Upload 690 files

.gitattributes

@@ -33,3 +33,33 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+autodE/source/autode/common/hessians.pdf filter=lfs diff=lfs merge=lfs -text
+autodE/source/autode/common/llogo.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/autode/common/logo.pages filter=lfs diff=lfs merge=lfs -text
+autodE/source/autode/common/NEB.pdf filter=lfs diff=lfs merge=lfs -text
+autodE/source/autode/common/thermochemistry.pdf filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/adapt_surface_sn2.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/claisen_neb_optimised.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/conformers.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/curtius_ts.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/curtius.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/DA_surface_interpolated.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/DA_surface.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/diels_alder_quickstart.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/diels_alder.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/functionalisation.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/logo.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/molfunc_functionalisation.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/na_h2o_3_confomers.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/OH_PES_relaxed.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/OH_PES_unrelaxed_DFT.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/OH_PES_unrelaxed.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/opt_convergence_3500_ORCA.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/sn2_image.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/vaskas_conformers.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/vaskas.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/water_opt_energy.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/water_shift.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/water_trimer_expl.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/water_trimer.png filter=lfs diff=lfs merge=lfs -text
+autodE/source/doc/common/XY_bde_XTB.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "autodE/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,32 @@
 ---
-title: AutodE
-emoji: 😻
-colorFrom: red
-colorTo: yellow
+title: Autode MCP
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
+sdk_version: "4.26.0"
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Autode MCP Service
+
+Auto-generated MCP service for autodE.
+
+## Usage
+
+```
+https://None-autodE-mcp.hf.space/mcp
+```
+
+## Connect with Cursor
+
+```json
+{
+  "mcpServers": {
+    "autodE": {
+      "url": "https://None-autodE-mcp.hf.space/mcp"
+    }
+  }
+}
+```

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "autodE", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Autode MCP Service",
+    description="Auto-generated MCP service for autodE",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Autode MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "autodE MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

autodE/mcp_output/README_MCP.md

@@ -0,0 +1,59 @@
+# autodE
+
+## Project Introduction
+
+autodE is a Python module designed for the automated calculation of reaction profiles from SMILES strings of reactants and products. It automates the complex process of finding transition states, performing conformer searches, and generating complete reaction energy profiles using quantum chemical calculations. The core functionalities include handling atomic properties, managing quantum chemical calculations, defining and analyzing chemical reactions, and optimizing transition states.
+
+## Installation Method
+
+To install autodE, ensure you have Python installed and then use the following pip command:
+
+```
+pip install autodE
+```
+
+### Dependencies
+
+autodE requires the following dependencies:
+- Required: numpy, scipy, ase
+- Optional: matplotlib, pandas
+
+Ensure these dependencies are installed in your environment.
+
+## Quick Start
+
+Here's a simple example to get started with autodE:
+
+1. Import autodE and define reactants and products using SMILES strings.
+2. Create a Reaction object and calculate the reaction profile.
+
+```
+import autode as ade
+
+# Define reactants and products
+reactant = ade.Reactant(smiles='CC[H]')
+product = ade.Product(smiles='C[H]C')
+
+# Create reaction and calculate profile
+reaction = ade.Reaction(reactant, product, name='1-2_shift')
+reaction.calculate_reaction_profile()
+```
+
+This high-level interface abstracts the complexity of transition state location, conformer generation, and thermochemical analysis while providing full control over the underlying quantum chemical calculations.
+
+## Available Tools and Endpoints List
+
+- **autode-calculate**: Runs a quantum chemical calculation using specified parameters.
+- **autode-reaction**: Analyzes a chemical reaction and computes its properties.
+
+## Common Issues and Notes
+
+- Ensure all required dependencies are installed to avoid import errors.
+- The performance of calculations can be affected by the computational resources available. Adjust the number of cores and memory settings in the configuration if necessary.
+- If using optional dependencies like matplotlib or pandas, ensure they are installed for enhanced functionality such as plotting and data manipulation.
+
+## Reference Links or Documentation
+
+For more detailed information, visit the autodE GitHub repository: [autodE GitHub](https://github.com/duartegroup/autodE)
+
+For comprehensive documentation, refer to the autodE documentation available in the repository.

autodE/mcp_output/analysis.json

@@ -0,0 +1,992 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/duartegroup/autodE",
+    "summary": "Imported via zip fallback, file count: 275",
+    "file_tree": {
+      ".github/ISSUE_TEMPLATE/bug_report.md": {
+        "size": 567
+      },
+      ".github/ISSUE_TEMPLATE/feature_request.md": {
+        "size": 194
+      },
+      ".github/pull_request_template.md": {
+        "size": 273
+      },
+      ".github/workflows/catch.yml": {
+        "size": 651
+      },
+      ".github/workflows/deploy.yml": {
+        "size": 824
+      },
+      ".github/workflows/lint.yml": {
+        "size": 683
+      },
+      ".github/workflows/pytest.yml": {
+        "size": 1191
+      },
+      ".github/workflows/pytest_cov.yml": {
+        "size": 1396
+      },
+      ".pre-commit-config.yaml": {
+        "size": 446
+      },
+      "CONTRIBUTING.md": {
+        "size": 228
+      },
+      "LICENSE.md": {
+        "size": 1067
+      },
+      "README.md": {
+        "size": 4804
+      },
+      "autode/__init__.py": {
+        "size": 1744
+      },
+      "autode/atoms.py": {
+        "size": 46059
+      },
+      "autode/bond_rearrangement.py": {
+        "size": 28652
+      },
+      "autode/bonds.py": {
+        "size": 2554
+      },
+      "autode/bracket/__init__.py": {
+        "size": 70
+      },
+      "autode/bracket/base.py": {
+        "size": 11755
+      },
+      "autode/bracket/dhs.py": {
+        "size": 28076
+      },
+      "autode/bracket/ieip.py": {
+        "size": 22489
+      },
+      "autode/bracket/imagepair.py": {
+        "size": 21276
+      },
+      "autode/calculations/__init__.py": {
+        "size": 236
+      },
+      "autode/calculations/calculation.py": {
+        "size": 10489
+      },
+      "autode/calculations/executors.py": {
+        "size": 18044
+      },
+      "autode/calculations/input.py": {
+        "size": 2394
+      },
+      "autode/calculations/output.py": {
+        "size": 2371
+      },
+      "autode/calculations/types.py": {
+        "size": 167
+      },
+      "autode/config.py": {
+        "size": 19291
+      },
+      "autode/conformers/__init__.py": {
+        "size": 141
+      },
+      "autode/conformers/conf_gen.py": {
+        "size": 16976
+      },
+      "autode/conformers/conformer.py": {
+        "size": 5866
+      },
+      "autode/conformers/conformers.py": {
+        "size": 12027
+      },
+      "autode/constants.py": {
+        "size": 965
+      },
+      "autode/constraints.py": {
+        "size": 5418
+      },
+      "autode/exceptions.py": {
+        "size": 4054
+      },
+      "autode/ext/CMakeLists.txt": {
+        "size": 941
+      },
+      "autode/ext/README.md": {
+        "size": 374
+      },
+      "autode/ext/__init__.py": {
+        "size": 0
+      },
+      "autode/geom.py": {
+        "size": 9283
+      },
+      "autode/hessians.py": {
+        "size": 23080
+      },
+      "autode/input_output.py": {
+        "size": 5343
+      },
+      "autode/log/__init__.py": {
+        "size": 57
+      },
+      "autode/log/log.py": {
+        "size": 2015
+      },
+      "autode/log/methods.py": {
+        "size": 1210
+      },
+      "autode/methods.py": {
+        "size": 4468
+      },
+      "autode/mol_graphs.py": {
+        "size": 24611
+      },
+      "autode/neb/__init__.py": {
+        "size": 96
+      },
+      "autode/neb/ci.py": {
+        "size": 3882
+      },
+      "autode/neb/idpp.py": {
+        "size": 5325
+      },
+      "autode/neb/neb.py": {
+        "size": 1899
+      },
+      "autode/neb/original.py": {
+        "size": 25297
+      },
+      "autode/opt/__init__.py": {
+        "size": 164
+      },
+      "autode/opt/coordinates/__init__.py": {
+        "size": 184
+      },
+      "autode/opt/coordinates/_autodiff.py": {
+        "size": 24107
+      },
+      "autode/opt/coordinates/base.py": {
+        "size": 14924
+      },
+      "autode/opt/coordinates/cartesian.py": {
+        "size": 4114
+      },
+      "autode/opt/coordinates/dic.py": {
+        "size": 18255
+      },
+      "autode/opt/coordinates/dimer.py": {
+        "size": 8581
+      },
+      "autode/opt/coordinates/internals.py": {
+        "size": 19160
+      },
+      "autode/opt/coordinates/primitives.py": {
+        "size": 19426
+      },
+      "autode/opt/optimisers/__init__.py": {
+        "size": 565
+      },
+      "autode/opt/optimisers/base.py": {
+        "size": 43844
+      },
+      "autode/opt/optimisers/crfo.py": {
+        "size": 9294
+      },
+      "autode/opt/optimisers/dimer.py": {
+        "size": 13546
+      },
+      "autode/opt/optimisers/hessian_update.py": {
+        "size": 17503
+      },
+      "autode/opt/optimisers/prfo.py": {
+        "size": 4780
+      },
+      "autode/opt/optimisers/qa.py": {
+        "size": 4388
+      },
+      "autode/opt/optimisers/rfo.py": {
+        "size": 5307
+      },
+      "autode/opt/optimisers/steepest_descent.py": {
+        "size": 1992
+      },
+      "autode/opt/optimisers/utils.py": {
+        "size": 5039
+      },
+      "autode/path/__init__.py": {
+        "size": 117
+      },
+      "autode/path/adaptive.py": {
+        "size": 12943
+      },
+      "autode/path/interpolation.py": {
+        "size": 8476
+      },
+      "autode/path/path.py": {
+        "size": 5925
+      },
+      "autode/pes/__init__.py": {
+        "size": 139
+      },
+      "autode/pes/mep.py": {
+        "size": 1239
+      },
+      "autode/pes/pes_nd.py": {
+        "size": 29328
+      },
+      "autode/pes/reactive.py": {
+        "size": 13627
+      },
+      "autode/pes/relaxed.py": {
+        "size": 7520
+      },
+      "autode/pes/unrelaxed.py": {
+        "size": 4701
+      },
+      "autode/plotting.py": {
+        "size": 16231
+      },
+      "autode/point_charges.py": {
+        "size": 1084
+      },
+      "autode/reactions/__init__.py": {
+        "size": 150
+      },
+      "autode/reactions/multistep.py": {
+        "size": 7474
+      },
+      "autode/reactions/reaction.py": {
+        "size": 32095
+      },
+      "autode/reactions/reaction_types.py": {
+        "size": 2720
+      },
+      "autode/smiles/__init__.py": {
+        "size": 115
+      },
+      "autode/smiles/angles.py": {
+        "size": 9039
+      },
+      "autode/smiles/atom_types.py": {
+        "size": 12856
+      },
+      "autode/smiles/base.py": {
+        "size": 8439
+      },
+      "autode/smiles/builder.py": {
+        "size": 36448
+      },
+      "autode/smiles/parser.py": {
+        "size": 18540
+      },
+      "autode/smiles/smiles.py": {
+        "size": 5932
+      },
+      "autode/solvent/__init__.py": {
+        "size": 211
+      },
+      "autode/solvent/explicit_solvent.py": {
+        "size": 8622
+      },
+      "autode/solvent/solvents.py": {
+        "size": 65287
+      },
+      "autode/species/__init__.py": {
+        "size": 522
+      },
+      "autode/species/complex.py": {
+        "size": 15627
+      },
+      "autode/species/molecule.py": {
+        "size": 9914
+      },
+      "autode/species/species.py": {
+        "size": 54754
+      },
+      "autode/substitution.py": {
+        "size": 10025
+      },
+      "autode/thermochemistry/__init__.py": {
+        "size": 177
+      },
+      "autode/thermochemistry/igm.py": {
+        "size": 17425
+      },
+      "autode/thermochemistry/symmetry.py": {
+        "size": 8040
+      },
+      "autode/transition_states/__init__.py": {
+        "size": 258
+      },
+      "autode/transition_states/base.py": {
+        "size": 19578
+      },
+      "autode/transition_states/lib/template0.txt": {
+        "size": 497
+      },
+      "autode/transition_states/locate_tss.py": {
+        "size": 12006
+      },
+      "autode/transition_states/templates.py": {
+        "size": 14335
+      },
+      "autode/transition_states/transition_state.py": {
+        "size": 13849
+      },
+      "autode/transition_states/transition_states.py": {
+        "size": 863
+      },
+      "autode/transition_states/truncation.py": {
+        "size": 11766
+      },
+      "autode/transition_states/ts_guess.py": {
+        "size": 8954
+      },
+      "autode/units.py": {
+        "size": 7919
+      },
+      "autode/utils.py": {
+        "size": 22566
+      },
+      "autode/values.py": {
+        "size": 23224
+      },
+      "autode/wrappers/G09.py": {
+        "size": 24012
+      },
+      "autode/wrappers/G16.py": {
+        "size": 503
+      },
+      "autode/wrappers/MOPAC.py": {
+        "size": 12114
+      },
+      "autode/wrappers/NWChem.py": {
+        "size": 15218
+      },
+      "autode/wrappers/ORCA.py": {
+        "size": 20640
+      },
+      "autode/wrappers/QChem.py": {
+        "size": 20416
+      },
+      "autode/wrappers/XTB.py": {
+        "size": 14414
+      },
+      "autode/wrappers/__init__.py": {
+        "size": 0
+      },
+      "autode/wrappers/keywords/__init__.py": {
+        "size": 1238
+      },
+      "autode/wrappers/keywords/basis_sets.py": {
+        "size": 1051
+      },
+      "autode/wrappers/keywords/dispersion.py": {
+        "size": 226
+      },
+      "autode/wrappers/keywords/functionals.py": {
+        "size": 662
+      },
+      "autode/wrappers/keywords/implicit_solvent_types.py": {
+        "size": 358
+      },
+      "autode/wrappers/keywords/keywords.py": {
+        "size": 19880
+      },
+      "autode/wrappers/keywords/ri.py": {
+        "size": 146
+      },
+      "autode/wrappers/keywords/wf.py": {
+        "size": 92
+      },
+      "autode/wrappers/methods.py": {
+        "size": 10180
+      },
+      "doc/README.md": {
+        "size": 318
+      },
+      "doc/common/DA_2d.py": {
+        "size": 368
+      },
+      "doc/common/DA_2d_interp.py": {
+        "size": 134
+      },
+      "doc/common/OH_PES_relaxed.py": {
+        "size": 614
+      },
+      "doc/common/OH_PES_unrelaxed.py": {
+        "size": 667
+      },
+      "doc/common/OH_PES_unrelaxed_DFT.py": {
+        "size": 734
+      },
+      "doc/common/XY_bde_XTB.py": {
+        "size": 2167
+      },
+      "doc/common/claisen_cineb.py": {
+        "size": 505
+      },
+      "doc/common/curtius.py": {
+        "size": 169
+      },
+      "doc/common/methane_molfunc.py": {
+        "size": 409
+      },
+      "doc/common/na_h2o_3.py": {
+        "size": 460
+      },
+      "doc/common/nci_FF_example.py": {
+        "size": 3894
+      },
+      "doc/common/rmsd.py": {
+        "size": 2490
+      },
+      "doc/common/vaskas_conformers.py": {
+        "size": 1013
+      },
+      "doc/common/water_trimer.py": {
+        "size": 681
+      },
+      "doc/conf.py": {
+        "size": 1617
+      },
+      "doc/requirements.txt": {
+        "size": 25
+      },
+      "examples/README.md": {
+        "size": 343
+      },
+      "examples/diels_alder.py": {
+        "size": 134
+      },
+      "examples/sn2.py": {
+        "size": 159
+      },
+      "examples/tutorials/a_atoms.py": {
+        "size": 995
+      },
+      "examples/tutorials/b_atom_collections.py": {
+        "size": 655
+      },
+      "examples/tutorials/c_species.py": {
+        "size": 980
+      },
+      "examples/tutorials/d_solvated_species.py": {
+        "size": 741
+      },
+      "examples/tutorials/e_molecules.py": {
+        "size": 1409
+      },
+      "examples/tutorials/f_molecule_io.py": {
+        "size": 1304
+      },
+      "examples/tutorials/g_conformers.py": {
+        "size": 1427
+      },
+      "examples/tutorials/h_configuration.py": {
+        "size": 1321
+      },
+      "examples/tutorials/i_constrained_opt.py": {
+        "size": 1475
+      },
+      "examples/tutorials/j_NEB.py": {
+        "size": 965
+      },
+      "examples/tutorials/k_1d_pes.py": {
+        "size": 755
+      },
+      "examples/tutorials/l_2d_pes.py": {
+        "size": 860
+      },
+      "examples/tutorials/m_thermochem.py": {
+        "size": 867
+      },
+      "examples/tutorials/n_normal_modes.py": {
+        "size": 921
+      },
+      "examples/tutorials/o_transition_states.py": {
+        "size": 1088
+      },
+      "examples/tutorials/p_reaction_profile1.py": {
+        "size": 718
+      },
+      "examples/tutorials/q_reaction_profile2.py": {
+        "size": 1065
+      },
+      "examples/tutorials/r_hessians.py": {
+        "size": 547
+      },
+      "examples/tutorials/s_logging.py": {
+        "size": 543
+      },
+      "examples/tutorials/t_identity_reactions.py": {
+        "size": 842
+      },
+      "examples/tutorials/u_reaction_profile_reload.py": {
+        "size": 863
+      },
+      "pyproject.toml": {
+        "size": 366
+      },
+      "requirements.txt": {
+        "size": 64
+      },
+      "setup.py": {
+        "size": 2005
+      },
+      "tests/README.md": {
+        "size": 1601
+      },
+      "tests/__init__.py": {
+        "size": 0
+      },
+      "tests/benchmark.py": {
+        "size": 11598
+      },
+      "tests/conftest.py": {
+        "size": 740
+      },
+      "tests/data/benchmark/ADE_SM.txt": {
+        "size": 106
+      },
+      "tests/data/benchmark/ADE_SO.txt": {
+        "size": 482
+      },
+      "tests/data/test_subprocess.py": {
+        "size": 21
+      },
+      "tests/requirements.txt": {
+        "size": 34
+      },
+      "tests/test_atoms.py": {
+        "size": 13407
+      },
+      "tests/test_attack.py": {
+        "size": 2151
+      },
+      "tests/test_bond_rearrangement.py": {
+        "size": 17958
+      },
+      "tests/test_bracket/__init__.py": {
+        "size": 0
+      },
+      "tests/test_bracket/test_dhs.py": {
+        "size": 11627
+      },
+      "tests/test_bracket/test_ieip.py": {
+        "size": 5293
+      },
+      "tests/test_bracket/test_imagepair.py": {
+        "size": 10123
+      },
+      "tests/test_calculation.py": {
+        "size": 16185
+      },
+      "tests/test_comp_methods.py": {
+        "size": 741
+      },
+      "tests/test_complex.py": {
+        "size": 7841
+      },
+      "tests/test_conf_gen.py": {
+        "size": 10342
+      },
+      "tests/test_config.py": {
+        "size": 3871
+      },
+      "tests/test_conformers.py": {
+        "size": 11906
+      },
+      "tests/test_const_opt.py": {
+        "size": 748
+      },
+      "tests/test_constraints.py": {
+        "size": 3203
+      },
+      "tests/test_examples.py": {
+        "size": 2831
+      },
+      "tests/test_explicit_solvent.py": {
+        "size": 3735
+      },
+      "tests/test_g16.py": {
+        "size": 154
+      },
+      "tests/test_geom.py": {
+        "size": 3074
+      },
+      "tests/test_graphs.py": {
+        "size": 12383
+      },
+      "tests/test_hessian.py": {
+        "size": 30049
+      },
+      "tests/test_import.py": {
+        "size": 940
+      },
+      "tests/test_input_output.py": {
+        "size": 3916
+      },
+      "tests/test_locate_tss.py": {
+        "size": 2687
+      },
+      "tests/test_log.py": {
+        "size": 856
+      },
+      "tests/test_methods.py": {
+        "size": 3515
+      },
+      "tests/test_molecule.py": {
+        "size": 8215
+      },
+      "tests/test_multistep.py": {
+        "size": 4088
+      },
+      "tests/test_nci_complex.py": {
+        "size": 1044
+      },
+      "tests/test_neb.py": {
+        "size": 11578
+      },
+      "tests/test_opt/__init__.py": {
+        "size": 0
+      },
+      "tests/test_opt/molecules.py": {
+        "size": 2438
+      },
+      "tests/test_opt/setup.py": {
+        "size": 493
+      },
+      "tests/test_opt/test_autodiff.py": {
+        "size": 6118
+      },
+      "tests/test_opt/test_coordiantes.py": {
+        "size": 31278
+      },
+      "tests/test_opt/test_crfo.py": {
+        "size": 13397
+      },
+      "tests/test_opt/test_dimer.py": {
+        "size": 7715
+      },
+      "tests/test_opt/test_hessian_update.py": {
+        "size": 9860
+      },
+      "tests/test_opt/test_opt.py": {
+        "size": 18254
+      },
+      "tests/test_opt/test_opt_utils.py": {
+        "size": 2978
+      },
+      "tests/test_opt/test_prfo.py": {
+        "size": 3741
+      },
+      "tests/test_opt/test_qa.py": {
+        "size": 3301
+      },
+      "tests/test_opt/test_rfo.py": {
+        "size": 3062
+      },
+      "tests/test_path.py": {
+        "size": 9185
+      },
+      "tests/test_pes/__init__.py": {
+        "size": 0
+      },
+      "tests/test_pes/sample_pes.py": {
+        "size": 864
+      },
+      "tests/test_pes/test_base_class.py": {
+        "size": 3058
+      },
+      "tests/test_pes/test_calculate.py": {
+        "size": 1641
+      },
+      "tests/test_pes/test_load_save.py": {
+        "size": 2097
+      },
+      "tests/test_pes/test_mep.py": {
+        "size": 2958
+      },
+      "tests/test_pes/test_points.py": {
+        "size": 6631
+      },
+      "tests/test_pes/test_relaxed.py": {
+        "size": 6719
+      },
+      "tests/test_pes/test_rs.py": {
+        "size": 6049
+      },
+      "tests/test_pes/test_unrelaxed.py": {
+        "size": 2271
+      },
+      "tests/test_plotting.py": {
+        "size": 7230
+      },
+      "tests/test_point_charge.py": {
+        "size": 780
+      },
+      "tests/test_qrc.py": {
+        "size": 1362
+      },
+      "tests/test_rb_min.py": {
+        "size": 1579
+      },
+      "tests/test_reaction_class.py": {
+        "size": 17661
+      },
+      "tests/test_reaction_with_complexes.py": {
+        "size": 1233
+      },
+      "tests/test_reactions.py": {
+        "size": 1203
+      },
+      "tests/test_smiles_base.py": {
+        "size": 1190
+      },
+      "tests/test_smiles_builder.py": {
+        "size": 21622
+      },
+      "tests/test_smiles_parser.py": {
+        "size": 14277
+      },
+      "tests/test_sn2prime.py": {
+        "size": 2722
+      },
+      "tests/test_solvents.py": {
+        "size": 2315
+      },
+      "tests/test_species.py": {
+        "size": 20762
+      },
+      "tests/test_substitution.py": {
+        "size": 2411
+      },
+      "tests/test_thermochem.py": {
+        "size": 10114
+      },
+      "tests/test_truncation.py": {
+        "size": 7249
+      },
+      "tests/test_ts/__init__.py": {
+        "size": 0
+      },
+      "tests/test_ts/test_mode_checking.py": {
+        "size": 3312
+      },
+      "tests/test_ts/test_ts_adapt_neb.py": {
+        "size": 2762
+      },
+      "tests/test_ts/test_ts_base.py": {
+        "size": 1668
+      },
+      "tests/test_ts/test_ts_guess.py": {
+        "size": 370
+      },
+      "tests/test_ts/test_ts_template.py": {
+        "size": 7961
+      },
+      "tests/test_units.py": {
+        "size": 753
+      },
+      "tests/test_utils.py": {
+        "size": 12326
+      },
+      "tests/test_value.py": {
+        "size": 7621
+      },
+      "tests/test_values.py": {
+        "size": 3635
+      },
+      "tests/test_wrappers/__init__.py": {
+        "size": 0
+      },
+      "tests/test_wrappers/test_gaussian.py": {
+        "size": 13535
+      },
+      "tests/test_wrappers/test_keywords.py": {
+        "size": 6887
+      },
+      "tests/test_wrappers/test_mopac.py": {
+        "size": 9087
+      },
+      "tests/test_wrappers/test_nwchem.py": {
+        "size": 7848
+      },
+      "tests/test_wrappers/test_orca.py": {
+        "size": 12660
+      },
+      "tests/test_wrappers/test_qchem.py": {
+        "size": 16267
+      },
+      "tests/test_wrappers/test_wrappers.py": {
+        "size": 344
+      },
+      "tests/test_wrappers/test_xtb.py": {
+        "size": 12198
+      },
+      "tests/testutils.py": {
+        "size": 1682
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.autode",
+      "source.autode.bracket",
+      "source.autode.calculations",
+      "source.autode.conformers",
+      "source.autode.ext",
+      "source.autode.log",
+      "source.autode.neb",
+      "source.autode.opt",
+      "source.autode.path",
+      "source.autode.pes",
+      "source.autode.reactions",
+      "source.autode.smiles",
+      "source.autode.solvent",
+      "source.autode.species",
+      "source.autode.thermochemistry",
+      "source.autode.transition_states",
+      "source.autode.wrappers",
+      "source.tests",
+      "source.tests.test_bracket",
+      "source.tests.test_opt",
+      "source.tests.test_pes",
+      "source.tests.test_ts",
+      "source.tests.test_wrappers"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": true,
+    "pyproject": true,
+    "setup_cfg": false,
+    "setup_py": true
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "source.autode.atoms",
+        "module": "atoms",
+        "functions": [
+          "get_distance",
+          "get_angle"
+        ],
+        "classes": [
+          "Atom",
+          "Atoms"
+        ],
+        "description": "Handles atomic properties and operations."
+      },
+      {
+        "package": "source.autode.calculations",
+        "module": "calculation",
+        "functions": [
+          "run_calculation",
+          "parse_output"
+        ],
+        "classes": [
+          "Calculation",
+          "CalculationExecutor"
+        ],
+        "description": "Manages quantum chemical calculations and their execution."
+      },
+      {
+        "package": "source.autode.reactions",
+        "module": "reaction",
+        "functions": [
+          "find_reaction_path",
+          "calculate_reaction_energy"
+        ],
+        "classes": [
+          "Reaction",
+          "ReactionPath"
+        ],
+        "description": "Defines and analyzes chemical reactions."
+      },
+      {
+        "package": "source.autode.transition_states",
+        "module": "transition_state",
+        "functions": [
+          "locate_ts",
+          "optimize_ts"
+        ],
+        "classes": [
+          "TransitionState",
+          "TSOptimizer"
+        ],
+        "description": "Handles transition state search and optimization."
+      },
+      {
+        "package": "source.autode.wrappers",
+        "module": "G09",
+        "functions": [
+          "execute_g09",
+          "parse_g09_output"
+        ],
+        "classes": [
+          "G09Wrapper"
+        ],
+        "description": "Interface for Gaussian09 quantum chemistry software."
+      }
+    ],
+    "cli_commands": [
+      {
+        "name": "autode-calculate",
+        "module": "source.autode.calculations.calculation",
+        "description": "Runs a quantum chemical calculation using specified parameters."
+      },
+      {
+        "name": "autode-reaction",
+        "module": "source.autode.reactions.reaction",
+        "description": "Analyzes a chemical reaction and computes its properties."
+      }
+    ],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.85
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "scipy",
+        "ase"
+      ],
+      "optional": [
+        "matplotlib",
+        "pandas"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "medium",
+      "complexity": "complex"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/duartegroup/autodE",
+    "repo_name": "autodE",
+    "content": "duartegroup/autodE\nCore Architecture\nChemical Species and Atoms\nReactions and Bond Rearrangements\nConfiguration System\nTransition State Analysis\nTransition State Location Methods\nTS Validation and Optimization\nMolecular Graphs and Connectivity\nBracketing Methods\nElectronic Structure Interface\nMethod Wrappers\nCalculations and Executors\nKeywords and Thermochemistry\nGeometry Optimization\nCoordinate Systems\nOptimization Algorithms\nConformer Generation\nConformer Generation Algorithms\nConformer Management\nAdditional Systems\nSMILES Processing\nMolecular Truncation\nExplicit Solvation\nPlotting and Visualization\nUtilities and Development\nCore Utilities\nTesting and CI/CD\nautode/__init__.py\nautode/transition_states/templates.py\ndoc/changelog.rst\ndoc/config.rst\ndoc/index.rst\ndoc/install.rst\ndoc/troubleshooting.rst\nexamples/README.md\nPurpose and Scope\nautodE is a Python module designed for the automated calculation of reaction profiles from SMILES strings of reactants and products. This system automates the complex process of finding transition states, performing conformer searches, and generating complete reaction energy profiles using quantum chemical calculations.\nThis overview provides a high-level architectural understanding of autodE's core systems and their interactions. For detailed information about specific subsystems, seeCore Architecture,Transition State Analysis,Electronic Structure Interface, andGeometry Optimization.\nSources:README.md7-11doc/index.rst13-16autode/__init__.py1-71\nCore Workflow and Concepts\nautodE follows a double-ended search approach, starting from reactant and product structures to automatically locate transition states and generate reaction profiles. The typical workflow involves:\nInput Processing: Users provide reactants and products as SMILES strings or 3D structures\nBond Rearrangement Analysis: The system identifies which bonds form and break during the reaction\nTransition State Location: Multiple algorithms search for saddle points connecting reactants to products\nProfile Generation: Complete energy profiles are calculated with conformer searching and thermochemistry\nUser InputReactant/Product SMILESBond Rearrangement Analysisautode.reactions.bond_rearrangementTransition State Locationautode.transition_statesReaction Profile Generationautode.reactions.reactionTemplate Matchingautode.transition_states.templatesAdaptive Path Searchautode.pathNEB Calculationsautode.nebConformer Generationautode.conformersThermochemistryautode.thermochemistryFinal ResultsEnergy profiles & structures\nUser InputReactant/Product SMILES\nBond Rearrangement Analysisautode.reactions.bond_rearrangement\nTransition State Locationautode.transition_states\nReaction Profile Generationautode.reactions.reaction\nTemplate Matchingautode.transition_states.templates\nAdaptive Path Searchautode.path\nNEB Calculationsautode.neb\nConformer Generationautode.conformers\nThermochemistryautode.thermochemistry\nFinal ResultsEnergy profiles & structures\nSources:README.md41-50doc/changelog.rst756-784autode/reactions/reaction.py\nHigh-Level System Architecture\nThe autodE architecture consists of several interconnected layers that handle different aspects of the reaction profile calculation workflow:\nExternal ProgramsElectronic Structure InterfaceOptimization FrameworkTransition State EngineReaction Analysis EngineCore Chemical RepresentationUser InterfaceCommand Line InterfacePython APIautode.Reactionautode.MoleculeConfiguration Systemautode.config.ConfigChemical Speciesautode.species.Speciesautode.species.molecule.MoleculeAtomic Dataautode.atoms.Atomautode.atoms.AtomsCoordinate Systemsautode.opt.coordinatesReaction Objectsautode.reactions.reaction.ReactionBond Rearrangementsautode.reactions.bond_rearrangementMolecular Graphsautode.mol_graphsTS Locationautode.transition_statesTS Templatesautode.transition_states.templatesBracketing Methodsautode.bracketGeometry Optimizersautode.opt.optimisersNEB Methodsautode.nebPath Optimizationautode.pathCalculation Managerautode.calculations.CalculationMethod Wrappersautode.wrappersKeyword Managementautode.wrappers.keywordsORCAautode.wrappers.ORCAGaussianautode.wrappers.G09/G16XTBautode.wrappers.XTBMOPACautode.wrappers.MOPAC\nExternal Programs\nElectronic Structure Interface\nOptimization Framework\nTransition State Engine\nReaction Analysis Engine\nCore Chemical Representation\nUser Interface\nCommand Line Interface\nPython APIautode.Reactionautode.Molecule\nConfiguration Systemautode.config.Config\nChemical Speciesautode.species.Speciesautode.species.molecule.Molecule\nAtomic Dataautode.atoms.Atomautode.atoms.Atoms\nCoordinate Systemsautode.opt.coordinates\nReaction Objectsautode.reactions.reaction.Reaction\nBond Rearrangementsautode.reactions.bond_rearrangement\nMolecular Graphsautode.mol_graphs\nTS Locationautode.transition_states\nTS Templatesautode.transition_states.templates\nBracketing Methodsautode.bracket\nGeometry Optimizersautode.opt.optimisers\nNEB Methodsautode.neb\nPath Optimizationautode.path\nCalculation Managerautode.calculations.Calculation\nMethod Wrappersautode.wrappers\nKeyword Managementautode.wrappers.keywords\nORCAautode.wrappers.ORCA\nGaussianautode.wrappers.G09/G16\nXTBautode.wrappers.XTB\nMOPACautode.wrappers.MOPAC\nSources:autode/__init__.py44-71setup.py37-57doc/changelog.rst overall system diagrams\nKey Components\nChemical Species and Data Structures\nThe foundation of autodE rests on robust chemical data structures that represent atoms, molecules, and their properties:\nautode.atoms.Atom\nautode.species.molecule.Molecule\nautode.species.molecule.Reactant\nautode.species.molecule.Product\nautode.species.complex.NCIComplex\nSources:autode/__init__.py14-16autode/species/autode/atoms.py\nReaction Processing\nThe reaction analysis system identifies chemical changes and guides transition state searches:\nautode.reactions.reaction.Reactionautode.reactions.bond_rearrangement.BondRearrangementautode.mol_graphs.MolecularGraphautode.transition_states.ts_guess.TSguessautode.transition_states.transition_state.TransitionState\nautode.reactions.reaction.Reaction\nautode.reactions.bond_rearrangement.BondRearrangement\nautode.mol_graphs.MolecularGraph\nautode.transition_states.ts_guess.TSguess\nautode.transition_states.transition_state.TransitionState\nSources:autode/reactions/autode/mol_graphs/autode/transition_states/\nElectronic Structure Integration\nautodE provides a unified interface to multiple quantum chemistry packages through method wrappers:\nautode.wrappers.ORCA\nautode.wrappers.G09\nautode.wrappers.G16\nautode.wrappers.XTB\nautode.wrappers.MOPAC\nautode.wrappers.NWChem\nautode.wrappers.QChem\nSources:README.md15-24autode/wrappers/doc/install.rst10-22\nConfiguration and Extensibility\nThe system is highly configurable through theautode.config.Configclass, which manages:\nautode.config.Config\nElectronic structure method selection and keywords\nOptimization parameters and convergence criteria\nParallel execution settings\nTemplate libraries for transition state finding\nLogging and output control\nautode.config.ConfigMethod ConfigurationConfig.ORCA, Config.XTB, etc.Keyword ManagementConfig.keywordsCore Settingsn_cores, max_core, etc.Optimization Keywordsautode.wrappers.keywords.OptKeywordsSingle Point Keywordsautode.wrappers.keywords.SinglePointKeywordsHessian Keywordsautode.wrappers.keywords.HessianKeywords\nautode.config.Config\nMethod ConfigurationConfig.ORCA, Config.XTB, etc.\nKeyword ManagementConfig.keywords\nCore Settingsn_cores, max_core, etc.\nOptimization Keywordsautode.wrappers.keywords.OptKeywords\nSingle Point Keywordsautode.wrappers.keywords.SinglePointKeywords\nHessian Keywordsautode.wrappers.keywords.HessianKeywords\nSources:autode/config.pydoc/config.rst1-217autode/wrappers/keywords/\nUsage Patterns\nThe primary usage pattern involves creatingReactionobjects from reactants and products, then invoking the automated workflow:\nimportautodeasade# Define reactants and productsreactant = ade.Reactant(smiles='CC<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>[H]')product = ade.Product(smiles='C<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>C')# Create reaction and calculate profilereaction = ade.Reaction(reactant, product, name='1-2_shift')reaction.calculate_reaction_profile()\nimportautodeasade# Define reactants and productsreactant = ade.Reactant(smiles='CC<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>[H]')product = ade.Product(smiles='C<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>C')# Create reaction and calculate profilereaction = ade.Reaction(reactant, product, name='1-2_shift')reaction.calculate_reaction_profile()\nimportautodeasade# Define reactants and productsreactant = ade.Reactant(smiles='CC<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>[H]')product = ade.Product(smiles='C<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>C')# Create reaction and calculate profilereaction = ade.Reaction(reactant, product, name='1-2_shift')reaction.calculate_reaction_profile()\nThis high-level interface abstracts the complexity of transition state location, conformer generation, and thermochemical analysis while providing full control over the underlying quantum chemical calculations.\nSources:README.md41-50examples/README.md1-8doc/quickstart.rst examples\nRefresh this wiki\nOn this page\nPurpose and Scope\nCore Workflow and Concepts\nHigh-Level System Architecture\nKey Components\nChemical Species and Data Structures\nReaction Processing\nElectronic Structure Integration\nConfiguration and Extensibility\nUsage Patterns",
+    "model": "gpt-4o-2024-08-06",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o-2024-08-06"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "medium",
+    "complexity": "complex"
+  }
+}

autodE/mcp_output/diff_report.md

@@ -0,0 +1,68 @@
+# autodE Project Difference Report
+
+**Repository:** autodE  
+**Project Type:** Python Library  
+**Report Date:** February 4, 2026  
+**Time:** 13:19:49  
+**Intrusiveness:** None  
+**Workflow Status:** Success  
+**Test Status:** Failed  
+
+## Project Overview
+
+The autodE project is a Python library designed to provide basic functionality for computational chemistry tasks. The library aims to simplify the process of setting up and running quantum chemistry calculations, making it accessible to a broader audience of researchers and developers.
+
+## Difference Analysis
+
+### New Files
+
+Since the last update, the autodE project has introduced 8 new files. These files likely contain new features or enhancements to existing functionalities. However, no existing files have been modified, indicating that the new additions are likely standalone features or modules.
+
+### Modified Files
+
+There are no modified files in this update, suggesting that the existing codebase remains unchanged. This could imply that the new files are designed to extend the library's capabilities without altering the current functionality.
+
+### Workflow and Test Status
+
+- **Workflow Status:** The workflow status is marked as successful, indicating that the integration and deployment processes were executed without errors.
+- **Test Status:** The test status is marked as failed, which suggests that the new additions may have introduced issues or that the existing test suite does not cover the new functionalities adequately.
+
+## Technical Analysis
+
+The introduction of 8 new files without modifications to existing ones suggests a modular approach to extending the library. This approach minimizes the risk of introducing bugs into the existing codebase but requires thorough testing to ensure compatibility and functionality of the new modules.
+
+The failure in the test status indicates potential issues that need to be addressed. These could range from integration problems with the new files to inadequacies in the test coverage for the new functionalities.
+
+## Recommendations and Improvements
+
+1. **Enhance Test Coverage:** 
+   - Develop comprehensive test cases for the new files to ensure they function as expected.
+   - Review and update the existing test suite to include scenarios that involve interactions between the new and existing functionalities.
+
+2. **Code Review and Refactoring:**
+   - Conduct a thorough code review of the new files to identify any potential issues or areas for optimization.
+   - Consider refactoring the new code to improve readability and maintainability.
+
+3. **Documentation Update:**
+   - Update the project documentation to include details about the new features and how they integrate with the existing library.
+   - Provide usage examples and guidelines for the new functionalities to assist users in adopting them effectively.
+
+## Deployment Information
+
+The successful workflow status indicates that the deployment process was executed without errors. However, given the test failures, it is advisable to hold off on deploying the new version to production until the issues are resolved.
+
+## Future Planning
+
+1. **Issue Resolution:**
+   - Prioritize resolving the test failures to ensure the stability and reliability of the library.
+   - Investigate the root causes of the test failures and implement necessary fixes.
+
+2. **Feature Expansion:**
+   - Plan for future updates that build upon the new functionalities, ensuring they align with the overall project goals and user needs.
+
+3. **Community Engagement:**
+   - Engage with the user community to gather feedback on the new features and identify any additional requirements or improvements.
+
+## Conclusion
+
+The autodE project has made significant strides with the addition of new files, potentially enhancing its functionality. However, the test failures highlight the need for further refinement and testing. By addressing these issues and enhancing documentation and community engagement, the project can continue to evolve and meet the needs of its users effectively.

autodE/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,248 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from autode.atoms import Atom, Atoms
+    from autode.reactions.reaction import Reaction
+    from autode.calculations.calculation import Calculation
+    from autode.transition_states.transition_state import TransitionState
+    from autode.wrappers.ORCA import ORCA
+    from autode.wrappers.G09 import G09
+    from autode.wrappers.G16 import G16
+    from autode.wrappers.XTB import XTB
+    from autode.wrappers.MOPAC import MOPAC
+    from autode.wrappers.NWChem import NWChem
+    from autode.wrappers.QChem import QChem
+except ImportError as e:
+    print(f"Import failed: {e}. Ensure all dependencies are installed and the source path is correct.")
+
+# Adapter class definition
+class Adapter:
+    """
+    Adapter class for MCP plugin, providing access to core functionalities
+    of the autodE package.
+    """
+
+    def __init__(self):
+        self.mode = "import"
+
+    # -------------------- Atom Module --------------------
+
+    def create_atom(self, element, x, y, z):
+        """
+        Create an Atom instance.
+
+        Parameters:
+        - element (str): Chemical symbol of the element.
+        - x (float): X-coordinate of the atom.
+        - y (float): Y-coordinate of the atom.
+        - z (float): Z-coordinate of the atom.
+
+        Returns:
+        - dict: Status and Atom instance or error message.
+        """
+        try:
+            atom = Atom(element, x, y, z)
+            return {"status": "success", "atom": atom}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create Atom: {e}"}
+
+    def create_atoms(self, atom_list):
+        """
+        Create an Atoms instance.
+
+        Parameters:
+        - atom_list (list): List of Atom instances.
+
+        Returns:
+        - dict: Status and Atoms instance or error message.
+        """
+        try:
+            atoms = Atoms(atom_list)
+            return {"status": "success", "atoms": atoms}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create Atoms: {e}"}
+
+    # -------------------- Reaction Module --------------------
+
+    def create_reaction(self, reactants, products, name):
+        """
+        Create a Reaction instance.
+
+        Parameters:
+        - reactants (list): List of reactant molecules.
+        - products (list): List of product molecules.
+        - name (str): Name of the reaction.
+
+        Returns:
+        - dict: Status and Reaction instance or error message.
+        """
+        try:
+            reaction = Reaction(reactants, products, name=name)
+            return {"status": "success", "reaction": reaction}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create Reaction: {e}"}
+
+    # -------------------- Calculation Module --------------------
+
+    def run_calculation(self, method, molecule):
+        """
+        Run a quantum chemical calculation.
+
+        Parameters:
+        - method (str): Calculation method (e.g., 'ORCA', 'G09').
+        - molecule (Molecule): Molecule instance to calculate.
+
+        Returns:
+        - dict: Status and Calculation result or error message.
+        """
+        try:
+            calculation = Calculation(method=method, molecule=molecule)
+            calculation.run()
+            return {"status": "success", "calculation": calculation}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to run Calculation: {e}"}
+
+    # -------------------- Transition State Module --------------------
+
+    def create_transition_state(self, reaction):
+        """
+        Create a TransitionState instance.
+
+        Parameters:
+        - reaction (Reaction): Reaction instance.
+
+        Returns:
+        - dict: Status and TransitionState instance or error message.
+        """
+        try:
+            ts = TransitionState(reaction)
+            return {"status": "success", "transition_state": ts}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create TransitionState: {e}"}
+
+    # -------------------- Wrapper Modules --------------------
+
+    def use_orca(self, molecule):
+        """
+        Use ORCA wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and ORCA result or error message.
+        """
+        try:
+            orca = ORCA(molecule)
+            orca.run()
+            return {"status": "success", "orca": orca}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use ORCA: {e}"}
+
+    def use_g09(self, molecule):
+        """
+        Use G09 wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and G09 result or error message.
+        """
+        try:
+            g09 = G09(molecule)
+            g09.run()
+            return {"status": "success", "g09": g09}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use G09: {e}"}
+
+    def use_g16(self, molecule):
+        """
+        Use G16 wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and G16 result or error message.
+        """
+        try:
+            g16 = G16(molecule)
+            g16.run()
+            return {"status": "success", "g16": g16}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use G16: {e}"}
+
+    def use_xtb(self, molecule):
+        """
+        Use XTB wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and XTB result or error message.
+        """
+        try:
+            xtb = XTB(molecule)
+            xtb.run()
+            return {"status": "success", "xtb": xtb}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use XTB: {e}"}
+
+    def use_mopac(self, molecule):
+        """
+        Use MOPAC wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and MOPAC result or error message.
+        """
+        try:
+            mopac = MOPAC(molecule)
+            mopac.run()
+            return {"status": "success", "mopac": mopac}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use MOPAC: {e}"}
+
+    def use_nwchem(self, molecule):
+        """
+        Use NWChem wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and NWChem result or error message.
+        """
+        try:
+            nwchem = NWChem(molecule)
+            nwchem.run()
+            return {"status": "success", "nwchem": nwchem}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use NWChem: {e}"}
+
+    def use_qchem(self, molecule):
+        """
+        Use QChem wrapper for calculations.
+
+        Parameters:
+        - molecule (Molecule): Molecule instance.
+
+        Returns:
+        - dict: Status and QChem result or error message.
+        """
+        try:
+            qchem = QChem(molecule)
+            qchem.run()
+            return {"status": "success", "qchem": qchem}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to use QChem: {e}"}

autodE/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

autodE/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,69 @@
+import os
+import sys
+
+# Add the local source directory to sys.path
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+from autode.atoms import Atom, Atoms
+from autode.calculations.calculation import Calculation
+from autode.reactions.reaction import Reaction
+
+# Create the FastMCP service application
+mcp = FastMCP("autode_service")
+
+@mcp.tool(name="atom_properties", description="Get properties of an atom")
+def atom_properties(element: str) -> dict:
+    """
+    Get properties of an atom given its element symbol.
+
+    :param element: The chemical symbol of the element (e.g., 'H', 'C', 'O')
+    :return: A dictionary with success, result, or error fields
+    """
+    try:
+        atom = Atom(element)
+        result = {
+            "mass": atom.mass,
+            "atomic_number": atom.atomic_number
+        }
+        return {"success": True, "result": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="calculate_reaction", description="Perform a quantum chemical calculation for a reaction")
+def calculate_reaction(reactant_smiles: str, product_smiles: str) -> dict:
+    """
+    Perform a quantum chemical calculation for a given reaction.
+
+    :param reactant_smiles: SMILES string of the reactant
+    :param product_smiles: SMILES string of the product
+    :return: A dictionary with success, result, or error fields
+    """
+    try:
+        reactant = Reaction.Reactant(smiles=reactant_smiles)
+        product = Reaction.Product(smiles=product_smiles)
+        reaction = Reaction(reactant, product)
+        calculation = Calculation(reaction)
+        calculation.run()
+        result = {
+            "energy": calculation.energy,
+            "status": calculation.status
+        }
+        return {"success": True, "result": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def create_app() -> FastMCP:
+    """
+    Create and return the FastMCP application instance.
+
+    :return: FastMCP instance
+    """
+    return mcp
+
+# Ensure the module can be run as a script
+if __name__ == "__main__":
+    app = create_app()
+    app.run()

autodE/mcp_output/requirements.txt

@@ -0,0 +1,13 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+rdkit
+numpy
+networkx
+matplotlib
+pillow>=9.5.0
+cython
+scipy
+loky
+ase

autodE/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

autodE/mcp_output/workflow_summary.json

@@ -0,0 +1,216 @@
+{
+  "repository": {
+    "name": "autodE",
+    "url": "https://github.com/duartegroup/autodE",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/autodE",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "complex",
+    "intrusiveness_risk": "medium"
+  },
+  "execution": {
+    "start_time": 1770182237.7316194,
+    "end_time": 1770182330.7397785,
+    "duration": 93.00815939903259,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 23,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.autode",
+        "source.autode.bracket",
+        "source.autode.calculations",
+        "source.autode.conformers",
+        "source.autode.ext",
+        "source.autode.log",
+        "source.autode.neb",
+        "source.autode.opt",
+        "source.autode.path",
+        "source.autode.pes",
+        "source.autode.reactions",
+        "source.autode.smiles",
+        "source.autode.solvent",
+        "source.autode.species",
+        "source.autode.thermochemistry",
+        "source.autode.transition_states",
+        "source.autode.wrappers",
+        "source.tests",
+        "source.tests.test_bracket",
+        "source.tests.test_opt",
+        "source.tests.test_pes",
+        "source.tests.test_ts",
+        "source.tests.test_wrappers"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": true,
+      "pyproject": true,
+      "setup_cfg": false,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "medium",
+      "complexity": "complex"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/duartegroup/autodE",
+      "repo_name": "autodE",
+      "content": "duartegroup/autodE\nCore Architecture\nChemical Species and Atoms\nReactions and Bond Rearrangements\nConfiguration System\nTransition State Analysis\nTransition State Location Methods\nTS Validation and Optimization\nMolecular Graphs and Connectivity\nBracketing Methods\nElectronic Structure Interface\nMethod Wrappers\nCalculations and Executors\nKeywords and Thermochemistry\nGeometry Optimization\nCoordinate Systems\nOptimization Algorithms\nConformer Generation\nConformer Generation Algorithms\nConformer Management\nAdditional Systems\nSMILES Processing\nMolecular Truncation\nExplicit Solvation\nPlotting and Visualization\nUtilities and Development\nCore Utilities\nTesting and CI/CD\nautode/__init__.py\nautode/transition_states/templates.py\ndoc/changelog.rst\ndoc/config.rst\ndoc/index.rst\ndoc/install.rst\ndoc/troubleshooting.rst\nexamples/README.md\nPurpose and Scope\nautodE is a Python module designed for the automated calculation of reaction profiles from SMILES strings of reactants and products. This system automates the complex process of finding transition states, performing conformer searches, and generating complete reaction energy profiles using quantum chemical calculations.\nThis overview provides a high-level architectural understanding of autodE's core systems and their interactions. For detailed information about specific subsystems, seeCore Architecture,Transition State Analysis,Electronic Structure Interface, andGeometry Optimization.\nSources:README.md7-11doc/index.rst13-16autode/__init__.py1-71\nCore Workflow and Concepts\nautodE follows a double-ended search approach, starting from reactant and product structures to automatically locate transition states and generate reaction profiles. The typical workflow involves:\nInput Processing: Users provide reactants and products as SMILES strings or 3D structures\nBond Rearrangement Analysis: The system identifies which bonds form and break during the reaction\nTransition State Location: Multiple algorithms search for saddle points connecting reactants to products\nProfile Generation: Complete energy profiles are calculated with conformer searching and thermochemistry\nUser InputReactant/Product SMILESBond Rearrangement Analysisautode.reactions.bond_rearrangementTransition State Locationautode.transition_statesReaction Profile Generationautode.reactions.reactionTemplate Matchingautode.transition_states.templatesAdaptive Path Searchautode.pathNEB Calculationsautode.nebConformer Generationautode.conformersThermochemistryautode.thermochemistryFinal ResultsEnergy profiles & structures\nUser InputReactant/Product SMILES\nBond Rearrangement Analysisautode.reactions.bond_rearrangement\nTransition State Locationautode.transition_states\nReaction Profile Generationautode.reactions.reaction\nTemplate Matchingautode.transition_states.templates\nAdaptive Path Searchautode.path\nNEB Calculationsautode.neb\nConformer Generationautode.conformers\nThermochemistryautode.thermochemistry\nFinal ResultsEnergy profiles & structures\nSources:README.md41-50doc/changelog.rst756-784autode/reactions/reaction.py\nHigh-Level System Architecture\nThe autodE architecture consists of several interconnected layers that handle different aspects of the reaction profile calculation workflow:\nExternal ProgramsElectronic Structure InterfaceOptimization FrameworkTransition State EngineReaction Analysis EngineCore Chemical RepresentationUser InterfaceCommand Line InterfacePython APIautode.Reactionautode.MoleculeConfiguration Systemautode.config.ConfigChemical Speciesautode.species.Speciesautode.species.molecule.MoleculeAtomic Dataautode.atoms.Atomautode.atoms.AtomsCoordinate Systemsautode.opt.coordinatesReaction Objectsautode.reactions.reaction.ReactionBond Rearrangementsautode.reactions.bond_rearrangementMolecular Graphsautode.mol_graphsTS Locationautode.transition_statesTS Templatesautode.transition_states.templatesBracketing Methodsautode.bracketGeometry Optimizersautode.opt.optimisersNEB Methodsautode.nebPath Optimizationautode.pathCalculation Managerautode.calculations.CalculationMethod Wrappersautode.wrappersKeyword Managementautode.wrappers.keywordsORCAautode.wrappers.ORCAGaussianautode.wrappers.G09/G16XTBautode.wrappers.XTBMOPACautode.wrappers.MOPAC\nExternal Programs\nElectronic Structure Interface\nOptimization Framework\nTransition State Engine\nReaction Analysis Engine\nCore Chemical Representation\nUser Interface\nCommand Line Interface\nPython APIautode.Reactionautode.Molecule\nConfiguration Systemautode.config.Config\nChemical Speciesautode.species.Speciesautode.species.molecule.Molecule\nAtomic Dataautode.atoms.Atomautode.atoms.Atoms\nCoordinate Systemsautode.opt.coordinates\nReaction Objectsautode.reactions.reaction.Reaction\nBond Rearrangementsautode.reactions.bond_rearrangement\nMolecular Graphsautode.mol_graphs\nTS Locationautode.transition_states\nTS Templatesautode.transition_states.templates\nBracketing Methodsautode.bracket\nGeometry Optimizersautode.opt.optimisers\nNEB Methodsautode.neb\nPath Optimizationautode.path\nCalculation Managerautode.calculations.Calculation\nMethod Wrappersautode.wrappers\nKeyword Managementautode.wrappers.keywords\nORCAautode.wrappers.ORCA\nGaussianautode.wrappers.G09/G16\nXTBautode.wrappers.XTB\nMOPACautode.wrappers.MOPAC\nSources:autode/__init__.py44-71setup.py37-57doc/changelog.rst overall system diagrams\nKey Components\nChemical Species and Data Structures\nThe foundation of autodE rests on robust chemical data structures that represent atoms, molecules, and their properties:\nautode.atoms.Atom\nautode.species.molecule.Molecule\nautode.species.molecule.Reactant\nautode.species.molecule.Product\nautode.species.complex.NCIComplex\nSources:autode/__init__.py14-16autode/species/autode/atoms.py\nReaction Processing\nThe reaction analysis system identifies chemical changes and guides transition state searches:\nautode.reactions.reaction.Reactionautode.reactions.bond_rearrangement.BondRearrangementautode.mol_graphs.MolecularGraphautode.transition_states.ts_guess.TSguessautode.transition_states.transition_state.TransitionState\nautode.reactions.reaction.Reaction\nautode.reactions.bond_rearrangement.BondRearrangement\nautode.mol_graphs.MolecularGraph\nautode.transition_states.ts_guess.TSguess\nautode.transition_states.transition_state.TransitionState\nSources:autode/reactions/autode/mol_graphs/autode/transition_states/\nElectronic Structure Integration\nautodE provides a unified interface to multiple quantum chemistry packages through method wrappers:\nautode.wrappers.ORCA\nautode.wrappers.G09\nautode.wrappers.G16\nautode.wrappers.XTB\nautode.wrappers.MOPAC\nautode.wrappers.NWChem\nautode.wrappers.QChem\nSources:README.md15-24autode/wrappers/doc/install.rst10-22\nConfiguration and Extensibility\nThe system is highly configurable through theautode.config.Configclass, which manages:\nautode.config.Config\nElectronic structure method selection and keywords\nOptimization parameters and convergence criteria\nParallel execution settings\nTemplate libraries for transition state finding\nLogging and output control\nautode.config.ConfigMethod ConfigurationConfig.ORCA, Config.XTB, etc.Keyword ManagementConfig.keywordsCore Settingsn_cores, max_core, etc.Optimization Keywordsautode.wrappers.keywords.OptKeywordsSingle Point Keywordsautode.wrappers.keywords.SinglePointKeywordsHessian Keywordsautode.wrappers.keywords.HessianKeywords\nautode.config.Config\nMethod ConfigurationConfig.ORCA, Config.XTB, etc.\nKeyword ManagementConfig.keywords\nCore Settingsn_cores, max_core, etc.\nOptimization Keywordsautode.wrappers.keywords.OptKeywords\nSingle Point Keywordsautode.wrappers.keywords.SinglePointKeywords\nHessian Keywordsautode.wrappers.keywords.HessianKeywords\nSources:autode/config.pydoc/config.rst1-217autode/wrappers/keywords/\nUsage Patterns\nThe primary usage pattern involves creatingReactionobjects from reactants and products, then invoking the automated workflow:\nimportautodeasade# Define reactants and productsreactant = ade.Reactant(smiles='CC<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>[H]')product = ade.Product(smiles='C<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>C')# Create reaction and calculate profilereaction = ade.Reaction(reactant, product, name='1-2_shift')reaction.calculate_reaction_profile()\nimportautodeasade# Define reactants and productsreactant = ade.Reactant(smiles='CC<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>[H]')product = ade.Product(smiles='C<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>C')# Create reaction and calculate profilereaction = ade.Reaction(reactant, product, name='1-2_shift')reaction.calculate_reaction_profile()\nimportautodeasade# Define reactants and productsreactant = ade.Reactant(smiles='CC<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>[H]')product = ade.Product(smiles='C<FileRef file-url=\"https://github.com/duartegroup/autodE/blob/e7e71b33/C\" undefined  file-path=\"C\">Hii</FileRef>C')# Create reaction and calculate profilereaction = ade.Reaction(reactant, product, name='1-2_shift')reaction.calculate_reaction_profile()\nThis high-level interface abstracts the complexity of transition state location, conformer generation, and thermochemical analysis while providing full control over the underlying quantum chemical calculations.\nSources:README.md41-50examples/README.md1-8doc/quickstart.rst examples\nRefresh this wiki\nOn this page\nPurpose and Scope\nCore Workflow and Concepts\nHigh-Level System Architecture\nKey Components\nChemical Species and Data Structures\nReaction Processing\nElectronic Structure Integration\nConfiguration and Extensibility\nUsage Patterns",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/autodE/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Improve test coverage by adding more unit tests for critical modules",
+    "streamline the import process to reduce complexity",
+    "enhance documentation for better clarity on core functionalities",
+    "optimize large files for better performance",
+    "implement continuous integration to automate testing and deployment",
+    "refactor code to improve readability and maintainability",
+    "ensure all dependencies are up-to-date and compatible",
+    "enhance error handling to improve robustness",
+    "consider adding more examples and tutorials for user guidance",
+    "improve logging for better traceability and debugging."
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Comprehensive workflow execution with all nodes completed successfully",
+      "Efficient processing of 23 files within a short duration"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "excellent",
+    "node_performance": {
+      "download_time": "Efficient, no delays reported",
+      "analysis_time": "Completed successfully, indicating effective analysis processes",
+      "generation_time": "Swift generation of MCP service components",
+      "test_time": "Original project tests failed, but MCP plugin tests passed"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Not explicitly measured, but no memory issues reported",
+      "cpu_efficiency": "Not explicitly measured, but no CPU issues reported",
+      "disk_usage": "Efficient, with minimal generated file size"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 75,
+    "architecture_score": 80,
+    "performance_score": 85,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 80
+  }
+}

autodE/source/.pre-commit-config.yaml

@@ -0,0 +1,19 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: trailing-whitespace
+      - id: mixed-line-ending
+
+  - repo: https://github.com/psf/black
+    rev: 23.9.1
+    hooks:
+      - id: black
+        language_version: python3
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.5.1
+    hooks:
+    - id: mypy
+      exclude: "tests/|doc/|examples/"
+      args: [--ignore-missing-imports]

autodE/source/CONTRIBUTING.md

@@ -0,0 +1,5 @@
+# Contributing to autodE
+
+Contributions in any form are very much welcome. To make managing these
+easier, we kindly ask that you follow the guidelines outlined
+[here](https://duartegroup.github.io/autodE/dev/contributing.html).

autodE/source/LICENSE.md

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

autodE/source/README.md

@@ -0,0 +1,100 @@
+[![Build Status](https://github.com/duartegroup/autodE/actions/workflows/pytest.yml/badge.svg)](https://github.com/duartegroup/autodE/actions) [![codecov](https://codecov.io/gh/duartegroup/autodE/branch/master/graph/badge.svg)](https://codecov.io/gh/duartegroup/autodE/branch/master) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![GitHub CodeQL](https://github.com/duartegroup/autodE/actions/workflows/codeql.yml/badge.svg)](https://github.com/duartegroup/autodE/actions/workflows/codeql.yml) [![Conda Recipe](https://img.shields.io/badge/recipe-autode-green.svg)](https://anaconda.org/conda-forge/autode) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/autode.svg)](https://anaconda.org/conda-forge/autode)
+
+![alt text](autode/common/llogo.png)
+***
+## Introduction
+
+**autodE** is a Python module initially designed for the automated calculation of reaction profiles from SMILES strings of
+reactant(s) and product(s). Current features include: transition state location, conformer searching, atom mapping,
+Python wrappers for a range of electronic structure theory codes, SMILES parsing, association complex generation, and
+ reaction profile generation.
+
+
+### Dependencies
+* [Python](https://www.python.org/) > v. 3.7
+* One of:
+   * [ORCA](https://sites.google.com/site/orcainputlibrary/home/) > v. 4.0
+   * [Gaussian09](https://gaussian.com/glossary/g09/)
+   * [Gaussian16](https://gaussian.com/gaussian16/)
+   * [NWChem](http://www.nwchem-sw.org/index.php/Main_Page) > 6.5
+   * [QChem](https://www.q-chem.com/) > 5.4
+* One of:
+   * [XTB](https://www.chemie.uni-bonn.de/pctc/mulliken-center/software/xtb/xtb/) > v. 6.1
+   * [MOPAC](http://openmopac.net/)
+
+The Python dependencies are listed in requirements.txt are best satisfied using a conda install (Miniconda or Anaconda).
+
+## Installation
+
+To install **autodE** with [conda](https://anaconda.org/conda-forge/autode):
+```
+conda install autode -c conda-forge
+```
+see the [installation guide](https://duartegroup.github.io/autodE/install.html) for installing from source.
+
+## Usage
+
+Reaction profiles in  **autodE** are generated by initialising _Reactant_ and _Product_ objects,
+generating a _Reaction_ from those and invoking _calculate_reaction_profile()_.
+For example, to  calculate the profile for a 1,2 hydrogen shift in a propyl radical:
+
+```python
+import autode as ade
+ade.Config.n_cores = 8
+
+r = ade.Reactant(name='reactant', smiles='CC[C]([H])[H]')
+p = ade.Product(name='product', smiles='C[C]([H])C')
+
+reaction = ade.Reaction(r, p, name='1-2_shift')
+reaction.calculate_reaction_profile()  # creates 1-2_shift/ and saves profile
+```
+
+See [examples/](https://github.com/duartegroup/autodE/tree/master/examples) for
+more examples and [duartegroup.github.io/autodE/](https://duartegroup.github.io/autodE/) for
+additional documentation.
+
+
+## Development
+
+There is a [slack workspace](https://autodeworkspace.slack.com) for development and discussion - please
+[email](mailto:autodE-gh@outlook.com?subject=autodE%20slack) to be added. Pull requests are
+very welcome but must pass all the unit tests prior to being merged. Please write code and tests!
+See the [todo list](https://github.com/duartegroup/autodE/projects/1) for features on the horizon.
+Bugs and feature requests should be raised on the [issue page](https://github.com/duartegroup/autodE/issues).
+
+> **_NOTE:_**  We'd love more contributors to this project!
+
+
+## Citation
+
+If **autodE** is used in a publication please consider citing the [paper](https://doi.org/10.1002/anie.202011941):
+
+```
+@article{autodE,
+  doi = {10.1002/anie.202011941},
+  url = {https://doi.org/10.1002/anie.202011941},
+  year = {2021},
+  publisher = {Wiley},
+  volume = {60},
+  number = {8},
+  pages = {4266--4274},
+  author = {Tom A. Young and Joseph J. Silcock and Alistair J. Sterling and Fernanda Duarte},
+  title = {{autodE}: Automated Calculation of Reaction Energy Profiles -- Application to Organic and Organometallic Reactions},
+  journal = {Angewandte Chemie International Edition}
+}
+```
+
+
+## Contributors
+
+- Tom Young ([@t-young31](https://github.com/t-young31))
+- Joseph Silcock ([@josephsilcock](https://github.com/josephsilcock))
+- Kjell Jorner ([@kjelljorner](https://github.com/kjelljorner))
+- Thibault Lestang ([@tlestang](https://github.com/tlestang))
+- Domen Pregeljc ([@dpregeljc](https://github.com/dpregeljc))
+- Jonathon Vandezande ([@jevandezande](https://github.com/jevandezande))
+- Shoubhik Maiti ([@shoubhikraj](https://github.com/shoubhikraj))
+- Daniel Hollas ([@danielhollas](https://github.com/danielhollas))
+- Nils Heunemann ([@nilsheunemann](https://github.com/NilsHeunemann))
+- Sijie Fu ([@sijiefu](https://github.com/SijieFu))
+- Javier Alfonso ([@javialra97](https://github.com/javialra97))

autodE/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+autodE Project Package Initialization File
+"""

autodE/source/autode/__init__.py

@@ -0,0 +1,71 @@
+import importlib.metadata
+
+from autode import methods
+from autode import geom
+from autode import pes
+from autode import utils
+from autode import neb
+from autode import mol_graphs
+from autode import hessians
+from autode.neb import NEB, CINEB
+from autode.reactions.reaction import Reaction
+from autode.reactions.multistep import MultiStepReaction
+from autode.transition_states.transition_state import TransitionState
+from autode.atoms import Atom
+from autode.species.molecule import Reactant, Product, Molecule, Species
+from autode.species.complex import NCIComplex
+from autode.config import Config
+from autode.calculations import Calculation
+from autode.wrappers.keywords import (
+    KeywordsSet,
+    OptKeywords,
+    HessianKeywords,
+    SinglePointKeywords,
+    Keywords,
+    GradientKeywords,
+)
+from autode.utils import temporary_config
+
+"""
+Bumping the version number requires following the release procedure:
+
+- Run tests/benchmark.py with both organic and organometallic sets
+
+- Release on conda-forge
+  - Fork https://github.com/conda-forge/autode-feedstock
+  - Make a local branch
+  - Modify recipe/meta.yaml with the new version number, sha256
+  - Push commit and open PR on the conda-forge feedstock
+  - Merge when tests pass
+"""
+
+__version__ = importlib.metadata.version("autode")
+
+__all__ = [
+    "KeywordsSet",
+    "Keywords",
+    "OptKeywords",
+    "HessianKeywords",
+    "SinglePointKeywords",
+    "GradientKeywords",
+    "Reaction",
+    "MultiStepReaction",
+    "Atom",
+    "Species",
+    "Reactant",
+    "Product",
+    "Molecule",
+    "TransitionState",
+    "NCIComplex",
+    "Config",
+    "Calculation",
+    "NEB",
+    "CINEB",
+    "pes",
+    "neb",
+    "geom",
+    "methods",
+    "mol_graphs",
+    "utils",
+    "hessians",
+]

autodE/source/autode/atoms.py

@@ -0,0 +1,1865 @@
+import numpy as np
+from copy import deepcopy
+from typing import Union, Optional, List, Sequence, Any
+from autode.log import logger
+from autode.geom import get_rot_mat_euler
+from autode.values import (
+    Distance,
+    Angle,
+    Mass,
+    Coordinate,
+    Coordinates,
+    MomentOfInertia,
+)
+
+
+class Atom:
+    def __init__(
+        self,
+        atomic_symbol: str,
+        x: Any = 0.0,
+        y: Any = 0.0,
+        z: Any = 0.0,
+        atom_class: Optional[int] = None,
+        partial_charge: Optional[float] = None,
+    ):
+        """
+        Atom class. Centered at the origin by default. Can be initialised from
+        positional or keyword arguments:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('H')
+            Atom(H, 0.0000, 0.0000, 0.0000)
+            >>>
+            >>> ade.Atom('H', x=1.0, y=1.0, z=1.0)
+            Atom(H, 1.0000, 1.0000, 1.0000)
+            >>>
+            >>> ade.Atom('H', 1.0, 1.0, 1.0)
+            Atom(H, 1.0000, 1.0000, 1.0000)
+
+        -----------------------------------------------------------------------
+        Arguments:
+            atomic_symbol: Symbol of an element e.g. 'C' for carbon
+
+            x: x coordinate in 3D space (Å)
+
+            y: y coordinate in 3D space (Å)
+
+            z: z coordinate in 3D space (Å)
+
+            atom_class: Fictitious additional labels to distinguish otherwise
+                        identical atoms. Useful in finding bond isomorphisms
+                        over identity reactions
+
+            partial_charge: Partial atomic charge in units of e, determined by
+                            the atomic envrionment. Not an observable property.
+        """
+        assert atomic_symbol in elements
+
+        self.label = atomic_symbol
+        self._coord = Coordinate(float(x), float(y), float(z))
+        self.atom_class = atom_class
+        self.partial_charge = (
+            None if partial_charge is None else float(partial_charge)
+        )
+
+    def __repr__(self):
+        """
+        Representation of this atom
+
+        -----------------------------------------------------------------------
+        Returns:
+            (str): Representation
+        """
+        x, y, z = self.coord
+        return f"Atom({self.label}, {x:.4f}, {y:.4f}, {z:.4f})"
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __eq__(self, other: Any):
+        """Equality of another atom to this one"""
+        are_equal = (
+            isinstance(other, Atom)
+            and other.label == self.label
+            and other.atom_class == self.atom_class
+            and isinstance(other.partial_charge, type(self.partial_charge))
+            and (
+                (other.partial_charge is None and self.partial_charge is None)
+                or np.isclose(other.partial_charge, self.partial_charge)
+            )
+            and np.allclose(other._coord, self._coord)
+        )
+        return are_equal
+
+    @property
+    def atomic_number(self) -> int:
+        """
+        Atomic numbers are the position in the elements (indexed from zero),
+        plus one. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> atom = ade.Atom('C')
+            >>> atom.atomic_number
+            6
+
+        -----------------------------------------------------------------------
+        Returns:
+            (int): Atomic number
+        """
+        return elements.index(self.label) + 1
+
+    @property
+    def atomic_symbol(self) -> str:
+        """
+        A more interpretable alias for Atom.label. Should be present in the
+        elements. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> atom = ade.Atom('Zn')
+            >>> atom.atomic_symbol
+            'Zn'
+
+        -----------------------------------------------------------------------
+        Returns:
+            (str): Atomic symbol
+        """
+        return self.label
+
+    @property
+    def coord(self) -> Coordinate:
+        """
+        Position of this atom in space. Coordinate has attributes x, y, z
+        for the Cartesian displacements. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> atom = ade.Atom('H')
+            >>> atom.coord
+            Coordinate([0. 0. 0.] Å)
+
+        To initialise at a different position away from the origin
+
+        .. code-block:: Python
+
+            >>> ade.Atom('H', x=1.0).coord
+            Coordinate([1. 0. 0.] Å)
+            >>> ade.Atom('H', x=1.0).coord.x
+            1.0
+
+        Coordinates are instances of autode.values.ValueArray, so can
+        be converted from the default angstrom units to e.g. Bohr
+
+        .. code-block:: Python
+
+            >>> ade.Atom('H', x=1.0, y=-1.0).coord.to('a0')
+            Coordinate([1.889  -1.889  0. ] bohr)
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Coordinate): Coordinate
+        """
+        return self._coord
+
+    @coord.setter
+    def coord(self, *args):
+        """
+        Coordinate setter
+
+        -----------------------------------------------------------------------
+        Arguments:
+            *args (float | list(float) | np.ndarray(float)):
+
+        Raises:
+            (ValueError): If the arguments cannot be coerced into a (3,) shape
+        """
+        self._coord = Coordinate(*args)
+
+    @property
+    def is_metal(self) -> bool:
+        """
+        Is this atom a metal? Defines metals to be up to and including:
+        Ga, Sn, Bi. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('C').is_metal
+            False
+            >>> ade.Atom('Zn').is_metal
+            True
+
+        -----------------------------------------------------------------------
+        Returns:
+            (bool):
+        """
+        return self.label in metals
+
+    @property
+    def group(self) -> int:
+        """
+        Group of the periodic table is this atom in. 0 if not found. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('C').group
+            14
+
+        -----------------------------------------------------------------------
+        Returns:
+            (int): Group
+        """
+
+        for group_idx in range(1, 18):
+            if self.label in PeriodicTable.group(group_idx):
+                return group_idx
+
+        return 0
+
+    @property
+    def period(self) -> int:
+        """
+        Period of the periodic table is this atom in. 0 if not found. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('C').period
+            2
+
+        -----------------------------------------------------------------------
+        Returns:
+            (int): Period
+        """
+
+        for period_idx in range(1, 7):
+            if self.label in PeriodicTable.period(period_idx):
+                return period_idx
+
+        return 0
+
+    @property
+    def tm_row(self) -> Optional[int]:
+        """
+        Row of transition metals that this element is in. Returns None if
+        this atom is not a metal. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('Zn').tm_row
+            1
+
+        -----------------------------------------------------------------------
+        Returns:
+            (int | None): Transition metal row
+        """
+        for row in [1, 2, 3]:
+            if self.label in PeriodicTable.transition_metals(row):
+                return row
+
+        return None
+
+    @property
+    def weight(self) -> Mass:
+        """
+        Atomic weight. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('C').weight
+            Mass(12.0107 amu)
+            >>>
+            >>> ade.Atom('C').weight == ade.Atom('C').mass
+            True
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Mass): Weight
+        """
+
+        try:
+            return Mass(atomic_weights[self.label])
+
+        except KeyError:
+            logger.warning(
+                f"Could not find a valid weight for {self.label}. "
+                f"Guessing at 70"
+            )
+            return Mass(70)
+
+    @property
+    def mass(self) -> Mass:
+        """Alias of weight. Returns Atom.weight an so can be converted
+        to different units. For example, to convert the mass to electron masses:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('H').mass.to('me')
+            Mass(1837.36222 m_e)
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Mass): Mass
+        """
+        return self.weight
+
+    @property
+    def maximal_valance(self) -> int:
+        """
+        The maximum/maximal valance that this atom supports in any charge
+        state (most commonly). i.e. for H the maximal_valance=1. Useful for
+        generating molecular graphs
+
+        -----------------------------------------------------------------------
+        Returns:
+            (int): Maximal valance
+        """
+
+        if self.is_metal:
+            return 6
+
+        if self.label in _max_valances:
+            return _max_valances[self.label]
+
+        logger.warning(
+            f"Could not find a valid valance for {self}. " f"Guessing at 6"
+        )
+        return 6
+
+    @property
+    def vdw_radius(self) -> Distance:
+        """
+        Van der Waals radius for this atom. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('H').vdw_radius
+            Distance(1.1 Å)
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Distance): Van der Waals radius
+        """
+
+        if self.label in vdw_radii:
+            radius = vdw_radii[self.label]
+        else:
+            logger.error(
+                f"Couldn't find the VdV radii for {self}. "
+                f"Guessing at 2.3 Å"
+            )
+            radius = 2.3
+
+        return Distance(radius, "Å")
+
+    @property
+    def covalent_radius(self) -> Distance:
+        """
+        Covalent radius for this atom. Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('H').covalent_radius
+            Distance(0.31 Å)
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Distance): Van der Waals radius
+        """
+        radius = Distance(
+            _covalent_radii_pm[self.atomic_number - 1], units="pm"
+        )
+        return radius.to("Å")
+
+    def is_pi(self, valency: int) -> bool:
+        """
+        Determine if this atom is a 'π-atom' i.e. is unsaturated. Only
+        approximate! Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> ade.Atom('C').is_pi(valency=3)
+            True
+            >>> ade.Atom('H').is_pi(valency=1)
+            False
+
+        -----------------------------------------------------------------------
+        Arguments:
+            valency (int):
+
+        Returns:
+            (bool):
+        """
+
+        if self.label in non_pi_elements:
+            return False
+
+        if self.label not in pi_valencies:
+            logger.warning(
+                f"{self.label} not found in π valency dictionary - "
+                f"assuming not a π-atom"
+            )
+            return False
+
+        if valency in pi_valencies[self.label]:
+            return True
+
+        return False
+
+    def translate(self, *args, **kwargs) -> None:
+        """
+        Translate this atom by a vector in place. Arguments should be
+        coercible into a coordinate (i.e. length 3). Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> atom = ade.Atom('H')
+            >>> atom.translate(1.0, 0.0, 0.0)
+            >>> atom.coord
+            Coordinate([1. 0. 0.] Å)
+
+        Atoms can also be translated using numpy arrays:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> import numpy as np
+            >>>
+            >>> atom = ade.Atom('H')
+            >>> atom.translate(np.ones(3))
+            >>> atom.coord
+            Coordinate([1. 1. 1.] Å)
+            >>>
+            >>> atom.translate(vec=-atom.coord)
+            >>> atom.coord
+            Coordinate([0. 0. 0.] Å)
+
+        -----------------------------------------------------------------------
+        Arguments:
+             *args (float | np.ndarray | list(float)):
+
+        Keyword Arguments:
+            vec (np.ndarray): Shape = (3,)
+        """
+        if "vec" in kwargs:
+            # Assume the vec is cast-able to a numpy array which can be added
+            self.coord += np.asarray(kwargs["vec"])
+
+        elif len(kwargs) > 0:
+            raise ValueError(
+                f"Expecting only a vec keyword argument. " f"Had {kwargs}"
+            )
+
+        else:
+            self.coord += Coordinate(*args)
+
+        return None
+
+    def rotate(
+        self,
+        axis: Union[np.ndarray, Sequence],
+        theta: Union[Angle, float],
+        origin: Union[np.ndarray, Sequence, None] = None,
+    ) -> None:
+        """
+        Rotate this atom theta radians around an axis given an origin. By
+        default the rotation is applied around the origin with the angle
+        in radians (unless an autode.values.Angle). Rotation is applied in
+        place. To rotate a H atom around the z-axis:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> atom = ade.Atom('H', x=1.0)
+            >>> atom.rotate(axis=[0.0, 0.0, 1.0], theta=3.14)
+            >>> atom.coord
+            Coordinate([-1.  0.  0.] Å)
+
+        With an origin:
+
+        .. code-block:: Python
+
+          >>> import autode as ade
+          >>> atom = ade.Atom('H')
+          >>> atom.rotate(axis=[0.0, 0.0, 1.0], theta=3.14, origin=[1.0, 0.0, 0.0])
+          >>> atom.coord
+          Coordinate([2.  0.  0.] Å)
+
+        And with an angle not in radians:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> from autode.values import Angle
+            >>>
+            >>> atom = ade.Atom('H', x=1.0)
+            >>> atom.rotate(axis=[0.0, 0.0, 1.0], theta=Angle(180, units='deg'))
+            >>> atom.coord
+            Coordinate([-1.  0.  0.] Å)
+
+        -----------------------------------------------------------------------
+        Arguments:
+            axis: Axis to rotate in. shape = (3,)
+
+            theta: Angle to rotate by
+
+            origin: Rotate about this origin. shape = (3,) if no origin is
+                    specified then the atom is rotated without translation.
+        """
+        # If specified, shift so that the origin is at (0, 0, 0)
+        if origin is not None:
+            self.translate(vec=-np.asarray(origin))
+
+        # apply the rotation
+        rot_matrix = get_rot_mat_euler(axis=axis, theta=theta)
+        self.coord = np.matmul(rot_matrix, self.coord)
+
+        # and shift back, if required
+        if origin is not None:
+            self.translate(vec=np.asarray(origin))
+
+        return None
+
+    def copy(self) -> "Atom":
+        return deepcopy(self)
+
+    # --- Method aliases ---
+    coordinate = coord
+
+
+class DummyAtom(Atom):
+    def __init__(self, x, y, z):
+        """
+        Dummy atom
+
+        -----------------------------------------------------------------------
+        Arguments:
+            x (float): x coordinate in 3D space (Å)
+            y (float): y
+            z (float): z
+        """
+        # Superclass constructor called with a valid element...
+        super().__init__("H", x, y, z)
+
+        # then re-assigned
+        self.label = "D"
+
+    @property
+    def atomic_number(self):
+        """The atomic number is defined as 0 for a dummy atom"""
+        return 0
+
+    @property
+    def weight(self) -> Mass:
+        """Dummy atoms do not have any weight/mass"""
+        return Mass(0.0)
+
+    @property
+    def mass(self) -> Mass:
+        """Dummy atoms do not have any weight/mass"""
+        return Mass(0.0)
+
+    @property
+    def vdw_radius(self) -> Distance:
+        """Dummy atoms have no radius"""
+        return Distance(0.0, units="Å")
+
+    @property
+    def covalent_radius(self) -> Distance:
+        """Dummy atoms have no radius"""
+        return Distance(0.0, units="Å")
+
+
+class Atoms(list):
+    def __repr__(self):
+        """Representation"""
+        return f"Atoms(n_atoms={len(self)}, {super().__repr__()})"
+
+    def __add__(self, other):
+        """Add another set of Atoms to this one. Can add None"""
+        if other is None:
+            return self
+
+        return super().__add__(other)
+
+    def __radd__(self, other):
+        """Add another set of Atoms to this one. Can add None"""
+        return self.__add__(other)
+
+    def copy(self) -> "Atoms":
+        """
+        Copy these atoms, deeply
+
+        -----------------------------------------------------------------------
+        Returns:
+             (autode.atoms.Atoms):
+        """
+        return deepcopy(self)
+
+    def remove_dummy(self) -> None:
+        """Remove all the dummy atoms from this list of atoms"""
+
+        for i, atom in enumerate(self):
+            if isinstance(atom, DummyAtom):
+                del self[i]
+        return
+
+    @property
+    def coordinates(self) -> Coordinates:
+        return Coordinates(np.array([a.coord for a in self]))
+
+    @coordinates.setter
+    def coordinates(self, value: np.ndarray):
+        """Set the coordinates from a numpy array
+
+        -----------------------------------------------------------------------
+        Arguments:
+            value (np.ndarray): Shape = (n_atoms, 3) or (3*n_atoms) as a
+                                row major vector
+        """
+
+        if value.ndim == 1:
+            assert value.shape == (3 * len(self),)
+            value = value.reshape((-1, 3))
+
+        elif value.ndim == 2:
+            assert value.shape == (len(self), 3)
+
+        else:
+            raise AssertionError(
+                "Cannot set coordinates from a array with"
+                f"shape: {value.shape}. Must be 1 or 2 "
+                f"dimensional"
+            )
+
+        for i, atom in enumerate(self):
+            atom.coord = Coordinate(*value[i])
+
+    @property
+    def com(self) -> Coordinate:
+        r"""
+        Centre of mass of these coordinates
+
+        .. math::
+            \text{COM} = \frac{1}{M} \sum_i m_i R_i
+
+        where M is the total mass, m_i the mass of atom i and R_i it's
+        coordinate
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Coordinate): COM
+        """
+        if len(self) == 0:
+            raise ValueError("Undefined centre of mass with no atoms")
+
+        com = Coordinate(0.0, 0.0, 0.0)
+
+        for atom in self:
+            com += atom.mass * atom.coord
+
+        return Coordinate(com / sum(atom.mass for atom in self))
+
+    @property
+    def moi(self) -> MomentOfInertia:
+        """
+        Moment of inertia matrix (I)::
+
+                (I_00   I_01   I_02)
+            I = (I_10   I_11   I_12)
+                (I_20   I_21   I_22)
+
+        Returns:
+            (autode.values.MomentOfInertia):
+        """
+        moi = MomentOfInertia(np.zeros(shape=(3, 3)), units="amu Å^2")
+
+        for atom in self:
+            mass, (x, y, z) = atom.mass, atom.coord
+
+            moi[0, 0] += mass * (y**2 + z**2)
+            moi[0, 1] -= mass * (x * y)
+            moi[0, 2] -= mass * (x * z)
+
+            moi[1, 0] -= mass * (y * x)
+            moi[1, 1] += mass * (x**2 + z**2)
+            moi[1, 2] -= mass * (y * z)
+
+            moi[2, 0] -= mass * (z * x)
+            moi[2, 1] -= mass * (z * y)
+            moi[2, 2] += mass * (x**2 + y**2)
+
+        return moi
+
+    @property
+    def contain_metals(self) -> bool:
+        """
+        Do these atoms contain at least a single metal atom?
+
+        -----------------------------------------------------------------------
+        Returns:
+            (bool):
+        """
+        return any(atom.label in metals for atom in self)
+
+    def idxs_are_present(self, *args: int) -> bool:
+        """Are all these indexes present in this set of atoms"""
+        return set(args).issubset(set(range(len(self))))
+
+    def eqm_bond_distance(self, i: int, j: int) -> Distance:
+        """
+        Equilibrium distance between two atoms. If known then use the
+        experimental dimer distance, otherwise estimate if from the
+        covalent radii of the two atoms. Example
+
+        Example:
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> mol = ade.Molecule(atoms=[ade.Atom('H'), ade.Atom('H')])
+            >>> mol.distance(0, 1)
+            Distance(0.0 Å)
+            >>> mol.eqm_bond_distance(0, 1)
+            Distance(0.741 Å)
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Distance): Equlirbium distance
+        """
+        if not self.idxs_are_present(i, j):
+            raise ValueError(
+                f"Cannot calculate the equilibrium distance "
+                f"between {i}-{j}. At least one atom not present"
+            )
+
+        if i == j:
+            return Distance(0.0, units="Å")
+
+        symbols = f"{self[i].atomic_symbol}{self[j].atomic_symbol}"
+
+        if symbols in _bond_lengths:
+            return Distance(_bond_lengths[symbols], units="Å")
+
+        # TODO: Something more accurate here
+        return self[i].covalent_radius + self[j].covalent_radius
+
+    def distance(self, i: int, j: int) -> Distance:
+        """
+        Distance between two atoms (Å), indexed from 0.
+
+        .. code-block:: Python
+
+            >>> import autode as ade
+            >>> mol = ade.Molecule(atoms=[ade.Atom('H'), ade.Atom('H', x=1.0)])
+            >>> mol.distance(0, 1)
+            Distance(1.0 Å)
+
+        -----------------------------------------------------------------------
+        Arguments:
+            i (int): Atom index of the first atom
+            j (int): Atom index of the second atom
+
+        Returns:
+            (autode.values.Distance): Distance
+
+        Raises:
+            (ValueError):
+        """
+        if not self.idxs_are_present(i, j):
+            raise ValueError(
+                f"Cannot calculate the distance between {i}-{j}. "
+                f"At least one atom not present"
+            )
+
+        return Distance(np.linalg.norm(self[i].coord - self[j].coord))
+
+    def vector(self, i: int, j: int) -> np.ndarray:
+        """
+        Vector from atom i to atom j
+
+        -----------------------------------------------------------------------
+        Arguments:
+            i (int):
+            j (int):
+
+        Returns:
+            (np.ndarray):
+
+        Raises:
+            (IndexError): If i or j are not present
+        """
+        return np.asarray(self[j].coord - self[i].coord)
+
+    def nvector(self, i: int, j: int) -> np.ndarray:
+        """
+        Normalised vector from atom i to atom j
+
+        -----------------------------------------------------------------------
+        Arguments:
+            i (int):
+            j (int):
+
+        Returns:
+            (np.ndarray):
+
+        Raises:
+            (IndexError): If i or j are not present
+        """
+        vec = self.vector(i, j)
+        return vec / np.linalg.norm(vec)
+
+    def are_linear(self, angle_tol: Angle = Angle(1, "º")) -> bool:
+        """
+        Are these set of atoms colinear?
+
+        -----------------------------------------------------------------------
+        Arguments:
+            angle_tol (autode.values.Angle): Tolerance on the angle
+
+        Returns:
+            (bool): Whether the atoms are linear
+        """
+        if len(self) < 2:  # Must have at least 2 atoms colinear
+            return False
+
+        if len(self) == 2:  # Two atoms must be linear
+            return True
+
+        tol = np.abs(1.0 - np.cos(angle_tol.to("rad")))
+
+        vec0 = self.nvector(0, 1)  # Normalised first vector
+
+        for atom in self[2:]:
+            vec = atom.coord - self[0].coord
+            cos_theta = np.dot(vec, vec0) / np.linalg.norm(vec)
+
+            # Both e.g. <179° and >1° should satisfy this condition for
+            # angle_tol = 1°
+            if np.abs(np.abs(cos_theta) - 1) > tol:
+                return False
+
+        return True
+
+    def are_planar(self, distance_tol: Distance = Distance(1e-3, "Å")) -> bool:
+        """
+        Do all the atoms in this set lie in a single plane?
+
+        -----------------------------------------------------------------------
+        Arguments:
+            distance_tol (autode.values.Distance):
+
+        Returns:
+            (bool):
+        """
+        if len(self) < 4:  # 3 points must lie in a plane
+            return True
+
+        arr = self.coordinates.to("Å")
+
+        if isinstance(distance_tol, Distance):
+            distance_tol_float = float(distance_tol.to("Å"))
+
+        else:
+            logger.warning("Assuming a distance tolerance in units of Å")
+            distance_tol_float = float(distance_tol)
+
+        # Calculate a normal vector to the first two atomic vectors from atom 0
+        x0 = arr[0, :]
+        normal_vec = np.cross(arr[1, :] - x0, arr[2, :] - x0)
+
+        for i in range(3, len(self)):
+            # Calculate the 0->i atomic vector, which must not have any
+            # component in the direction in the normal if the atoms are planar
+            if np.dot(normal_vec, arr[i, :] - x0) > distance_tol_float:
+                return False
+
+        return True
+
+
+class AtomCollection:
+    def __init__(self, atoms: Union[List[Atom], Atoms, None] = None):
+        """
+        Collection of atoms, used as a base class for a species, complex
+        or transition state.
+
+        -----------------------------------------------------------------------
+        Arguments:
+            atoms (autode.atoms.Atoms | list(autode.atoms.Atom) | None):
+        """
+        self._atoms = Atoms(atoms) if atoms is not None else None
+
+    @property
+    def n_atoms(self) -> int:
+        """Number of atoms in this collection"""
+        return 0 if self.atoms is None else len(self.atoms)
+
+    @property
+    def coordinates(self) -> Optional[Coordinates]:
+        """Numpy array of coordinates"""
+        if self.atoms is None:
+            return None
+
+        return self.atoms.coordinates
+
+    @coordinates.setter
+    def coordinates(self, value: np.ndarray):
+        """Set the coordinates from a numpy array
+
+        -----------------------------------------------------------------------
+        Arguments:
+            value (np.ndarray): Shape = (n_atoms, 3) or (3*n_atoms) as a
+                                row major vector
+        """
+        if self._atoms is None:
+            raise ValueError(
+                "Must have atoms set to be able to set the "
+                "coordinates of them"
+            )
+
+        self._atoms.coordinates = value
+
+    @property
+    def atoms(self) -> Optional[Atoms]:
+        """Constituent atoms of this collection"""
+        return self._atoms
+
+    @atoms.setter
+    def atoms(self, value: Union[List[Atom], Atoms, None]):
+        """Set the constituent atoms of this collection"""
+        self._atoms = Atoms(value) if value is not None else None
+
+    @property
+    def com(self) -> Optional[Coordinate]:
+        """Centre of mass of this atom collection
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Coordinate): COM
+
+        Raises:
+            (ValueError): If there are no atoms
+        """
+        return None if self.atoms is None else self.atoms.com
+
+    @property
+    def moi(self) -> Optional[MomentOfInertia]:
+        """
+        Moment of inertia matrix (I)
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.MomentOfInertia):
+        """
+        return None if self.atoms is None else self.atoms.moi
+
+    @property
+    def weight(self) -> Mass:
+        """
+        Molecular weight
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.values.Mass):
+        """
+        if self.n_atoms == 0:
+            return Mass(0.0)
+
+        return sum(atom.mass for atom in self.atoms)  # type: ignore
+
+    def distance(self, i: int, j: int) -> Distance:
+        assert self.atoms is not None, "Must have atoms"
+        return self.atoms.distance(i, j)
+
+    def eqm_bond_distance(self, i: int, j: int) -> Distance:
+        assert self.atoms is not None, "Must have atoms"
+        return self.atoms.eqm_bond_distance(i, j)
+
+    def angle(self, i: int, j: int, k: int) -> Angle:
+        r"""
+        Angle between three atoms i-j-k, where the atoms are indexed from
+        zero::
+
+            E_i  --- E_j
+                        \
+                  θ      E_k
+
+
+        Example:
+
+        .. code-block:: Python
+
+            >>> from autode import Atom, Molecule
+            >>> h2o = Molecule(atoms=[Atom('H', x=-1), Atom('O'), Atom('H', x=1)])
+            >>> h2o.angle(0, 1, 2).to('deg')
+            Angle(180.0 °)
+
+
+        -----------------------------------------------------------------------
+        Arguments:
+            i (int): Atom index of the left hand side in the angle
+            j (int):  --- middle
+            k (int):  --- right
+
+        Returns:
+            (autode.values.Angle): Angle
+
+        Raises:
+            (ValueError): If any of the atom indexes are not present
+        """
+        assert self.atoms is not None, "Must have atoms"
+
+        if not self.atoms.idxs_are_present(i, j, k):
+            raise ValueError(
+                f"Cannot calculate the angle between {i}-{j}-{k}."
+                f" At least one atom not present"
+            )
+
+        vec1 = self.atoms[i].coord - self.atoms[j].coord
+        vec2 = self.atoms[k].coord - self.atoms[j].coord
+
+        norms = np.linalg.norm(vec1) * np.linalg.norm(vec2)
+
+        if np.isclose(norms, 0.0):
+            raise ValueError(
+                f"Cannot calculate the angle {i}-{j}-{k} - at "
+                f"least one zero vector"
+            )
+
+        # Cos(theta) must lie within [-1, 1]
+        cos_value = np.clip(np.dot(vec1, vec2) / norms, a_min=-1, a_max=1)
+
+        return Angle(np.arccos(cos_value))
+
+    def dihedral(self, w: int, x: int, y: int, z: int) -> Angle:
+        r"""
+        Dihedral angle between four atoms (x, y, z, w), where the atoms are
+        indexed from zero::
+
+            E_w  --- E_x
+                        \  φ
+                         \
+                          E_y ---- E_z
+
+        Example:
+
+        .. code-block:: Python
+
+            >>> from autode import Atom, Molecule
+            >>> h2s2 = Molecule(atoms=[Atom('S',  0.1527, 0.9668, -0.9288),
+            ...                        Atom('S',  2.0024, 0.0443, -0.4227),
+            ...                        Atom('H', -0.5802, 0.0234, -0.1850),
+            ...                        Atom('H',  2.1446, 0.8424,  0.7276)])
+            >>> h2s2.dihedral(2, 0, 1, 3).to('deg')
+            Angle(-90.0 °)
+
+        -----------------------------------------------------------------------
+        Arguments:
+            w (int): Atom index of the first atom in the dihedral
+            x (int):               -- second --
+            y (int):               -- third  --
+            z (int):               -- fourth --
+
+        Returns:
+            (autode.values.Angle): Dihedral angle
+
+        Raises:
+            (ValueError): If any of the atom indexes are not present in the
+                          molecule
+        """
+        assert self.atoms is not None, "Must have atoms"
+
+        if not self.atoms.idxs_are_present(w, x, y, z):
+            raise ValueError(
+                f"Cannot calculate the dihedral angle involving "
+                f"atoms {z}-{w}-{x}-{y}. At least one atom not "
+                f"present"
+            )
+
+        vec_xw = self.atoms[w].coord - self.atoms[x].coord
+        vec_yz = self.atoms[z].coord - self.atoms[y].coord
+        vec_xy = self.atoms[y].coord - self.atoms[x].coord
+
+        vec1, vec2 = np.cross(vec_xw, vec_xy), np.cross(-vec_xy, vec_yz)
+
+        # Normalise and ensure no zero vectors, for which the dihedral is not
+        # defined
+        for vec in (vec1, vec2, vec_xy):
+            norm = np.linalg.norm(vec)
+
+            if np.isclose(norm, 0.0):
+                raise ValueError(
+                    f"Cannot calculate the dihedral angle "
+                    f"{z}-{w}-{x}-{y} - one zero vector"
+                )
+            vec /= norm
+
+        """
+        Dihedral angles are defined as from the IUPAC gold book: "the torsion
+        angle between groups A and D is then considered to be positive if
+        the bond A-B is rotated in a clockwise direction through less than
+        180 degrees"
+        """
+        value = -np.arctan2(
+            np.dot(np.cross(vec1, vec_xy), vec2), np.dot(vec1, vec2)
+        )
+
+        return Angle(value)
+
+    # --- Method aliases ---
+    centre_of_mass = com
+    moment_of_inertia = moi
+    mass = weight
+
+
+elements = [
+    "H",
+    "He",
+    "Li",
+    "Be",
+    "B",
+    "C",
+    "N",
+    "O",
+    "F",
+    "Ne",
+    "Na",
+    "Mg",
+    "Al",
+    "Si",
+    "P",
+    "S",
+    "Cl",
+    "Ar",
+    "K",
+    "Ca",
+    "Sc",
+    "Ti",
+    "V",
+    "Cr",
+    "Mn",
+    "Fe",
+    "Co",
+    "Ni",
+    "Cu",
+    "Zn",
+    "Ga",
+    "Ge",
+    "As",
+    "Se",
+    "Br",
+    "Kr",
+    "Rb",
+    "Sr",
+    "Y",
+    "Zr",
+    "Nb",
+    "Mo",
+    "Tc",
+    "Ru",
+    "Rh",
+    "Pd",
+    "Ag",
+    "Cd",
+    "In",
+    "Sn",
+    "Sb",
+    "Te",
+    "I",
+    "Xe",
+    "Cs",
+    "Ba",
+    "La",
+    "Ce",
+    "Pr",
+    "Nd",
+    "Pm",
+    "Sm",
+    "Eu",
+    "Gd",
+    "Tb",
+    "Dy",
+    "Ho",
+    "Er",
+    "Tm",
+    "Yb",
+    "Lu",
+    "Hf",
+    "Ta",
+    "W",
+    "Re",
+    "Os",
+    "Ir",
+    "Pt",
+    "Au",
+    "Hg",
+    "Tl",
+    "Pb",
+    "Bi",
+    "Po",
+    "At",
+    "Rn",
+    "Fr",
+    "Ra",
+    "Ac",
+    "Th",
+    "Pa",
+    "U",
+    "Np",
+    "Pu",
+    "Am",
+    "Cm",
+    "Bk",
+    "Cf",
+    "Es",
+    "Fm",
+    "Md",
+    "No",
+    "Lr",
+    "Rf",
+    "Db",
+    "Sg",
+    "Bh",
+    "Hs",
+    "Mt",
+    "Ds",
+    "Rg",
+    "Cn",
+    "Nh",
+    "Fl",
+    "Mc",
+    "Lv",
+    "Ts",
+    "Og",
+]
+
+
+class PeriodicTable:
+    # fmt: off
+    table = np.array(
+        [['H',    '',   '',   '',   '',  '',    '',   '',   '',   '',   '',   '',   '',   '',   '',   '',   '', 'He'],
+         ['Li', 'Be',   '',   '',   '',  '',    '',   '',   '',   '',   '',   '',  'B',  'C',  'N',  'O',  'F', 'Ne'],
+         ['Na', 'Mg',   '',   '',   '',  '',    '',   '',   '',   '',   '',   '', 'Al', 'Si',  'P',  'S', 'Cl', 'Ar'],
+         ['K',  'Ca', 'Sc', 'Ti',  'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr'],
+         ['Rb', 'Sr',  'Y', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te',  'I', 'Xe'],
+         ['Cs', 'Ba',   '', 'Hf', 'Ta',  'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Po', 'At', 'Rn'],
+         ['Fr', 'Ra',   '', 'Rf', 'Db', 'Sg', 'Bh', 'Hs', 'Mt', 'Ds', 'Rg', 'Cn', 'Nh', 'Fl', 'Mc', 'Lv', 'Ts', 'Og']],
+        dtype=str
+    )
+    # fmt: on
+
+    @classmethod
+    def period(cls, n: int):
+        """
+        Period of the periodic table, with 1 being the first period
+
+        -----------------------------------------------------------------------
+        Arguments:
+            n (int):
+
+        Returns:
+            (np.ndarray(str)):
+
+        Raises:
+            (ValueError): If n is not valid period index
+        """
+        if n < 1 or n > 7:
+            raise ValueError("Not a valid period. Must be 1-7")
+
+        # Exclude the empty strings of non-present elements
+        return np.array([elem for elem in cls.table[n - 1, :] if elem != ""])
+
+    @classmethod
+    def group(cls, n: int):
+        """
+        Group of the periodic table, with 1 being the first period
+
+        -----------------------------------------------------------------------
+        Arguments:
+            n (int):
+
+        Returns:
+            (np.ndarray(str)):
+
+        Raises:
+            (ValueError): If n is not valid group index
+        """
+        if n < 1 or n > 18:
+            raise ValueError("Not a valid group. Must be 1-18")
+
+        # Exclude the empty strings of non-present elements
+        return np.array([elem for elem in cls.table[:, n - 1] if elem != ""])
+
+    @classmethod
+    def element(cls, period: int, group: int):
+        """
+        Element given it's index in the periodic table, excluding
+        lanthanides and actinides.
+
+        -----------------------------------------------------------------------
+        Arguments:
+            period (int):
+
+            group (int):
+
+        Returns:
+            (str): Atomic symbol of the element
+
+        Raises:
+            (IndexError): If such an element does not exist
+        """
+        try:
+            elem = cls.table[
+                period - 1, group - 1
+            ]  # Convert from 1 -> 0 indexing
+            assert elem != ""
+
+        except (IndexError, AssertionError):
+            raise IndexError("Index of the element not found")
+
+        return elem
+
+    @classmethod
+    def transition_metals(cls, row: int):
+        """
+        Collection of transition metals (TMs) of a defined row. e.g.
+
+        row = 1 -> [Sc, Ti .. Zn]
+
+        -----------------------------------------------------------------------
+        Arguments:
+            row (int): Colloquial name for TMs period
+
+        Returns:
+            (np.ndarray(str)):
+
+        Raises:
+            (ValueError): If the row is not valid
+        """
+        if row < 1 or row > 3:
+            raise ValueError("Not a valid row of TMs. Must be 1-3")
+
+        tms = [elem for elem in cls.period(row + 3) if elem in metals]
+        return np.array(tms, dtype=str)
+
+    lanthanoids = lanthanides = np.array(
+        [
+            "La",
+            "Ce",
+            "Pr",
+            "Nd",
+            "Pm",
+            "Sm",
+            "Eu",
+            "Gd",
+            "Tb",
+            "Dy",
+            "Ho",
+            "Er",
+            "Tm",
+            "Yb",
+            "Lu",
+        ],
+        dtype=str,
+    )
+    actinoids = actinides = np.array(
+        [
+            "Ac",
+            "Th",
+            "Pa",
+            "U",
+            "Np",
+            "Pu",
+            "Am",
+            "Cm",
+            "Bk",
+            "Cf",
+            "Es",
+            "Fm",
+            "Md",
+            "No",
+            "Lr",
+        ],
+        dtype=str,
+    )
+
+
+# A set of reasonable valances for anionic/neutral/cationic atoms
+valid_valances = {
+    "H": [0, 1],
+    "B": [3, 4],
+    "C": [2, 3, 4],
+    "N": [2, 3, 4],
+    "O": [1, 2, 3],
+    "F": [0, 1],
+    "Si": [2, 3, 4],
+    "P": [2, 3, 4, 5, 6],
+    "S": [2, 3, 4, 5, 6],
+    "Cl": [0, 1, 2, 3, 4],
+    "Br": [0, 1, 2, 3, 4],
+    "I": [0, 1, 2, 3, 4, 5, 6],
+    "Rh": [0, 1, 2, 3, 4, 5, 6],
+}
+
+#  Atomic weights in amu from:
+#  IUPAC-CIAWW's Atomic weights of the elements: Review 2000
+atomic_weights = {
+    "H": 1.00794,
+    "He": 4.002602,
+    "Li": 6.941,
+    "Be": 9.012182,
+    "B": 10.811,
+    "C": 12.0107,
+    "N": 14.0067,
+    "O": 15.9994,
+    "F": 18.9984032,
+    "Ne": 2.01797,
+    "Na": 22.989770,
+    "Mg": 24.3050,
+    "Al": 26.981538,
+    "Si": 28.0855,
+    "P": 30.973761,
+    "S": 32.065,
+    "Cl": 35.453,
+    "Ar": 39.948,
+    "K": 39.0983,
+    "Ca": 40.078,
+    "Sc": 44.955910,
+    "Ti": 47.867,
+    "V": 50.9415,
+    "Cr": 51.9961,
+    "Mn": 54.938049,
+    "Fe": 55.845,
+    "Co": 58.933200,
+    "Ni": 58.6934,
+    "Cu": 63.546,
+    "Zn": 65.409,
+    "Ga": 69.723,
+    "Ge": 72.64,
+    "As": 74.92160,
+    "Se": 78.96,
+    "Br": 79.904,
+    "Kr": 83.798,
+    "Rb": 85.4678,
+    "Sr": 87.62,
+    "Y": 88.90585,
+    "Zr": 91.224,
+    "Nb": 92.90638,
+    "Mo": 95.94,
+    "Ru": 101.07,
+    "Rh": 102.90550,
+    "Pd": 106.42,
+    "Ag": 107.8682,
+    "Cd": 112.411,
+    "In": 114.818,
+    "Sn": 118.710,
+    "Sb": 121.760,
+    "Te": 127.60,
+    "I": 126.90447,
+    "Xe": 131.293,
+    "Cs": 132.90545,
+    "Ba": 137.327,
+    "La": 138.9055,
+    "Ce": 140.116,
+    "Pr": 140.90765,
+    "Nd": 144.24,
+    "Sm": 150.36,
+    "Eu": 151.964,
+    "Gd": 157.25,
+    "Tb": 158.92534,
+    "Dy": 162.500,
+    "Ho": 164.93032,
+    "Er": 167.259,
+    "Tm": 168.93421,
+    "Yb": 173.04,
+    "Lu": 174.967,
+    "Hf": 178.49,
+    "Ta": 180.9479,
+    "W": 183.84,
+    "Re": 186.207,
+    "Os": 190.23,
+    "Ir": 192.217,
+    "Pt": 195.078,
+    "Au": 196.96655,
+    "Hg": 200.59,
+    "Tl": 204.3833,
+    "Pb": 207.2,
+    "Bi": 208.98038,
+    "Th": 232.0381,
+    "Pa": 231.03588,
+    "U": 238.02891,
+    # Remainder from https://ciaaw.org/atomic-masses.htm
+    "Np": 237.0,
+    "Pu": 244.0,
+    "Am": 243.0,
+    "Cm": 247.0,
+    "Bk": 247.0,
+    "Cf": 251.0,
+    "Es": 252.0,
+    "Fm": 257.0,
+    "Md": 258.0,
+    "No": 259.0,
+    "Lr": 262.0,
+    "Rf": 267.0,
+    "Db": 268.0,
+    "Sg": 271.0,
+    "Bh": 274.0,
+    "Hs": 269.0,
+    "Mt": 276.0,
+    "Ds": 281.0,
+    "Rg": 281.0,
+    "Cn": 285.0,
+    "Nh": 286.0,
+    "Fl": 289.0,
+    "Mc": 288.0,
+    "Lv": 293.0,
+    "Ts": 294.0,
+    "Og": 294.0,
+}
+
+# van der Walls radii from https://books.google.no/books?id=bNDMBQAAQBAJ
+vdw_radii = {
+    "H": 1.1,
+    "He": 1.4,
+    "Li": 1.82,
+    "Be": 1.53,
+    "B": 1.92,
+    "C": 1.7,
+    "N": 1.55,
+    "O": 1.52,
+    "F": 1.47,
+    "Ne": 1.54,
+    "Na": 2.27,
+    "Mg": 1.73,
+    "Al": 1.84,
+    "Si": 2.1,
+    "P": 1.8,
+    "S": 1.8,
+    "Cl": 1.75,
+    "Ar": 1.88,
+    "K": 2.75,
+    "Ca": 2.31,
+    "Sc": 2.15,
+    "Ti": 2.11,
+    "V": 2.07,
+    "Cr": 2.06,
+    "Mn": 2.05,
+    "Fe": 2.04,
+    "Co": 2.0,
+    "Ni": 1.97,
+    "Cu": 1.96,
+    "Zn": 2.01,
+    "Ga": 1.87,
+    "Ge": 2.11,
+    "As": 1.85,
+    "Se": 1.9,
+    "Br": 1.85,
+    "Kr": 2.02,
+    "Rb": 3.03,
+    "Sr": 2.49,
+    "Y": 2.32,
+    "Zr": 2.23,
+    "Nb": 2.18,
+    "Mo": 2.17,
+    "Tc": 2.16,
+    "Ru": 2.13,
+    "Rh": 2.1,
+    "Pd": 2.1,
+    "Ag": 2.11,
+    "Cd": 2.18,
+    "In": 1.93,
+    "Sn": 2.17,
+    "Sb": 2.06,
+    "Te": 2.06,
+    "I": 1.98,
+    "Xe": 2.16,
+    "Cs": 3.43,
+    "Ba": 2.68,
+    "La": 2.43,
+    "Ce": 2.42,
+    "Pr": 2.4,
+    "Nd": 2.39,
+    "Pm": 2.38,
+    "Sm": 2.36,
+    "Eu": 2.35,
+    "Gd": 2.34,
+    "Tb": 2.33,
+    "Dy": 2.31,
+    "Ho": 2.3,
+    "Er": 2.29,
+    "Tm": 2.27,
+    "Yb": 2.26,
+    "Lu": 2.24,
+    "Hf": 2.23,
+    "Ta": 2.22,
+    "W": 2.18,
+    "Re": 2.16,
+    "Os": 2.16,
+    "Ir": 2.13,
+    "Pt": 2.13,
+    "Au": 2.14,
+    "Hg": 2.23,
+    "Tl": 1.96,
+    "Pb": 2.02,
+    "Bi": 2.07,
+    "Po": 1.97,
+    "At": 2.02,
+    "Rn": 2.2,
+    "Fr": 3.48,
+    "Ra": 2.83,
+    "Ac": 2.47,
+    "Th": 2.45,
+    "Pa": 2.43,
+    "U": 2.41,
+    "Np": 2.39,
+    "Pu": 2.43,
+    "Am": 2.44,
+    "Cm": 2.45,
+    "Bk": 2.44,
+    "Cf": 2.45,
+    "Es": 2.45,
+    "Fm": 2.45,
+    "Md": 2.46,
+    "No": 2.46,
+    "Lr": 2.46,
+}
+
+"""
+Although a π-bond may not be well defined, it is useful to have a notion of
+a bond about which there is restricted rotation. The below sets are used to
+define which atoms may be π-bonded to another
+"""
+non_pi_elements = ["H", "He"]
+pi_valencies = {
+    "B": [1, 2],
+    "N": [1, 2],
+    "O": [1],
+    "C": [1, 2, 3],
+    "P": [1, 2, 3, 4],
+    "S": [1, 3, 4, 5],
+    "Si": [1, 2, 3],
+}
+
+# Standard definition of metallic elements: https://en.wikipedia.org/wiki/Metal
+# (all semi-metals not included)
+metals = [
+    "Li",
+    "Be",
+    "Na",
+    "Mg",
+    "Al",
+    "K",
+    "Ca",
+    "Sc",
+    "Ti",
+    "V",
+    "Cr",
+    "Mn",
+    "Fe",
+    "Co",
+    "Ni",
+    "Cu",
+    "Zn",
+    "Ga",
+    "Rb",
+    "Sr",
+    "Y",
+    "Zr",
+    "Nb",
+    "Mo",
+    "Tc",
+    "Ru",
+    "Rh",
+    "Pd",
+    "Ag",
+    "Cd",
+    "In",
+    "Sn",
+    "Cs",
+    "Ba",
+    "La",
+    "Ce",
+    "Pr",
+    "Nd",
+    "Pm",
+    "Sm",
+    "Eu",
+    "Gd",
+    "Tb",
+    "Dy",
+    "Ho",
+    "Er",
+    "Tm",
+    "Yb",
+    "Lu",
+    "Hf",
+    "Ta",
+    "W",
+    "Re",
+    "Os",
+    "Ir",
+    "Pt",
+    "Au",
+    "Hg",
+    "Tl",
+    "Pb",
+    "Bi",
+    "Po",
+    "Fr",
+    "Ra",
+    "Ac",
+    "Th",
+    "Pa",
+    "U",
+    "Np",
+    "Pu",
+    "Am",
+    "Cm",
+    "Bk",
+    "Cf",
+    "Es",
+    "Fm",
+    "Md",
+    "No",
+    "Lr",
+    "Rf",
+    "Db",
+    "Sg",
+    "Bh",
+    "Hs",
+    "Mt",
+    "Ds",
+    "Rg",
+    "Cn",
+    "Nh",
+    "Fl",
+    "Mc",
+    "Lv",
+]
+
+# Covalent radii in picometers from https://en.wikipedia.org/wiki/Covalent_radius
+_covalent_radii_pm = [
+    31.0,
+    28.0,
+    128.0,
+    96.0,
+    84.0,
+    76.0,
+    71.0,
+    66.0,
+    57.0,
+    58.0,
+    166.0,
+    141.0,
+    121.0,
+    111.0,
+    107.0,
+    105.0,
+    102.0,
+    106.0,
+    102.0,
+    203.0,
+    176.0,
+    170.0,
+    160.0,
+    153.0,
+    139.0,
+    161.0,
+    152.0,
+    150.0,
+    124.0,
+    132.0,
+    122.0,
+    122.0,
+    120.0,
+    119.0,
+    120.0,
+    116.0,
+    220.0,
+    195.0,
+    190.0,
+    175.0,
+    164.0,
+    154.0,
+    147.0,
+    146.0,
+    142.0,
+    139.0,
+    145.0,
+    144.0,
+    142.0,
+    139.0,
+    139.0,
+    138.0,
+    139.0,
+    140.0,
+    244.0,
+    215.0,
+    207.0,
+    204.0,
+    203.0,
+    201.0,
+    199.0,
+    198.0,
+    198.0,
+    196.0,
+    194.0,
+    192.0,
+    192.0,
+    189.0,
+    190.0,
+    187.0,
+    175.0,
+    187.0,
+    170.0,
+    162.0,
+    151.0,
+    144.0,
+    141.0,
+    136.0,
+    136.0,
+    132.0,
+    145.0,
+    146.0,
+    148.0,
+    140.0,
+    150.0,
+    150.0,
+]
+
+# Experimental bond lengths from https://cccbdb.nist.gov/diatomicexpbondx.asp
+_bond_lengths = {"HH": 0.741, "FF": 1.412, "ClCl": 1.988, "II": 2.665}
+
+
+_max_valances = {
+    "H": 1,
+    "He": 0,
+    "B": 4,
+    "C": 4,
+    "N": 4,
+    "O": 3,
+    "F": 1,
+    "Si": 4,
+    "P": 6,
+    "S": 6,
+    "Cl": 4,
+    "Br": 4,
+    "I": 6,
+    "Xe": 6,
+    "Al": 4,
+}

autodE/source/autode/bond_rearrangement.py

@@ -0,0 +1,876 @@
+import itertools
+import os
+from autode.geom import get_neighbour_list
+from autode.log import logger
+from autode.config import Config
+from autode.mol_graphs import (
+    get_bond_type_list,
+    get_fbonds,
+    is_isomorphic,
+    find_cycles,
+)
+
+
+def get_bond_rearrangs(reactant, product, name, save=True):
+    """For a reactant and product (mol_complex) find the set of breaking and
+    forming bonds that will turn reactants into products. This works by
+    determining the types of bonds that have been made/broken (i.e CH) and
+    then only considering rearrangements involving those bonds.
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        reactant (autode.species.ReactantComplex):
+
+        product (autode.species.ProductComplex):
+
+        name (str):
+
+    Keyword Arguments:
+        save (bool): Save bond rearrangements to a file for fast reloading
+
+    Returns:
+        (list(autode.bond_rearrangements.BondRearrangement)):
+    """
+    logger.info(f"Finding the possible forming and breaking bonds for {name}")
+
+    if os.path.exists(f"{name}_bond_rearrangs.txt"):
+        return get_bond_rearrangs_from_file(f"{name}_bond_rearrangs.txt")
+
+    if is_isomorphic(reactant.graph, product.graph) and product.n_atoms > 3:
+        logger.error(
+            "Reactant (complex) is isomorphic to product (complex). "
+            "Bond rearrangement cannot be determined unless the "
+            "substrates are limited in size"
+        )
+        return None
+
+    possible_brs = []
+
+    reac_bond_dict = get_bond_type_list(reactant.graph)
+    prod_bond_dict = get_bond_type_list(product.graph)
+
+    # list of bonds where this type of bond (e.g C-H) has less bonds in
+    # products than reactants
+    all_possible_bbonds = []
+
+    # list of bonds that can be formed of this bond type. This is only used
+    # if there is only one type of bbond, so can be overwritten for each new
+    # type of bbond
+    bbond_atom_type_fbonds = None
+
+    # list of bonds where this type of bond (e.g C-H) has more bonds in
+    #  products than reactants
+    all_possible_fbonds = []
+
+    # list of bonds that can be broken of this bond type. This is only used
+    # if there is only one type of fbond, so can be overwritten for each new
+    # type of fbond
+    fbond_atom_type_bbonds = None
+
+    # list of bonds where this type of bond (e.g C-H) has the same number of
+    # bonds in products and reactants
+    possible_bbond_and_fbonds = []
+
+    for reac_key, reac_bonds in reac_bond_dict.items():
+        prod_bonds = prod_bond_dict[reac_key]
+        possible_fbonds = get_fbonds(reactant.graph, reac_key)
+        if len(prod_bonds) < len(reac_bonds):
+            all_possible_bbonds.append(reac_bonds)
+            bbond_atom_type_fbonds = possible_fbonds
+        elif len(prod_bonds) > len(reac_bonds):
+            all_possible_fbonds.append(possible_fbonds)
+            fbond_atom_type_bbonds = reac_bonds
+        else:
+            if len(reac_bonds) != 0:
+                possible_bbond_and_fbonds.append([reac_bonds, possible_fbonds])
+
+    # The change in the number of bonds is > 0 as in the reaction
+    # initialisation reacs/prods are swapped if this is < 0
+    delta_n_bonds = (
+        reactant.graph.number_of_edges() - product.graph.number_of_edges()
+    )
+
+    if delta_n_bonds == 0:
+        funcs = [get_fbonds_bbonds_1b1f, get_fbonds_bbonds_2b2f]
+    elif delta_n_bonds == 1:
+        funcs = [get_fbonds_bbonds_1b, get_fbonds_bbonds_2b1f]
+    elif delta_n_bonds == 2:
+        funcs = [get_fbonds_bbonds_2b]
+    else:
+        logger.error(
+            f"Cannot treat a change in bonds "
+            f"reactant <- product of {delta_n_bonds}"
+        )
+        return None
+
+    for func in funcs:
+        possible_brs = func(
+            reactant,
+            product,
+            possible_brs,
+            all_possible_bbonds,
+            all_possible_fbonds,
+            possible_bbond_and_fbonds,
+            bbond_atom_type_fbonds,
+            fbond_atom_type_bbonds,
+        )
+
+        if len(possible_brs) > 0:
+            logger.info(
+                f"Found a molecular graph rearrangement to products "
+                f"with {func.__name__}"
+            )
+            # This function will return with the first bond rearrangement
+            # that leads to products
+
+            n_bond_rearrangs = len(possible_brs)
+            if n_bond_rearrangs > 1:
+                logger.info(
+                    f"Multiple *{n_bond_rearrangs}* possible bond "
+                    f"breaking/makings are possible"
+                )
+                possible_brs = strip_equiv_bond_rearrs(possible_brs, reactant)
+                prune_small_ring_rearrs(possible_brs, reactant)
+
+            if save:
+                save_bond_rearrangs_to_file(
+                    possible_brs, filename=f"{name}_BRs.txt"
+                )
+
+            logger.info(
+                f"Found *{len(possible_brs)}* bond "
+                f"rearrangement(s) that lead to products"
+            )
+            return possible_brs
+
+    return None
+
+
+def save_bond_rearrangs_to_file(brs, filename="bond_rearrangs.txt"):
+    """
+    Save a list of bond rearrangements to a file in plane text
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        brs (list(autode.bond_rearrangements.BondRearrangement)):
+
+        filename (str):
+    """
+    logger.info(f"Saving bond rearrangements to {filename}")
+
+    with open(filename, "w") as file:
+        for bond_rearrang in brs:
+            print("fbonds", file=file)
+            for fbond in bond_rearrang.fbonds:
+                print(*fbond, file=file)
+            print("bbonds", file=file)
+            for bbond in bond_rearrang.bbonds:
+                print(*bbond, file=file)
+            print("end", file=file)
+
+    return None
+
+
+def get_bond_rearrangs_from_file(filename="bond_rearrangs.txt"):
+    """
+    Extract a list of bond rearrangements from a file
+
+    ---------------------------------------------------------------------------
+    Keyword Arguments:
+        filename (str):
+
+    Returns:
+        (list(autode.bond_rearrangements.BondRearrangement)):
+    """
+    logger.info("Getting bond rearrangements from file")
+
+    if not os.path.exists(filename):
+        logger.error("No bond rearrangements file")
+        return None
+
+    bond_rearrangs = []
+
+    with open(filename, "r") as br_file:
+        fbonds_block = False
+        fbonds, bbonds = [], []
+        for line in br_file:
+            if "fbonds" in line:
+                fbonds_block = True
+
+            if "bbonds" in line:
+                fbonds_block = False
+
+            if len(line.split()) == 2:
+                atom_idx0, atom_idx1 = (int(val) for val in line.split())
+
+                if fbonds_block:
+                    fbonds.append((atom_idx0, atom_idx1))
+                if not fbonds_block:
+                    bbonds.append((atom_idx0, atom_idx1))
+
+            if "end" in line:
+                bond_rearrangs.append(
+                    BondRearrangement(
+                        forming_bonds=fbonds, breaking_bonds=bbonds
+                    )
+                )
+                fbonds = []
+                bbonds = []
+
+    return bond_rearrangs
+
+
+def add_bond_rearrangment(bond_rearrangs, reactant, product, fbonds, bbonds):
+    """
+    For a possible bond rearrangement, sees if the products are made, and
+    adds it to the bond rearrang list if it does
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        bond_rearrangs (list(autode.bond_rearrangements.BondRearrangement)):
+                        list of working bond rearrangements
+
+        reactant (autode.species.Complex): Reactant complex
+
+        product (autode.species.Complex): Product complex
+
+        fbonds (list(tuple)): list of bonds to be made
+
+        bbonds (list(tuple)): list of bonds to be broken
+
+    Returns:
+        (list(autode.bond_rearrangements.BondRearrangement)):
+    """
+
+    # Check that the bond rearrangement doesn't exceed standard atom valances
+    bbond_atoms = [atom for bbond in bbonds for atom in bbond]
+    for fbond in fbonds:
+        for idx in fbond:
+            if (
+                reactant.graph.degree(idx)
+                == reactant.atoms[idx].maximal_valance
+                and idx not in bbond_atoms
+            ):
+                # If we are here then there is at least one atom that will
+                # exceed it's maximal valance, therefore
+                # we don't need to run isomorphism
+                return bond_rearrangs
+
+    rearranged_graph = generate_rearranged_graph(
+        reactant.graph, fbonds=fbonds, bbonds=bbonds
+    )
+
+    if is_isomorphic(rearranged_graph, product.graph):
+        ordered_fbonds = []
+        ordered_bbonds = []
+        for fbond in fbonds:
+            if fbond[0] < fbond[1]:
+                ordered_fbonds.append((fbond[0], fbond[1]))
+            else:
+                ordered_fbonds.append((fbond[1], fbond[0]))
+        for bbond in bbonds:
+            if bbond[0] < bbond[1]:
+                ordered_bbonds.append((bbond[0], bbond[1]))
+            else:
+                ordered_bbonds.append((bbond[1], bbond[0]))
+
+        ordered_fbonds.sort()
+        ordered_bbonds.sort()
+        bond_rearrangs.append(
+            BondRearrangement(
+                forming_bonds=ordered_fbonds, breaking_bonds=ordered_bbonds
+            )
+        )
+
+    return bond_rearrangs
+
+
+def generate_rearranged_graph(graph, fbonds, bbonds):
+    """Generate a rearranged graph by breaking bonds (edge) and forming others
+    (edge)
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        graph (nx.Graph): reactant graph
+
+        fbonds (list(tuple)): list of bonds to be made
+
+        bbonds (list(tuple)): list of bonds to be broken
+
+    Returns:
+        nx.Graph: rearranged graph
+    """
+
+    rearranged_graph = graph.copy()
+    for fbond in fbonds:
+        rearranged_graph.add_edge(*fbond)
+    for bbond in bbonds:
+        rearranged_graph.remove_edge(*bbond)
+
+    return rearranged_graph
+
+
+def get_fbonds_bbonds_1b(
+    reac,
+    prod,
+    possible_brs,
+    all_possible_bbonds,
+    all_possible_fbonds,
+    possible_bbond_and_fbonds,
+    bbond_atom_type_fbonds,
+    fbond_atom_type_bbonds,
+):
+    logger.info("Getting possible 1 breaking bond rearrangements")
+
+    for bbond in all_possible_bbonds[0]:
+        # Break one bond
+        possible_brs = add_bond_rearrangment(
+            possible_brs, reac, prod, fbonds=[], bbonds=[bbond]
+        )
+
+    return possible_brs
+
+
+def get_fbonds_bbonds_2b(
+    reac,
+    prod,
+    possible_brs,
+    all_possible_bbonds,
+    all_possible_fbonds,
+    possible_bbond_and_fbonds,
+    bbond_atom_type_fbonds,
+    fbond_atom_type_bbonds,
+):
+    logger.info("Getting possible 2 breaking bond rearrangements")
+
+    if len(all_possible_bbonds) == 1:
+        # Break two bonds of the same type
+        for bbond1, bbond2 in itertools.combinations(
+            all_possible_bbonds[0], 2
+        ):
+            possible_brs = add_bond_rearrangment(
+                possible_brs, reac, prod, fbonds=[], bbonds=[bbond1, bbond2]
+            )
+
+    elif len(all_possible_bbonds) == 2:
+        # Break two bonds of different types
+        for bbond1, bbond2 in itertools.product(
+            all_possible_bbonds[0], all_possible_bbonds[1]
+        ):
+            possible_brs = add_bond_rearrangment(
+                possible_brs, reac, prod, fbonds=[], bbonds=[bbond1, bbond2]
+            )
+
+    return possible_brs
+
+
+def get_fbonds_bbonds_1b1f(
+    reac,
+    prod,
+    possible_brs,
+    all_possible_bbonds,
+    all_possible_fbonds,
+    possible_bbond_and_fbonds,
+    bbond_atom_type_fbonds,
+    fbond_atom_type_bbonds,
+):
+    logger.info(
+        "Getting possible 1 breaking and 1 forming bond " "rearrangements"
+    )
+
+    if len(all_possible_bbonds) == 1 and len(all_possible_fbonds) == 1:
+        # Make and break a bond of different types
+        for fbond, bbond in itertools.product(
+            all_possible_fbonds[0], all_possible_bbonds[0]
+        ):
+            possible_brs = add_bond_rearrangment(
+                possible_brs, reac, prod, fbonds=[fbond], bbonds=[bbond]
+            )
+
+    elif len(all_possible_bbonds) == 0 and len(all_possible_fbonds) == 0:
+        # Make and break a bond of the same type
+        for bbonds, fbonds in possible_bbond_and_fbonds:
+            for bbond, fbond in itertools.product(bbonds, fbonds):
+                possible_brs = add_bond_rearrangment(
+                    possible_brs, reac, prod, fbonds=[fbond], bbonds=[bbond]
+                )
+
+    return possible_brs
+
+
+def get_fbonds_bbonds_2b1f(
+    reac,
+    prod,
+    possible_brs,
+    all_possible_bbonds,
+    all_possible_fbonds,
+    possible_bbond_and_fbonds,
+    bbond_atom_type_fbonds,
+    fbond_atom_type_bbonds,
+):
+    logger.info(
+        "Getting possible 2 breaking and 1 forming bond rearrangements"
+    )
+
+    if len(all_possible_bbonds) == 2 and len(all_possible_fbonds) == 1:
+        # Make a bond and break two bonds, all of different types
+        possibles = itertools.product(
+            all_possible_fbonds[0],
+            all_possible_bbonds[0],
+            all_possible_bbonds[1],
+        )
+
+        for fbond, bbond1, bbond2 in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond],
+                bbonds=[bbond1, bbond2],
+            )
+
+    elif len(all_possible_bbonds) == 1 and len(all_possible_fbonds) == 1:
+        # Make a bond of one type, break two bonds of another type
+        two_same_possibles = itertools.combinations(all_possible_bbonds[0], 2)
+        possibles = itertools.product(
+            all_possible_fbonds[0], two_same_possibles
+        )
+
+        for fbond, (bbond1, bbond2) in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond],
+                bbonds=[bbond1, bbond2],
+            )
+
+    elif len(all_possible_bbonds) == 1 and len(all_possible_fbonds) == 0:
+        for bbonds, fbonds in possible_bbond_and_fbonds:
+            # Make and break a bond of one type, break a bond of a different
+            # type
+            possibles = itertools.product(
+                fbonds, all_possible_bbonds[0], bbonds
+            )
+
+            for fbond, bbond1, bbond2 in possibles:
+                possible_brs = add_bond_rearrangment(
+                    possible_brs,
+                    reac,
+                    prod,
+                    fbonds=[fbond],
+                    bbonds=[bbond1, bbond2],
+                )
+
+        # Make and break two bonds, all of the same type
+        two_same_possibles = itertools.combinations(all_possible_bbonds[0], 2)
+        possibles = itertools.product(
+            bbond_atom_type_fbonds, two_same_possibles
+        )
+
+        for fbond, (bbond1, bbond2) in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond],
+                bbonds=[bbond1, bbond2],
+            )
+
+    return possible_brs
+
+
+def get_fbonds_bbonds_2b2f(
+    reac,
+    prod,
+    possible_brs,
+    all_possible_bbonds,
+    all_possible_fbonds,
+    possible_bbond_and_fbonds,
+    bbond_atom_type_fbonds,
+    fbond_atom_type_bbonds,
+):
+    logger.info(
+        "Getting possible 2 breaking and 2 forming bond rearrangements"
+    )
+
+    if len(all_possible_bbonds) == 2 and len(all_possible_fbonds) == 2:
+        # Make two bonds and break two bonds, all of different types
+        possibles = itertools.product(
+            all_possible_fbonds[0],
+            all_possible_fbonds[1],
+            all_possible_bbonds[0],
+            all_possible_bbonds[1],
+        )
+
+        for fbond1, fbond2, bbond1, bbond2 in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond1, fbond2],
+                bbonds=[bbond1, bbond2],
+            )
+
+    elif len(all_possible_bbonds) == 2 and len(all_possible_fbonds) == 1:
+        # Make two bonds of the same type, break two bonds of different types
+        two_same_possibles = itertools.combinations(all_possible_fbonds[0], 2)
+        possibles = itertools.product(
+            all_possible_bbonds[0], all_possible_bbonds[1], two_same_possibles
+        )
+
+        for bbond1, bbond2, (fbond1, fbond2) in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond1, fbond2],
+                bbonds=[bbond1, bbond2],
+            )
+
+    elif len(all_possible_bbonds) == 1 and len(all_possible_fbonds) == 2:
+        # Make two bonds of different types, break two bonds of the same type
+        two_same_possibles = itertools.combinations(all_possible_bbonds[0], 2)
+        possibles = itertools.product(
+            all_possible_fbonds[0], all_possible_fbonds[1], two_same_possibles
+        )
+
+        for fbond1, fbond2, (bbond1, bbond2) in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond1, fbond2],
+                bbonds=[bbond1, bbond2],
+            )
+
+    elif len(all_possible_bbonds) == 1 and len(all_possible_fbonds) == 1:
+        two_f_possibles = itertools.combinations(all_possible_fbonds[0], 2)
+        two_b_possibles = itertools.combinations(all_possible_bbonds[0], 2)
+        possibles = itertools.product(two_f_possibles, two_b_possibles)
+
+        for (fbond1, fbond2), (bbond1, bbond2) in possibles:
+            # Make two bonds of the same type, break two bonds of another type
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond1, fbond2],
+                bbonds=[bbond1, bbond2],
+            )
+
+        for bbonds, fbonds in possible_bbond_and_fbonds:
+            # Make one bonds of one type, break one bond of another type, make
+            # and break a bond of a third type
+            possibles = itertools.product(
+                all_possible_fbonds[0], fbonds, all_possible_bbonds[0], bbonds
+            )
+
+            for fbond1, fbond2, bbond1, bbond2 in possibles:
+                possible_brs = add_bond_rearrangment(
+                    possible_brs,
+                    reac,
+                    prod,
+                    fbonds=[fbond1, fbond2],
+                    bbonds=[bbond1, bbond2],
+                )
+
+        # Make a bond of one type, make and break two bonds of another type
+        two_b_possibles = itertools.combinations(all_possible_bbonds[0], 2)
+        possibles = itertools.product(
+            all_possible_fbonds[0], bbond_atom_type_fbonds, two_b_possibles
+        )
+
+        for fbond1, fbond2, (bbond1, bbond2) in possibles:
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond1, fbond2],
+                bbonds=[bbond1, bbond2],
+            )
+
+        two_f_possibles = itertools.combinations(all_possible_fbonds[0], 2)
+        possibles = itertools.product(
+            all_possible_bbonds[0], fbond_atom_type_bbonds, two_f_possibles
+        )
+
+        for bbond1, bbond2, (fbond1, fbond2) in possibles:
+            # Break a bond of one type, make two and break one bond of another
+            #  type
+            possible_brs = add_bond_rearrangment(
+                possible_brs,
+                reac,
+                prod,
+                fbonds=[fbond1, fbond2],
+                bbonds=[bbond1, bbond2],
+            )
+
+    elif len(all_possible_bbonds) == 0 and len(all_possible_fbonds) == 0:
+        possibles_b_f = itertools.combinations(possible_bbond_and_fbonds, 2)
+
+        for (bbonds1, fbonds1), (bbonds2, fbonds2) in possibles_b_f:
+            # Make and break a bond of one type, make and break a bond of
+            # another type
+            possibles = itertools.product(fbonds1, bbonds1, fbonds2, bbonds2)
+
+            for fbond1, bbond1, fbond2, bbond2 in possibles:
+                possible_brs = add_bond_rearrangment(
+                    possible_brs,
+                    reac,
+                    prod,
+                    fbonds=[fbond1, fbond2],
+                    bbonds=[bbond1, bbond2],
+                )
+
+        for bbonds, fbonds in possible_bbond_and_fbonds:
+            # Make two and break two bonds, all of the same type
+            possibles = itertools.product(
+                itertools.combinations(fbonds, 2),
+                itertools.combinations(bbonds, 2),
+            )
+
+            for (fbond1, fbond2), (bbond1, bbond2) in possibles:
+                possible_brs = add_bond_rearrangment(
+                    possible_brs,
+                    reac,
+                    prod,
+                    fbonds=[fbond1, fbond2],
+                    bbonds=[bbond1, bbond2],
+                )
+
+    return possible_brs
+
+
+def strip_equiv_bond_rearrs(possible_brs, mol, depth=6):
+    """Remove any bond rearrangement from possible_brs for which
+    there is already an equivalent in the unique_bond_rearrangements list
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        possible_brs (list(BondRearrangement)):
+        mol (autode.species.Complex): Reactant
+
+    Keyword Arguments:
+        depth (int): Depth of neighbour list that must be identical for a set
+               of atoms to be considered equivalent (default: {6})
+
+    Returns:
+        (list(BondRearrangement)): stripped list of BondRearrangement objects
+    """
+    logger.info(
+        "Stripping the forming and breaking bond list by discarding "
+        "rearrangements with equivalent atoms"
+    )
+
+    unique_brs = []
+
+    for br in possible_brs:
+        bond_rearrang_is_unique = True
+
+        # Compare bond_rearrang to all those already considered to be unique,
+        for unique_br in unique_brs:
+            if unique_br.get_active_atom_neighbour_lists(
+                species=mol, depth=depth
+            ) == br.get_active_atom_neighbour_lists(species=mol, depth=depth):
+                bond_rearrang_is_unique = False
+
+        if bond_rearrang_is_unique:
+            unique_brs.append(br)
+
+    logger.info(
+        f"Stripped {len(possible_brs) - len(unique_brs)} "
+        "bond rearrangements"
+    )
+    return unique_brs
+
+
+def prune_small_ring_rearrs(possible_brs, mol):
+    """
+    Remove any bond rearrangements that go via small (3, 4) rings if there is
+    an alternative that goes vie
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        possible_brs (list(BondRearrangement)):
+
+        mol (autode.species.Complex): Reactant
+    """
+    small_ring_sizes = (3, 4)
+
+    if not Config.skip_small_ring_tss:
+        logger.info("Not pruning small ring TSs")
+        return None
+
+    # Membered-ness of rings in each bond rearrangement
+    n_mem_rings = [br.n_membered_rings(mol) for br in possible_brs]
+
+    # Unique elements involved in each bond rearrangement
+    elems = [
+        set(
+            mol.atoms[i].label
+            for i in range(mol.n_atoms)
+            if i in br.active_atoms
+        )
+        for br in possible_brs
+    ]
+
+    logger.info(
+        f"Pruning {len(possible_brs)} to remove any "
+        f"{small_ring_sizes}-membered rings where others are possible"
+    )
+
+    excluded_idxs = []
+    for i, br in enumerate(possible_brs):
+        logger.info(
+            f"Checking bond rearrangement {i} with rings:"
+            f" {n_mem_rings[i]} and atom indexes: {br}"
+        )
+
+        # Only consider brs with at least one small ring
+        if not any(n_mem in small_ring_sizes for n_mem in n_mem_rings[i]):
+            continue
+
+        # Check against all other rearrangements
+        for j, other_br in enumerate(possible_brs):
+            # Only consider brs with the same set of elements
+            if elems[i] != elems[j]:
+                continue
+
+            # Needs to have the same number of rings
+            if len(n_mem_rings[i]) != len(n_mem_rings[j]):
+                continue
+
+            # Exclude i if j has a larger smallest ring size
+            if min(n_mem_rings[i]) < min(n_mem_rings[j]):
+                excluded_idxs.append(i)
+                break
+
+    logger.info(
+        f"Excluding {len(excluded_idxs)} bond rearrangements based on "
+        f"small rings"
+    )
+
+    # Delete the excluded bond rearrangements (sorted high ->  low, so the
+    # idxs remain the same while deleting)
+    for idx in sorted(excluded_idxs, reverse=True):
+        del possible_brs[idx]
+
+    return None
+
+
+class BondRearrangement:
+    def __eq__(self, other):
+        return self.fbonds == other.fbonds and self.bbonds == other.bbonds
+
+    def __str__(self):
+        return "_".join(f"{bond[0]}-{bond[1]}" for bond in self.all)
+
+    def get_active_atom_neighbour_lists(self, species, depth):
+        """
+        Get neighbour lists of all the active atoms in the molecule
+        (reactant complex)
+
+        -----------------------------------------------------------------------
+        Arguments:
+            species (autode.species.Species | autode.species.Complex):
+            depth (int): Depth of the neighbour list to consider
+
+        Returns:
+            (list(list(str))):
+        """
+
+        def nl(idx):
+            mol_idxs = None
+
+            try:
+                mol_idxs = next(
+                    species.atom_indexes(i)
+                    for i in range(species.n_molecules)
+                    if idx in species.atom_indexes(i)
+                )
+
+            except (StopIteration, AttributeError):
+                logger.warning("Active atom index not found in any molecules")
+
+            nl_labels = get_neighbour_list(
+                species, atom_i=idx, index_set=mol_idxs
+            )
+            return nl_labels[:depth]
+
+        return [nl(idx) for idx in self.active_atoms]
+
+    def n_membered_rings(self, mol):
+        """
+        Find the membered-ness of the rings involved in this bond rearrangement
+        will add the forming bonds to the graph to determine
+
+        -----------------------------------------------------------------------
+        Arguments:
+            (autode.species.Species):
+
+        Returns:
+            (list(int)):
+        """
+        assert mol.graph is not None
+        graph = mol.graph.copy()
+
+        for fbond in self.fbonds:
+            if fbond not in graph.edges:
+                graph.add_edge(*fbond)
+
+        rings = find_cycles(graph)
+        n_mem_rings = []
+
+        # Full enumeration over all atoms and rings - could be faster..
+        for ring in rings:
+            for atom_idx in self.active_atoms:
+                if atom_idx in ring:
+                    # This ring has at least one active atom in
+                    n_mem_rings.append(len(ring))
+
+                    # don't add the same ring more than once
+                    break
+
+        return n_mem_rings
+
+    @property
+    def fatoms(self):
+        """Unique atoms indexes involved in forming bonds"""
+        return list(sorted(set([i for bond in self.fbonds for i in bond])))
+
+    @property
+    def batoms(self):
+        """Unique atoms indexes involved in breaking bonds"""
+        return list(sorted(set([i for bond in self.bbonds for i in bond])))
+
+    @property
+    def active_atoms(self):
+        """Unique atom indexes in forming or breaking bonds"""
+        return list(sorted(set(a for b in self.all for a in b)))
+
+    @property
+    def n_fbonds(self):
+        return len(self.fbonds)
+
+    @property
+    def n_bbonds(self):
+        return len(self.bbonds)
+
+    def __init__(self, forming_bonds=None, breaking_bonds=None):
+        """
+        Bond rearrangement
+
+        -----------------------------------------------------------------------
+        Keyword Arguments:
+            forming_bonds (list(tuple(int))): List of atom pairs that are
+                        forming in this reaction
+
+            breaking_bonds (list(tuple(int))): List of atom pairs that are
+                           breaking in the reaction
+        """
+
+        self.fbonds = forming_bonds if forming_bonds is not None else []
+        self.bbonds = breaking_bonds if breaking_bonds is not None else []
+
+        self.all = self.fbonds + self.bbonds

autodE/source/autode/bonds.py

@@ -0,0 +1,87 @@
+class ScannedBond:
+    def __str__(self):
+        i, j = self.atom_indexes
+        return f"{i}-{j}"
+
+    def __getitem__(self, item):
+        return self.atom_indexes[item]
+
+    @property
+    def dr(self):
+        """Change in distance for this bond (∆r / Å)"""
+        if self.curr_dist is None or self.final_dist is None:
+            return 0
+
+        return self.final_dist - self.curr_dist
+
+    def __init__(self, atom_indexes):
+        """
+        Bond with a current and final distance which will be scanned over
+
+        -----------------------------------------------------------------------
+        Arguments:
+            atom_indexes (tuple(int)): Atom indexes that make this
+            'bond' e.g. (0, 1)
+        """
+        assert len(atom_indexes) == 2
+
+        self.atom_indexes = atom_indexes
+
+        self.curr_dist = None
+        self.final_dist = None
+
+        self.forming = False
+        self.breaking = False
+
+
+class FormingBond(ScannedBond):
+    def __init__(self, atom_indexes, species, final_species=None):
+        """
+        Forming bond with current and final distances
+
+        -----------------------------------------------------------------------
+        Arguments:
+            atom_indexes (tuple(int)):
+
+            species (autode.species.Species):
+        """
+        super().__init__(atom_indexes)
+        self.forming = True
+
+        i, j = self.atom_indexes
+        self.curr_dist = species.distance(i=i, j=j)
+
+        if final_species is None:
+            self.final_dist = species.atoms.eqm_bond_distance(i, j)
+        else:
+            self.final_dist = final_species.distance(*atom_indexes)
+
+
+class BreakingBond(ScannedBond):
+    def __init__(self, atom_indexes, species, final_species=None):
+        """
+        Form a breaking bond with current and final distances
+
+        -----------------------------------------------------------------------
+        Arguments:
+            atom_indexes (tuple(int)):
+
+            species (autode.species.Species):
+
+            final_species (autode.species.Species | None):
+        """
+        super().__init__(atom_indexes)
+        self.breaking = True
+
+        self.curr_dist = species.distance(*self.atom_indexes)
+
+        if final_species is None:
+            self.final_dist = 2.0 * self.curr_dist
+
+        else:
+            # Take the smallest possible final distance, thus the shortest
+            # path to traverse
+            self.final_dist = min(
+                final_species.distance(*self.atom_indexes),
+                2.0 * self.curr_dist,
+            )

autodE/source/autode/bracket/__init__.py

@@ -0,0 +1,3 @@
+from autode.bracket.dhs import DHS, DHSGS
+
+__all__ = ["DHS", "DHSGS"]

autodE/source/autode/bracket/base.py

@@ -0,0 +1,316 @@
+from typing import Union, Optional, TYPE_CHECKING
+from abc import ABC, abstractmethod
+
+from autode.values import Distance, GradientRMS
+from autode.bracket.imagepair import EuclideanImagePair
+from autode.log import logger
+from autode.utils import work_in
+from autode import Config
+
+if TYPE_CHECKING:
+    from autode.species.species import Species
+    from autode.wrappers.methods import Method
+
+
+class BaseBracketMethod(ABC):
+    """
+    Base class for all bracketing methods
+    """
+
+    def __init__(
+        self,
+        initial_species: "Species",
+        final_species: "Species",
+        maxiter: int = 300,
+        dist_tol: Union[Distance, float] = Distance(1.0, "ang"),
+        gtol: Union[GradientRMS, float] = GradientRMS(1.0e-3, "ha/ang"),
+        cineb_at_conv: bool = False,
+        barrier_check: bool = True,
+    ):
+        """
+        Bracketing methods find transition state by using two images, one
+        for the reactant state and another representing the product state.
+        These methods move the images continuously until they converge at
+        the transition state (TS), i.e. they bracket the TS from both ends.
+        It is optionally possible to run a CI-NEB (with only one intervening
+        image) from the end-points of a converged bracketing method
+        calculation to get much closer to the actual TS.
+
+        Args:
+            initial_species: The "reactant" species
+            final_species: The "product" species
+            maxiter: Maximum number of energy-gradient evaluations
+            dist_tol: The distance tolerance at which the method
+                      will stop, in units of Å if not given
+            gtol: Gradient tolerance for optimisation steps in
+                  the method, units Ha/Å if not given
+            cineb_at_conv: Whether to run a CI-NEB with from the final points
+            barrier_check: Whether to stop the calculation if one image is
+                           detected to have jumped over the barrier. Do not
+                           turn this off unless you are absolutely sure!
+        """
+        # imgpair type must be set by subclass
+        self.imgpair: Optional["EuclideanImagePair"] = None
+        self._species: "Species" = initial_species.copy()
+
+        self._maxiter = int(maxiter)
+        self._dist_tol = Distance(dist_tol, units="ang")
+        self._gtol = GradientRMS(gtol, units="Ha/ang")
+
+        self._should_run_cineb = bool(cineb_at_conv)
+        self._barrier_check = bool(barrier_check)
+
+    @property
+    def _name(self) -> str:
+        """Name of the current bracketing method, obtained from class name"""
+        return type(self).__name__
+
+    @property
+    def ts_guess(self) -> Optional["Species"]:
+        """Get the TS guess from image-pair"""
+        assert self.imgpair is not None, "Must have an image pair for TS guess"
+        return self.imgpair.ts_guess
+
+    @property
+    def converged(self) -> bool:
+        """Whether the bracketing method has converged or not"""
+        assert self.imgpair is not None, "Must have an image pair"
+
+        # NOTE: Usually geometry optimisation is done in separate
+        # micro-iters, so gradient is checked elsewhere
+        return self.imgpair.dist <= self._dist_tol
+
+    @property
+    @abstractmethod
+    def _macro_iter(self) -> int:
+        """The number of macro-iterations run with this method"""
+
+    @property
+    @abstractmethod
+    def _micro_iter(self) -> int:
+        """Total number of micro-iterations run with this method"""
+
+    @abstractmethod
+    def _initialise_run(self) -> None:
+        """Initialise the bracketing method run"""
+
+    @abstractmethod
+    def _step(self) -> None:
+        """
+        One step of the bracket method, with one macro-iteration
+        and multiple micro-iterations. This must also set new
+        coordinates for the next step
+        """
+
+    def _log_convergence(self) -> None:
+        """
+        Log the convergence of the bracket method. Only logs macro-iters,
+        subclasses may implement further logging for micro-iters
+        """
+        assert self.imgpair is not None, "Must have an image pair to log"
+
+        logger.info(
+            f"{self._name} Macro-iteration #{self._macro_iter}: "
+            f"Distance = {self.imgpair.dist:.4f}; Energy (initial species) = "
+            f"{self.imgpair.left_coords.e:.6f}; Energy (final species) = "
+            f"{self.imgpair.right_coords.e:.6f}"
+        )
+
+    @property
+    def _exceeded_maximum_iteration(self) -> bool:
+        """Whether it has exceeded the number of maximum micro-iterations"""
+        if self._micro_iter >= self._maxiter:
+            logger.error(
+                f"Reached the maximum number of micro-iterations "
+                f"*{self._maxiter}*"
+            )
+            return True
+        else:
+            return False
+
+    def calculate(
+        self,
+        method: "Method",
+        n_cores: Optional[int] = None,
+    ) -> None:
+        """
+        Run the bracketing method calculation using the method for
+        energy/gradient calculation, with n_cores. Runs CI-NEB at
+        the end if requested; then save the .xyz trajectories,
+        plot the energies and finally save the peak as TS guess.
+        This function should be called only once!
+
+        Args:
+            method (Method): Method used for calculating energy/gradients
+            n_cores (int): Number of cores to use for calculation
+        """
+
+        @work_in(self._name.lower())
+        def run():
+            self._calculate(method, n_cores)
+
+        run()
+        return None
+
+    def _calculate(
+        self,
+        method: "Method",
+        n_cores: Optional[int] = None,
+    ) -> None:
+        """
+        Actually runs the calculation, it is wrapped around in calculate()
+        so that the results are placed in a sub-folder
+        """
+        assert self.imgpair is not None, "Must have set image pair"
+
+        n_cores = Config.n_cores if n_cores is None else int(n_cores)
+        self.imgpair.set_method_and_n_cores(method, n_cores)
+        self.imgpair.initialise_trj(
+            f"{self._name}_left_history.zip", f"{self._name}_right_history.zip"
+        )
+        self._initialise_run()
+
+        logger.info(f"Starting {self._name} method to find transition state")
+
+        while not self.converged:
+            self._step()
+
+            if self.imgpair.has_jumped_over_barrier:
+                # TODO: implement image pair regeneration
+                logger.error(
+                    "One image has probably jumped over the barrier, in"
+                    f" {self._name} TS search. Please check the"
+                    f" results carefully"
+                )
+                if self._barrier_check:
+                    logger.info(f"Stopping {self._name} calculation")
+                    break
+
+            if self._exceeded_maximum_iteration:
+                break
+
+            self._log_convergence()
+
+        # exited main loop, run CI-NEB if required and bracket converged
+        if self._should_run_cineb:
+            if self.converged and not self.imgpair.has_jumped_over_barrier:
+                self.run_cineb()
+            else:
+                logger.warning(
+                    f"{self._name} calculation has not converged"
+                    f" properly or one side has jumped over the barrier,"
+                    f" skipping CI-NEB run"
+                )
+
+        logger.info(
+            f"Finished {self._name} procedure in {self._macro_iter} "
+            f"macro-iterations consisting of {self._micro_iter} micro-"
+            f"iterations (optimiser steps). {self._name} is "
+            f"{'converged' if self.converged else 'not converged'}"
+        )
+        self.imgpair.close_trj()
+        self.print_geometries()
+        self.plot_energies()
+        if self.converged and self.ts_guess is not None:
+            self.ts_guess.print_xyz_file(filename=f"{self._name}_ts_guess.xyz")
+        return None
+
+    def print_geometries(
+        self,
+        init_trj_filename: Optional[str] = None,
+        final_trj_filename: Optional[str] = None,
+        total_trj_filename: Optional[str] = None,
+    ) -> None:
+        """
+        Write trajectories as *.xyz files, one for the initial species,
+        one for final species, and one for the whole trajectory, including
+        any CI-NEB run from the final end points. The default names for
+        the trajectories must be set in individual subclasses
+        """
+        assert self.imgpair is not None, "Must have an image pair to plot"
+
+        init_trj_filename = (
+            init_trj_filename
+            if init_trj_filename is not None
+            else f"initial_species_{self._name}.trj.xyz"
+        )
+        final_trj_filename = (
+            final_trj_filename
+            if final_trj_filename is not None
+            else f"final_species_{self._name}.trj.xyz"
+        )
+        total_trj_filename = (
+            total_trj_filename
+            if total_trj_filename is not None
+            else f"total_trajectory_{self._name}.trj.xyz"
+        )
+        self.imgpair.print_geometries(
+            init_trj_filename, final_trj_filename, total_trj_filename
+        )
+
+        return None
+
+    def plot_energies(
+        self,
+        filename: Optional[str] = None,
+        distance_metric: str = "relative",
+    ) -> None:
+        """
+        Plot the energies of the bracket method run, taking
+        into account any CI-NEB interpolation that may have been
+        done.
+
+        The distance metric chooses what the x-axis means;
+        "relative" means that the points will be plotted in the order
+        in which they appear in the total history, and the x-axis
+        numbers will represent the relative distances between two
+        adjacent points (giving an approximate reaction coordinate).
+        "from_start" will calculate the distance of each point from
+        the starting reactant structure and use that as the x-axis
+        position. If distance metric is set to "index", then the x-axis
+        will simply be integer numbers representing each point in order
+
+        Args:
+            filename (str|None): Name of the file (optional)
+            distance_metric (str): "relative" or "from_start" or "index"
+        """
+        assert self.imgpair is not None, "Must have an image pair to plot"
+
+        filename = (
+            filename
+            if filename is not None
+            else f"{self._name}_path_energy_plot.pdf"
+        )
+        self.imgpair.plot_energies(filename, distance_metric)
+        return None
+
+    def run_cineb(self) -> None:
+        """
+        Run CI-NEB from the end-points of a converged bracketing
+        calculation. Uses only one intervening image for the
+        CI-NEB calculation (which is okay as the bracketing method
+        should bring the ends very close to the TS). The result from
+        the CI-NEB calculation is stored as coordinates.
+        """
+        assert self.imgpair is not None, "Must have image pair to run CINEB"
+
+        if not self._micro_iter > 0:
+            logger.error(
+                f"Must run {self._name} calculation before"
+                f"running the CI-NEB calculation"
+            )
+            return None
+
+        if not self.converged or self.imgpair.dist > 2.0:
+            logger.warning(
+                f"{self._name} method has not converged sufficiently,"
+                f" running a CI-NEB calculation now may cause errors."
+                f" Please check results carefully."
+            )
+        else:
+            logger.info(
+                f"{self._name} has converged, running CI-NEB"
+                f" calculation from the end points"
+            )
+        self.imgpair.run_cineb_from_end_points()
+        return None

autodE/source/autode/bracket/dhs.py

@@ -0,0 +1,764 @@
+"""
+Dewar-Healy-Stewart Method for finding transition states
+
+Also implements DHS-GS, CI-DHS and CI-DHS-GS methods
+
+[1] M. J. S. Dewar, E. Healy, J. Chem. Soc. Farady Trans. 2, 1984, 80, 227-233
+"""
+import numpy as np
+from typing import Tuple, Union, Optional, Any, TYPE_CHECKING
+from enum import Enum
+
+from autode.values import Distance, Angle, GradientRMS, PotentialEnergy
+from autode.bracket.imagepair import EuclideanImagePair
+from autode.opt.coordinates import CartesianCoordinates
+from autode.opt.optimisers.utils import TruncatedTaylor
+from autode.opt.optimisers.hessian_update import BFGSSR1Update
+from autode.bracket.base import BaseBracketMethod
+from autode.opt.optimisers import RFOptimiser, ConvergenceParams
+from autode.exceptions import OptimiserStepError
+from autode.log import logger
+
+if TYPE_CHECKING:
+    from autode.species.species import Species
+    from autode.wrappers.methods import Method
+    from autode.opt.optimisers.base import ConvergenceTolStr
+
+
+class DistanceConstrainedOptimiser(RFOptimiser):
+    """
+    Constrained optimisation of a molecule, with the Euclidean
+    distance being kept constrained to a fixed value. The
+    constraint is enforced by a Lagrangian multiplier. An optional
+    linear search can be done to speed up convergence.
+
+    Same concept as that used in the corrector step of
+    Gonzalez-Schlegel second-order IRC integrator. However,
+    current implementation is modified to take steps within
+    a trust radius.
+
+    [1] C. Gonzalez, H. B. Schlegel, J. Chem. Phys., 90, 1989, 2154
+    """
+
+    def __init__(
+        self,
+        pivot_point: Optional[CartesianCoordinates],
+        init_trust: float = 0.1,
+        line_search: bool = True,
+        angle_thresh: Angle = Angle(5, units="deg"),
+        old_coords_read_hess: Optional[CartesianCoordinates] = None,
+        *args,
+        **kwargs,
+    ):
+        """
+        Initialise a distance constrained optimiser. The pivot point
+        is the point against which the distance is constrained. Optionally
+        a linear search can be used to attempt to speed up convergence, but
+        it may not improve performance in all cases.
+
+        Args:
+            init_trust: Initial trust radius in Angstrom
+            pivot_point: Coordinates of the pivot point
+            line_search: Whether to use linear search
+            angle_thresh: An angle threshold above which linear search
+                        will be rejected (in Degrees)
+            old_coords_read_hess: Old coordinate with hessian which will
+                        be used to obtain the initial hessian by a
+                        Hessian update scheme
+        """
+        kwargs.pop("init_alpha", None)
+        super().__init__(*args, init_alpha=init_trust, **kwargs)
+
+        if not isinstance(pivot_point, CartesianCoordinates):
+            raise NotImplementedError(
+                "Internal coordinates are not implemented in distance"
+                "constrained optimiser right now, please use Cartesian"
+            )
+        self._pivot = pivot_point
+        self._do_line_search = bool(line_search)
+        self._angle_thresh = Angle(angle_thresh, units="deg").to("radian")
+        self._target_dist: Optional[float] = None
+
+        self._hessian_update_types = [BFGSSR1Update]
+        self._old_coords = old_coords_read_hess
+
+    def _initialise_run(self) -> None:
+        """Initialise self._coords, gradient and hessian"""
+        assert self._species is not None, "Must have a species to init run"
+
+        self._coords = CartesianCoordinates(self._species.coordinates)
+        self._target_dist = np.linalg.norm(self.dist_vec)
+        self._update_gradient_and_energy()
+
+        # Update the Hessian from old coordinates, if exists
+        if self._old_coords is not None and self._old_coords.h is not None:
+            assert isinstance(self._old_coords, CartesianCoordinates)
+            self._coords.update_h_from_old_h(
+                self._old_coords, self._hessian_update_types
+            )
+        else:
+            # no hessian available, use low level method
+            self._coords.update_h_from_cart_h(self._low_level_cart_hessian)
+            self._coords.make_hessian_positive_definite()
+
+    @property
+    def converged(self) -> bool:
+        """Has the optimisation converged"""
+        assert self._coords is not None
+
+        # Check only the tangential component of gradient
+        g_tau = self.tangent_grad
+        rms_g_tau = np.sqrt(np.mean(np.square(g_tau)))
+        max_g_tau = np.max(np.abs(g_tau))
+
+        curr_params = self._history.conv_params()
+        curr_params.rms_g = GradientRMS(rms_g_tau, "Ha/ang")
+        curr_params.max_g = GradientRMS(max_g_tau, "Ha/ang")
+        return self.conv_tol.meets_criteria(curr_params)
+
+    @property
+    def tangent_grad(self) -> np.ndarray:
+        """
+        Obtain the component of atomic gradients tangent to the distance
+        vector between current coords and pivot point
+        """
+        assert self._coords is not None and self._coords.g is not None
+
+        grad = self._coords.g
+        # unit vector in the direction of distance vector
+        d_hat = self.dist_vec / np.linalg.norm(self.dist_vec)
+        tangent_grad = grad - (grad.dot(d_hat)) * d_hat
+        return tangent_grad
+
+    @property
+    def dist_vec(self) -> np.ndarray:
+        """
+        Get the distance vector (p) between the current coordinates
+        and the pivot point
+
+        Returns:
+            (np.ndarray):
+        """
+        return np.array(self._coords - self._pivot)
+
+    def _update_gradient_and_energy(self) -> None:
+        # Hessian update is done after en grad calculation, not in step
+        # so that it is present in the final converged coords, which
+        # can be used to start off the next batch of optimisation
+        super()._update_gradient_and_energy()
+        if self.iteration != 0:
+            assert self._coords is not None, "Must have set coordinates"
+            self._coords.update_h_from_old_h(
+                self._history.penultimate, self._hessian_update_types
+            )
+
+    def _step(self) -> None:
+        """
+        A step that maintains the distance of the coordinate from
+        the pivot point. A line search is done if it is not the first
+        iteration (and it has not been turned off), and then a
+        quasi-Newton step with a Lagrangian constraint for the distance
+        is taken (falls back to steepest descent with projected gradient
+        if this fails).
+        """
+        assert self._coords is not None, "Must have set coordinates"
+
+        # if energy is rising, interpolate halfway between last step
+        if self.iteration >= 1 and (
+            self.last_energy_change > PotentialEnergy(5, "kcalmol")
+        ):
+            logger.warning("Energy rising, going back half a step")
+            half_interp = (self._coords + self._history.penultimate) / 2
+            self._coords = half_interp
+            return None
+
+        if self.iteration >= 1 and self._do_line_search:
+            coords, grad = self._line_search_on_sphere()
+        else:
+            coords, grad = self._coords, self._coords.g
+
+        try:
+            step = self._get_lagrangian_step(coords, grad)
+            logger.info(
+                f"Taking a quasi-Newton step: {np.linalg.norm(step):.3f} Å"
+            )
+        except OptimiserStepError:
+            step = self._get_sd_step(coords, grad)
+            logger.warning(
+                f"Failed to take quasi-Newton step, taking steepest "
+                f"descent step instead: {np.linalg.norm(step):.3f} Å"
+            )
+
+        # the step is on the interpolated coordinates (if done)
+        actual_step = (coords + step) - self._coords
+        self._coords = self._coords + actual_step
+        return None
+
+    def _get_sd_step(self, coords, grad) -> np.ndarray:
+        """
+        Obtain a steepest descent step minimising the tangential
+        gradient. This step cannot perfectly maintain the same
+        distance from pivot point. The step size is at most half
+        of the trust radius.
+
+        Args:
+            coords: Previous coordinates
+            grad: Previous gradient
+
+        Returns:
+            (np.ndarray): Step in Cartesian coordinates
+        """
+        dist_vec = coords - self._pivot
+        dist_hat = dist_vec / np.linalg.norm(dist_vec)
+        perp_grad = grad - np.dot(grad, dist_hat) * dist_hat
+
+        sd_step = -perp_grad
+        if np.linalg.norm(sd_step) > self.alpha / 2:
+            sd_step *= (self.alpha / 2) / np.linalg.norm(sd_step)
+
+        return sd_step
+
+    def _get_lagrangian_step(self, coords, grad) -> np.ndarray:
+        """
+        Obtain the step that will minimise the gradient tangent to
+        the distance vector from pivot point, while maintaining the
+        same distance from pivot point. Takes the step within current
+        trust radius.
+
+        Args:
+            coords: Previous coordinate (either from quasi-NR step
+                    or from linear search)
+            grad: Previous gradient (either from quasi-NR or linear
+                  search)
+
+        Returns:
+            (np.ndarray): Step in cartesian (or mw-cartesian) coordinates
+
+        Raises:
+            OptimiserStepError: If scipy fails to calculate constrained step
+        """
+        from scipy.optimize import minimize
+
+        assert self._coords is not None, "Must have set coordinates"
+
+        # NOTE: Since the linear interpolation should produce a point
+        # in the vicinity of the last two points, it seems reasonable to
+        # also use the hessian from the last point in the case of linear
+        # interpolation being done
+        taylor_pes = TruncatedTaylor(coords, grad, self._coords.h)
+
+        def step_size_constr(x):
+            """step size must be <= trust radius"""
+            step_est = x - coords
+            # inequality constraint, should be > 0
+            return self.alpha - np.linalg.norm(step_est)
+
+        def lagrangian_constr(x):
+            """step must maintain same distance from pivot"""
+            p = x - self._pivot
+            return np.linalg.norm(p) - self._target_dist
+
+        constrs = (
+            {"type": "ineq", "fun": step_size_constr},
+            {"type": "eq", "fun": lagrangian_constr},
+        )
+        # NOTE: The Lagrangian constraint should be ideally calculated using
+        # a multiplier which can be found by a 1-D root search, however, it
+        # seems to produce really large steps. So instead the constraint
+        # and the trust radius are both enforced by doing a constrained
+        # optimisation on the truncated Taylor surface, which should give
+        # a quadratic step that follows the constraint and is within trust
+        # radius
+
+        res = minimize(
+            fun=taylor_pes.value,
+            x0=np.array(self._coords),
+            method="slsqp",
+            jac=taylor_pes.gradient,
+            options={"maxiter": 2000},
+            constraints=constrs,
+        )
+
+        if not res.success:
+            raise OptimiserStepError(
+                f"Unable to obtain distance-constrained step\nResult: {res}"
+            )
+
+        step = res.x - coords
+        return step
+
+    def _line_search_on_sphere(
+        self,
+    ) -> Tuple[Optional[CartesianCoordinates], Optional[np.ndarray]]:
+        """
+        Linear search on a hypersphere of radius equal to the target
+        distance.
+
+        Returns:
+            (Tuple): Interpolated coordinates and gradient as tuple
+        """
+        assert self._coords is not None, "Must have set coords to line search"
+
+        # Eq (12) to (15) in J. Chem. Phys., 90, 1989, 2154
+        # Notation follows the publication
+        last_coords = self._history[-2]
+        assert last_coords is not None
+
+        p_prime = self.dist_vec
+        g_prime_per = self._coords.g - p_prime * (
+            np.dot(self._coords.g, p_prime) / np.dot(p_prime, p_prime)
+        )
+        g_prime_per = np.linalg.norm(g_prime_per)
+        p_prime_prime = np.array(last_coords - self._pivot)
+        g_prime_prime_per = last_coords.g - p_prime_prime * (
+            np.dot(last_coords.g, p_prime_prime)
+            / np.dot(p_prime_prime, p_prime_prime)
+        )
+        g_prime_prime_per = np.linalg.norm(g_prime_prime_per)
+        cos_theta_prime = np.dot(p_prime, p_prime_prime) / (
+            np.linalg.norm(p_prime) * np.linalg.norm(p_prime_prime)
+        )
+        assert -1 < cos_theta_prime < 1
+        theta_prime = np.arccos(cos_theta_prime)
+        theta = (g_prime_prime_per * theta_prime) / (
+            g_prime_prime_per - g_prime_per
+        )
+
+        p_interp = p_prime_prime * (
+            np.cos(theta)
+            - np.sin(theta) * np.cos(theta_prime) / np.sin(theta_prime)
+        )
+        p_interp += p_prime * (np.sin(theta) / np.sin(theta_prime))
+
+        g_interp = last_coords.g * (1 - theta / theta_prime)
+        g_interp += self._coords.g * (theta / theta_prime)
+
+        x_interp = self._pivot + p_interp
+
+        step_size = np.linalg.norm(x_interp - self._coords)
+        angle_change = abs(theta_prime - theta)
+        if (
+            (
+                angle_change > self._angle_thresh
+                and abs(theta) > self._angle_thresh
+            )
+            or (
+                theta < 0  # extrapolating instead of interpolating
+                and theta_prime < self._angle_thresh
+            )
+            or (step_size > self.alpha)  # larger than trust radius
+        ):
+            logger.info("Linear interpolation step is unstable, skipping")
+            return self._coords, self._coords.g
+
+        logger.info(f"Linear interpolation - step size: {step_size:.3f} Å")
+
+        return x_interp, g_interp
+
+
+class ImageSide(Enum):
+    """Represents one side of the image-pair"""
+
+    left = 0
+    right = 1
+
+
+class DHSImagePair(EuclideanImagePair):
+    """
+    Image-pair used for Dewar-Healy-Stewart (DHS) method to
+    find transition states. In this method, only one side is
+    modified in a step, so functions to work with only one
+    side is present here
+    """
+
+    @property
+    def ts_guess(self) -> Optional["Species"]:
+        """
+        In DHS method, the images can only rise in energy; therefore,
+        the highest energy image is the ts_guess. If CI-NEB is run,
+        then that result is returned instead
+        """
+        tmp_spc = self._left_image.new_species(name="peak")
+
+        if self._cineb_coords is not None:
+            assert (
+                self._cineb_coords is not None
+                and self._cineb_coords.e
+                and self._cineb_coords.g is not None
+            )
+            tmp_spc.coordinates = self._cineb_coords
+            tmp_spc.energy = self._cineb_coords.e
+            tmp_spc.gradient = self._cineb_coords.g.reshape(-1, 3).copy()
+            return tmp_spc
+
+        # NOTE: Even though the final points are probably the highest
+        # this is not guaranteed, due to the probability of one end
+        # jumping over the barrier. So we iterate through all coords
+
+        energies = []
+        max_e = PotentialEnergy(-np.inf)
+        peak_coords: Optional[CartesianCoordinates] = None
+        for coord in self._total_history:
+            energies.append(coord.e)
+            if coord.e is None:
+                logger.error(
+                    "Energy values are missing in the trajectory of this"
+                    " image-pair. Unable to obtain transition state guess"
+                )
+                return None
+            if coord.e > max_e:
+                max_e = coord.e
+                peak_coords = coord
+
+        assert peak_coords is not None
+        tmp_spc.coordinates = peak_coords
+        tmp_spc.energy = peak_coords.e
+        if peak_coords.g is not None:
+            tmp_spc.gradient = peak_coords.g.reshape(-1, 3).copy()
+        return tmp_spc
+
+    def get_coord_by_side(self, side: ImageSide) -> CartesianCoordinates:
+        """For external usage, supplies the coordinate object by side"""
+        if side == ImageSide.left:
+            return self.left_coords
+        elif side == ImageSide.right:
+            return self.right_coords
+        else:
+            raise ValueError
+
+    def put_coord_by_side(
+        self, new_coord: CartesianCoordinates, side: ImageSide
+    ) -> None:
+        """
+        For external usage, puts the new coordinate in appropriate side
+
+        Args:
+            new_coord (CartesianCoordinates): New set of coordinates
+            side (ImageSide): left or right
+        """
+        if side == ImageSide.left:
+            self.left_coords = new_coord
+        elif side == ImageSide.right:
+            self.right_coords = new_coord
+        else:
+            raise ValueError
+        return None
+
+    def get_last_step_by_side(self, side: ImageSide) -> Optional[np.ndarray]:
+        """
+        Obtain the last step on the provided side (for the Growing
+        String like step)
+        """
+        if side == ImageSide.left:
+            hist = self._left_history
+        elif side == ImageSide.right:
+            hist = self._right_history
+        else:
+            raise ValueError
+
+        if len(hist) < 2:
+            return None
+        return hist.final - hist.penultimate
+
+    def get_dhs_step_by_side(
+        self, side: ImageSide, step_size: float
+    ) -> np.ndarray:
+        """
+        Obtain the DHS extrapolation step on the specified side,
+        with the specified step size
+
+        Args:
+            side (ImageSide): left or right
+            step_size (float): Step size in Angstrom
+
+        Returns:
+            (np.ndarray): The step
+        """
+        dhs_step = self.dist_vec * (step_size / self.dist)
+        if side == ImageSide.left:
+            dhs_step *= -1.0
+        elif side == ImageSide.right:
+            pass
+        else:
+            raise ValueError
+
+        return dhs_step
+
+
+class DHS(BaseBracketMethod):
+    """
+    Dewar-Healy-Stewart method for finding transition states,
+    from the reactant and product structures
+    """
+
+    def __init__(
+        self,
+        initial_species: "Species",
+        final_species: "Species",
+        large_step: Union[Distance, float] = Distance(0.2, "ang"),
+        small_step: Union[Distance, float] = Distance(0.05, "ang"),
+        switch_thresh: Union[Distance, float] = Distance(1.5, "ang"),
+        conv_tol: Union["ConvergenceParams", "ConvergenceTolStr"] = "loose",
+        **kwargs,
+    ):
+        """
+        Dewar-Healy-Stewart method to find transition states. The distance
+        tolerance convergence criteria should not be much lower than 0.5 Angstrom
+        as DHS is unstable when the distance is low, and there is a tendency for
+        one image to jumpy over the barrier.
+
+        Args:
+            initial_species: The "reactant" species
+
+            final_species: The "product" species
+
+            large_step: The size of the DHS step when distance between the
+                        images is larger than switch_thresh (Angstrom)
+
+            small_step: The size of the DHS step when distance between the
+                        images is smaller than swtich_thresh (Angstrom)
+
+            switch_thresh: When distance between the two images is less than
+                        this cutoff, smaller DHS extrapolation steps are taken
+
+            conv_tol: Convergence tolerance for the distance-constrained
+                      optimiser
+
+        Keyword Args:
+
+            maxiter: Maximum number of en/grad evaluations
+
+            dist_tol: The distance tolerance at which DHS will
+                      stop, values less than 0.5 Angstrom are not
+                      recommended.
+
+            cineb_at_conv: Whether to run CI-NEB calculation from the end
+                           points after the DHS is converged
+        """
+        super().__init__(initial_species, final_species, **kwargs)
+
+        # imgpair is only used for storing the points here
+        self.imgpair: DHSImagePair = DHSImagePair(
+            initial_species, final_species
+        )
+
+        # DHS needs to keep an extra reference method and n_cores
+        self._method: Optional[Method] = None
+        self._n_cores: Optional[int] = None
+
+        self._large_step = Distance(abs(large_step), "ang")
+        self._small_step = Distance(abs(small_step), "ang")
+        self._sw_thresh = Distance(abs(switch_thresh), "ang")
+        assert self._small_step < self._large_step
+        self._conv_tol = conv_tol
+
+        self._step_size: Optional[Distance] = None
+        if self._large_step > self.imgpair.dist:
+            logger.warning(
+                f"Step size ({self._large_step:.3f} Å) for {self._name}"
+                f" is larger than the starting Euclidean distance between"
+                f" images ({self.imgpair.dist:.3f} Å). This calculation"
+                f" will likely run into errors."
+            )
+
+        # NOTE: In DHS the micro-iterations are done separately in
+        # an optimiser, so keep track with local variable
+        self._current_microiters: int = 0
+
+    def _initialise_run(self) -> None:
+        """
+        Initialise energies/gradients for the first DHS macro-iteration
+        """
+        self.imgpair.update_both_img_engrad()
+        return None
+
+    def _step(self) -> None:
+        """
+        A DHS step consists of a macro-iteration step, where a step along
+        the linear path between two images is taken, and several micro-iteration
+        steps in the distance-constrained optimiser, to return to the MEP
+        """
+        assert self._method is not None, "Must have a set method"
+        assert self.imgpair.left_coords.e and self.imgpair.right_coords.e
+
+        if self.imgpair.dist > self._sw_thresh:
+            self._step_size = self._large_step
+        else:
+            self._step_size = self._small_step
+        opt_trust = min(self._step_size, Distance(0.1, "ang"))
+
+        if self.imgpair.left_coords.e < self.imgpair.right_coords.e:
+            side = ImageSide.left
+            pivot = self.imgpair.right_coords
+        else:
+            side = ImageSide.right
+            pivot = self.imgpair.left_coords
+
+        old_coords: Any = self.imgpair.get_coord_by_side(side)
+        old_coords = old_coords if old_coords.h is not None else None
+        # take a DHS step on the side with lower energy
+        new_coord = self._get_dhs_step(side)
+
+        # calculate the number of remaining maxiter to feed into optimiser
+        curr_maxiter = self._maxiter - self._current_microiters
+        if curr_maxiter <= 0:
+            return None
+
+        opt = DistanceConstrainedOptimiser(
+            maxiter=curr_maxiter,
+            conv_tol=self._conv_tol,
+            init_trust=opt_trust,
+            pivot_point=pivot,
+            old_coords_read_hess=old_coords,
+        )
+        tmp_spc = self._species.copy()
+        tmp_spc.coordinates = new_coord
+        opt.run(tmp_spc, self._method, self._n_cores)
+        self._micro_iter = self._micro_iter + opt.iteration
+
+        # not converged can only happen if exceeded maxiter of optimiser
+        if not opt.converged:
+            return None
+
+        rms_g_tau = np.sqrt(np.mean(np.square(opt.tangent_grad)))
+        logger.info(
+            "Successful optimization after DHS step, final RMS of "
+            f"tangential gradient = {rms_g_tau:.6f} "
+            f"Ha/angstrom"
+        )
+
+        # put results back into imagepair
+        self.imgpair.put_coord_by_side(opt.final_coordinates, side)  # type: ignore
+        opt.clean_up()
+        return None
+
+    def _calculate(
+        self, method: "Method", n_cores: Optional[int] = None
+    ) -> None:
+        """
+        Run the DHS calculation and CI-NEB if requested.
+
+        Args:
+            method (Method): Method used for calculating energy/gradients
+            n_cores (int): Number of cores to use for calculation
+        """
+        self._method = method
+        self._n_cores = n_cores
+        super()._calculate(method, n_cores)
+
+    @property
+    def _macro_iter(self):
+        """Total number of DHS steps taken so far"""
+        # ImagePair only stores the converged coordinates, which
+        # is equal to the number of macro-iterations (DHS steps)
+        return self.imgpair.total_iters
+
+    @property
+    def _micro_iter(self) -> int:
+        """Total number of optimiser steps in DHS"""
+        return self._current_microiters
+
+    @_micro_iter.setter
+    def _micro_iter(self, value: int):
+        """
+        For DHS the number of microiters has to be manually
+        set
+
+        Args:
+            value (int):
+        """
+        self._current_microiters = int(value)
+
+    def _get_dhs_step(self, side: ImageSide) -> CartesianCoordinates:
+        """
+        Take a DHS step, on the side requested, along the distance
+        vector between the two images, and return the new coordinates
+        after taking the step
+
+        Args:
+            side (ImageSide): left or right
+
+        Returns:
+            (CartesianCoordinates): New predicted coordinates for that side
+        """
+        assert self._step_size is not None
+        # take a DHS step of the size given
+        dhs_step = self.imgpair.get_dhs_step_by_side(side, self._step_size)
+
+        old_coord = self.imgpair.get_coord_by_side(side)
+        new_coord = old_coord + dhs_step
+
+        logger.info(
+            f"DHS step on {side} image: taking a step of"
+            f" size {np.linalg.norm(dhs_step):.4f} Å"
+        )
+        return new_coord
+
+
+class DHSGS(DHS):
+    """
+    Dewar-Healy-Stewart method, augmented with Growing String (GS)
+    method. The DHS step (stepping along the linear interpolated
+    path between the two images) is mixed with a GS step (linear
+    interpolation along last and current position of one image)
+    in a fixed ratio.
+
+    Proposed by J. Kilmes, D. R. Bowler, A. Michaelides,
+    J. Phys.: Condens. Matter, 2010, 22(7), 074203
+    """
+
+    def __init__(self, *args, gs_mix: float = 0.5, **kwargs):
+        """
+        Arguments and other keyword arguments follow DHS, please
+        see :py:meth:`DHS <autode.bracket.dhs.DHS.__init__>`
+
+        Keyword Args:
+            gs_mix (float): Represents the percentage of mixing of the
+                            Growing String step with the DHS step. 0.3
+                            means 0.3 * GS_step + (1-0.3) * DHS_step
+                            It is not recommended to set this higher
+                            than 0.5
+        """
+        super().__init__(*args, **kwargs)
+
+        self._gs_mix = float(gs_mix)
+        assert 0.0 < self._gs_mix < 1.0, "Mixing factor must be 0 < fac < 1"
+
+    def _get_dhs_step(self, side: ImageSide) -> CartesianCoordinates:
+        """
+        Take a mixed DHS and GS step (interpolates between the two
+        vectors) in the given ratio, and then return the new
+        coordinates after taking the step
+
+        Args:
+            side (ImageSide):
+
+        Returns:
+            (CartesianCoordinates): New predicted coordinates for that side
+        """
+        assert self.imgpair is not None, "Must have an image pair"
+        assert self._step_size is not None
+
+        dhs_step = self.imgpair.get_dhs_step_by_side(side, self._step_size)
+        gs_step = self.imgpair.get_last_step_by_side(side)
+
+        if gs_step is None:
+            gs_step = np.zeros_like(dhs_step)
+            # hack to ensure the first step is 100% DHS (as GS is not possible)
+            dhs_step = dhs_step / (1 - self._gs_mix)
+        else:
+            # rescale GS step as well so that one vector doesn't dominate
+            gs_step *= np.linalg.norm(dhs_step) / np.linalg.norm(gs_step)
+
+        old_coord = self.imgpair.get_coord_by_side(side)
+        new_coord = (
+            old_coord + (1 - self._gs_mix) * dhs_step + self._gs_mix * gs_step
+        )
+        # step size is variable due to adding GS component
+        step_size = np.linalg.norm(new_coord - old_coord)
+        logger.info(
+            f"DHS-GS step on {side} image: taking a step "
+            f"of size {step_size:.4f}"
+        )
+
+        return new_coord

autodE/source/autode/bracket/ieip.py

@@ -0,0 +1,601 @@
+"""
+Improved Elastic Image Pair method for finding transition states.
+
+References:
+
+[1] Y. Liu, H. Qi, M. Lei, J. Chem. Theory Comput., 2023, 19, 2410-2417
+"""
+from typing import Union, Optional, Tuple, List, TYPE_CHECKING
+import numpy as np
+from autode.methods import get_lmethod
+from autode.bracket.base import BaseBracketMethod
+from autode.bracket.dhs import TruncatedTaylor
+from autode.neb import NEB
+from autode.path.interpolation import CubicPathSpline
+from autode.bracket.imagepair import EuclideanImagePair
+from autode.opt.coordinates import CartesianCoordinates
+from autode.values import Distance, GradientRMS, PotentialEnergy
+from autode.utils import ProcessPool
+from autode.log import logger
+
+if TYPE_CHECKING:
+    from autode.species.species import Species
+    from autode.wrappers.methods import Method
+
+_interp_image_density = 1.0  # per Angstrom for initial interpolation
+
+
+def _calculate_low_sp_energy_for_species(
+    species: "Species", method: "Method", n_cores: int
+) -> "PotentialEnergy":
+    """
+    Convenience function to calculate the energy for a given species
+
+    Args:
+        species (Species): The species object
+        method (Method): The method (low_sp keywords will be used)
+        n_cores (int): The number of cores
+
+    Returns:
+        (PotentialEnergy): The single point energy of the species
+    """
+    from autode import Calculation
+
+    sp_calc = Calculation(
+        name=f"{species.name}_sp",
+        molecule=species,
+        method=method,
+        keywords=method.keywords.low_sp,  # NOTE: We use low_sp
+        n_cores=n_cores,
+    )
+
+    sp_calc.run()
+    sp_calc.clean_up(force=True, everything=True)
+
+    assert species.energy is not None
+    return species.energy
+
+
+def _parallel_calc_energies(
+    points: List["Species"], method: "Method", n_cores: int
+) -> List["PotentialEnergy"]:
+    """
+    Calculate the single point energies on a list of species with
+    parallel runs
+
+    Args:
+        points (list[Species]): A list of the species
+        method (Method): The method (low_sp keywords will be used)
+        n_cores (int): Total number of cores for all calculations
+
+    Returns:
+        (list[PotentialEnergy]): List of energies in order
+    """
+    n_cores_per_pp = max(n_cores // len(points), 1)
+    n_procs = min(n_cores, len(points))
+
+    with ProcessPool(max_workers=n_procs) as pool:
+        jobs = [
+            pool.submit(
+                _calculate_low_sp_energy_for_species,
+                species=point,
+                method=method,
+                n_cores=n_cores_per_pp,
+            )
+            for point in points
+        ]
+
+        energies = [job.result() for job in jobs]
+
+    return energies
+
+
+class ElasticImagePair(EuclideanImagePair):
+    """
+    This image-pair used for the Elastic Image Pair calculation. The
+    geometries after every macro-iteration are stored
+    """
+
+    @property
+    def last_left_step_size(self) -> float:
+        """The last step size on the left image"""
+        return np.linalg.norm(self.left_coords - self._left_history[-2])
+
+    @property
+    def last_right_step_size(self):
+        """The last step size on the right image"""
+        return np.linalg.norm(self.right_coords - self._right_history[-2])
+
+    @property
+    def ts_guess(self) -> Optional["Species"]:
+        """
+        Obtain the TS guess from the i-EIP image pair. The midpoint
+        between the two converged images is considered the TS guess
+
+        Returns:
+            (Species|None): The ts guess species, if images are available
+        """
+        # account for initial redistribution
+        if self.total_iters <= 2:
+            return None
+
+        tmp_spc = self._left_image.new_species(name="peak")
+        midpt_coords = np.array(self.left_coords + self.right_coords) / 2
+        tmp_spc.coordinates = midpt_coords
+        return tmp_spc
+
+    @property
+    def perp_rms_gs(self) -> Tuple[GradientRMS, GradientRMS]:
+        """
+        The RMS norms of perpendicular gradient component for left
+        and right image, in order. The parallel component against
+        the distance vector is projected out.
+
+        Returns:
+            (tuple[GradientRMS, GradientRMS]):
+        """
+        perp_gradients = []
+        d_hat = self.dist_vec / np.linalg.norm(self.dist_vec)
+        for coord in [self.left_coords, self.right_coords]:
+            parall_g = d_hat * np.dot(d_hat, coord.g)
+            perp_g = coord.g - parall_g
+            rms_perp_g = np.sqrt(np.mean(np.square(perp_g)))
+            perp_gradients.append(GradientRMS(rms_perp_g))
+
+        return perp_gradients[0], perp_gradients[1]
+
+    def redistribute_imagepair(
+        self,
+        ll_neb_interp: bool = True,
+        interp_fraction: float = 1 / 4,
+    ):
+        """
+        Redistribute the image pair by running a NEB calculation at lmethod or
+        use only IDPP interpolation, and then fitting a cubic spline on energy
+        calculated by the method (low_sp keywords). It generates the image pair
+        on both sides of the peak on the fitted spline, with a distance of
+        interp_fraction * total path distance on either side.
+
+        Args:
+            ll_neb_interp (bool): Whether to optimise the interpolated path with
+                                  NEB at lmethod for the interpolation.
+
+            interp_fraction (float): Fraction of total interpolated path distance
+                                     that will be used to generate the image pair
+                                     on either side of the interpolated TS
+        """
+        # Use at least 5 images for interpolation
+        n_images = int(_interp_image_density * self.dist - 1)
+        n_images = max(n_images, 5 + 2)
+
+        interp = NEB.from_end_points(
+            self._left_image.copy(), self._right_image.copy(), n_images
+        )
+        if ll_neb_interp:
+            interp.calculate(method=get_lmethod(), n_cores=self._n_cores)
+
+        # Only calc intermediate images, initial and final already have energies
+        path_points = interp.images[1:-1]
+        # Get energies
+        assert self.left_coords.e and self.right_coords.e
+        assert self._method is not None and self._n_cores is not None
+        path_energies = _parallel_calc_energies(
+            path_points, method=self._method, n_cores=self._n_cores
+        )
+        energies = [self.left_coords.e] + path_energies + [self.right_coords.e]
+        logger.info(
+            f"Fitting parametric spline on {len(interp.images)} points"
+        )
+
+        # NOTE: Here we are fitting a parametric spline, with the parameter
+        # being the path length along approx. rxn coordinate and target being all
+        # coordinates *and* energy at the points
+        path_spline = CubicPathSpline.from_species_list(interp.images)
+        path_spline.fit_energies(energies)
+        peak_x = path_spline.energy_peak()
+        if peak_x is None:
+            raise RuntimeError(
+                "The fitted spline does not have a peak! Unable to proceed"
+            )
+        # Check the peak is not at the beginning or end
+        assert 0.01 < peak_x < 0.99
+        # convert to integrated arc lengths
+        peak_pos = path_spline.path_integral(0, peak_x)
+        path_length = path_spline.path_integral(0, 1)
+
+        # Generate new coordinates a fraction (default 1/4) of total distance
+        # on each side of the peak (interpolated TS)
+        left_span = peak_pos - interp_fraction * path_length
+        if left_span <= 0.01:
+            l_point = 0.0
+        else:
+            l_point = path_spline.integrate_upto_length(
+                span=left_span,
+            )
+        r_point = path_spline.integrate_upto_length(
+            span=peak_pos + interp_fraction * path_length,
+        )
+        if r_point > 1:
+            r_point = 1
+        self.left_coords = CartesianCoordinates(path_spline.coords_at(l_point))
+        self.right_coords = CartesianCoordinates(
+            path_spline.coords_at(r_point)
+        )
+        return None
+
+
+class IEIPMicroIters:
+    """
+    Class to carry out the micro-iterations for the i-EIP
+    method
+    """
+
+    def __init__(
+        self,
+        left_coords: CartesianCoordinates,
+        right_coords: CartesianCoordinates,
+        micro_step_size: Union[Distance, float],
+        target_dist: Union[Distance, float],
+    ):
+        # generate the Taylor expansion surface from gradient and hessian
+        assert left_coords.g is not None and left_coords.h is not None
+        assert right_coords.g is not None and right_coords.h is not None
+        self._left_taylor_pes = TruncatedTaylor(
+            left_coords, left_coords.g, left_coords.h
+        )
+        self._right_taylor_pes = TruncatedTaylor(
+            right_coords, right_coords.g, right_coords.h
+        )
+        self._micro_step = float(Distance(micro_step_size, "ang"))
+        self._target_dist = float(Distance(target_dist, "ang"))
+        self.n_micro_iters = 0  # counter
+        self.left_coords = left_coords.copy()
+        self.right_coords = right_coords.copy()
+        # keep this in memory to calculate how much the coords have moved
+        self._start_left_coords = left_coords
+        self._start_right_coords = right_coords
+
+    def update_both_img_engrad(self) -> None:
+        """
+        Update the energy and gradient from the Taylor surface
+        """
+        self.left_coords.e = PotentialEnergy(
+            self._left_taylor_pes.value(self.left_coords)
+        )
+        self.left_coords.g = self._left_taylor_pes.gradient(self.left_coords)
+        self.right_coords.e = PotentialEnergy(
+            self._right_taylor_pes.value(self.right_coords)
+        )
+        self.right_coords.g = self._right_taylor_pes.gradient(
+            self.right_coords
+        )
+        return None
+
+    @property
+    def _n_hat(self):
+        dist_vec = np.array(self.left_coords - self.right_coords)
+        return dist_vec / np.linalg.norm(dist_vec)
+
+    def _get_perpendicular_micro_steps(self) -> List[np.ndarray]:
+        """
+        Obtain the perpendicular displacement for one i-EIP micro-iteration,
+        minimises the energy in the direction perpendicular to the distance
+        vector connecting the image pair
+
+        Returns:
+            (list[np.ndarray]): A list of steps for left and right
+                                image, in order
+        """
+        assert self.left_coords.g is not None
+        assert self.right_coords.g is not None
+        steps = []
+        for coord in [self.left_coords, self.right_coords]:
+            force = -coord.g  # type: ignore
+            force_parall = self._n_hat * np.dot(force, self._n_hat)
+            force_perp = force - force_parall
+            if np.linalg.norm(force_perp) > self._micro_step:
+                delta_x_perp = force_perp / np.linalg.norm(force_perp)
+                delta_x_perp *= self._micro_step
+            else:
+                delta_x_perp = force_perp
+            steps.append(delta_x_perp)
+
+        return steps
+
+    def _get_energy_micro_steps(self) -> List[np.ndarray]:
+        """
+        Obtain the energy based displacement term for one i-EIP
+        micro-iteration. This term minimises the energy difference
+        between the two images
+
+        Returns:
+            (list[np.ndarray]): A list of steps for the left and right
+                                image, in order
+        """
+        # NOTE: The sign is flipped here, because n_hat is
+        # defined in the opposite direction i.e. left - right
+        assert self.left_coords.e and self.right_coords.e
+        dist = np.linalg.norm(self.left_coords - self.right_coords)
+        f_de = (self.left_coords.e - self.right_coords.e) / float(dist)
+        f_de = self._n_hat * float(f_de)
+        if np.linalg.norm(f_de) > self._micro_step:
+            delta_x_e = f_de / np.linalg.norm(f_de)
+            delta_x_e *= self._micro_step
+        else:
+            delta_x_e = f_de
+        return [delta_x_e, delta_x_e]
+
+    def _get_distance_micro_steps(self):
+        """
+        Obtain the displacement term that controls the distance between
+        the two images. This term moves the images so that their distance
+        can be closer to the target distance in the current macro-iteration
+
+        Returns:
+            (list[np.ndarray]): A list of steps for the left and right
+                                images, in order
+        """
+        # NOTE: The factor k that appears in eqn.(1) of the i-EIP paper
+        # has been absorbed into the term in this function (i.e. the function
+        # returns the displacements with the proper sign)
+        dist_vec = np.array(self.left_coords - self.right_coords)
+        dist = np.linalg.norm(dist_vec)
+        f_l = -dist_vec * 2 * (dist - self._target_dist) / dist
+        if np.linalg.norm(f_l) > self._micro_step:
+            delta_x_l = f_l / np.linalg.norm(f_l)
+            delta_x_l *= self._micro_step
+        else:
+            delta_x_l = f_l
+        return [delta_x_l, -delta_x_l]
+
+    def take_micro_step(self) -> None:
+        """
+        Take a single i-EIP micro-iteration step (which is a sum of the
+        perpendicular, energy and distance terms)
+        """
+        perp_steps = self._get_perpendicular_micro_steps()
+        energy_steps = self._get_energy_micro_steps()
+        dist_steps = self._get_distance_micro_steps()
+
+        # sum the micro-iteration step components
+        left_step = perp_steps[0] + energy_steps[0] + dist_steps[0]
+        right_step = perp_steps[1] + energy_steps[1] + dist_steps[1]
+
+        # scale the steps within the microiter step size
+        if np.linalg.norm(left_step) > self._micro_step:
+            left_step *= self._micro_step / np.linalg.norm(left_step)
+        if np.linalg.norm(right_step) > self._micro_step:
+            right_step *= self._micro_step / np.linalg.norm(right_step)
+
+        self.left_coords = self.left_coords + left_step
+        self.right_coords = self.right_coords + right_step
+        self.n_micro_iters += 1
+        return None
+
+    @property
+    def max_displacement(self) -> float:
+        left_displ = np.linalg.norm(self.left_coords - self._start_left_coords)
+        right_displ = np.linalg.norm(
+            self.right_coords - self._start_right_coords
+        )
+        return max(left_displ, right_displ)
+
+
+class IEIP(BaseBracketMethod):
+    """
+    Improved Elastic Image Pair Method (i-EIP). It performs an initial
+    interpolation followed by spline fitting to redistribute the image
+    pair close to the interpolated TS. Then, micro-iterations are performed
+    to move the images closer while maintaining the distance
+    """
+
+    def __init__(
+        self,
+        initial_species: "Species",
+        final_species: "Species",
+        micro_step_size: Union[Distance, float] = Distance(1.5e-5, "ang"),
+        max_micro_per_macro: int = 2000,
+        max_macro_step: Union[Distance, float] = Distance(0.15, "ang"),
+        use_ll_neb_interp: bool = True,
+        interp_fraction: float = 1 / 4,
+        dist_tol: Union[Distance, float] = Distance(0.3, "ang"),
+        gtol: Union[GradientRMS, float] = GradientRMS(0.02, "Ha/ang"),
+        maxiter: int = 200,
+        **kwargs,
+    ):
+        """
+        Initialise an i-EIP calculation from the initial (reactant) and
+        final (product) species. Every macro-iteration consists of two
+        gradient evaluations on both images, therefore, the total number
+        of gradient evaluations would be 2 * maxiter. Increase the
+        interp_fraction argument to start the calculation closer to the
+        reactant and product, and move ahead less with the initial
+        interpolation.
+
+        Args:
+            initial_species: The "reactant" species
+
+            final_species: The "product" species
+
+            micro_step_size: The step size for every micro-iteration
+
+            max_micro_per_macro: The maximum number of micro-iterations
+                                per macro-iteration
+
+            max_macro_step: The maximum step size for one macro-iteration
+
+            use_ll_neb_interp: Whether to use lmethod NEB for the
+                            initial interpolation instead of only IDPP
+                            interpolation
+
+            interp_fraction: Generate image pair on both sides of the
+                            interpolated peak with this fraction of the
+                            total interpolated path length (default 1/4)
+
+            dist_tol: The Euclidean distance tolerance (between images)
+                      for convergence
+
+            gtol: The tolerance for perpendicular gradient RMS norm
+
+            maxiter: For i-EIP maxiter is the maximum number of macro-iterations
+
+        """
+        assert (
+            "cineb_at_conv" not in kwargs.keys()
+        ), "CI-NEB refinement is not available for i-EIP method!"
+
+        super().__init__(
+            initial_species,
+            final_species,
+            gtol=gtol,
+            dist_tol=dist_tol,
+            maxiter=maxiter,
+            **kwargs,
+        )
+
+        self.imgpair: ElasticImagePair = ElasticImagePair(
+            initial_species, final_species
+        )
+        self._micro_step_size = Distance(micro_step_size, "ang")
+        assert self._micro_step_size > 0
+        self._max_micro_per = abs(int(max_micro_per_macro))
+        self._max_macro_step = Distance(max_macro_step, "ang")
+        assert self._max_macro_step > 0
+        self._ll_neb_interp = bool(use_ll_neb_interp)
+        self._interp_frac = float(interp_fraction)
+        assert 0 < interp_fraction < 1
+
+        # NOTE: In EIP the microiters are done separately in a throwaway
+        # imagepair object, so a variable is required to keep track
+        self._current_microiters: int = 0
+
+        self._target_dist: Optional[float] = None
+        self._target_rms_g: Optional[float] = None
+
+    @property
+    def _micro_iter(self) -> int:
+        """
+        Total number of micro-iterations. For i-EIP each micro-iteration
+        is on both of the images simultaneously
+        """
+        return self._current_microiters
+
+    @_micro_iter.setter
+    def _micro_iter(self, value):
+        """Set the total number of micro-iterations"""
+        self._current_microiters = int(value)
+
+    @property
+    def _macro_iter(self) -> int:
+        """Total number of macro-iterations taken"""
+        # minus 1 due to first redistribution
+        return int(self.imgpair.total_iters / 2) - 1
+
+    @property
+    def converged(self) -> bool:
+        """Is the i-EIP method converged"""
+        # NOTE: Original publication recommends also checking overlap
+        # of image-pair mode with Hessian eigenvalue for convergence, but
+        # Hessian is expensive, so we use simpler check
+        return self.imgpair.dist < self._dist_tol and all(
+            rms_grad <= self._gtol for rms_grad in self.imgpair.perp_rms_gs
+        )
+
+    @property
+    def _exceeded_maximum_iteration(self) -> bool:
+        """Whether it has exceeded the number of maximum iterations"""
+        if self._macro_iter >= self._maxiter:
+            logger.error(
+                f"Reached the maximum number of macro-iterations "
+                f"*{self._maxiter}*"
+            )
+            return True
+        else:
+            return False
+
+    def _initialise_run(self) -> None:
+        """
+        Initialise the i-EIP calculation by redistributing the
+        image pair and then estimating a low level hessian
+        """
+        self.imgpair.update_both_img_engrad()
+        self.imgpair.redistribute_imagepair(
+            self._ll_neb_interp, self._interp_frac
+        )
+        self.imgpair.update_both_img_engrad()
+        self.imgpair.update_both_img_hessian_by_calc()
+        self._target_dist = self.imgpair.dist
+        self._target_rms_g = (
+            min(max(self.imgpair.dist / self._dist_tol, 1), 2) * self._gtol
+        )
+        return None
+
+    def _step(self) -> None:
+        """
+        Take one EIP macro-iteration step and store the new coordinates
+        in history and update the energies and gradients
+        """
+        self._update_target_distance_and_force()
+
+        # Turn off logging for micro-iterations
+        logger.disabled = True
+        assert self._target_dist is not None
+        micro_imgpair = IEIPMicroIters(
+            left_coords=self.imgpair.left_coords,
+            right_coords=self.imgpair.right_coords,
+            micro_step_size=self._micro_step_size,
+            target_dist=self._target_dist,
+        )
+
+        while not (
+            micro_imgpair.n_micro_iters >= self._max_micro_per
+            or micro_imgpair.max_displacement > self._max_macro_step
+        ):
+            micro_imgpair.update_both_img_engrad()
+            micro_imgpair.take_micro_step()
+            self._micro_iter += 1
+        logger.disabled = False
+        self.imgpair.left_coords = micro_imgpair.left_coords
+        self.imgpair.right_coords = micro_imgpair.right_coords
+        self.imgpair.update_both_img_engrad()
+        self.imgpair.update_both_img_hessian_by_formula()
+
+        logger.info(
+            f"Completed one i-EIP macro-iteration with "
+            f"{micro_imgpair.n_micro_iters} micro-iterations; maximum "
+            f"image displacement = {micro_imgpair.max_displacement:.3f}.\n"
+            f"Left image step: {self.imgpair.last_left_step_size:.3f}, "
+            f"Right image step: {self.imgpair.last_right_step_size:.3f}"
+        )
+        return None
+
+    def _update_target_distance_and_force(self):
+        """
+        Update the target distance tolerance and the RMS gradients
+        for the current macro-iteration
+        """
+        # only update if target RMS force and distance has been reached
+        if not all(
+            rms_grad <= self._target_rms_g
+            for rms_grad in self.imgpair.perp_rms_gs
+        ):
+            return None
+
+        # NOTE: target distance near the end of optimisation
+        # must be slighly lower than the set dist_tol, otherwise
+        # it will never converge (as it won't go below dist_tol)
+        self._target_dist = max(
+            0.9 * self.imgpair.dist,
+            self._dist_tol - 0.015,
+        )
+
+        self._target_rms_g = (
+            min(max(self.imgpair.dist / self._dist_tol, 1), 2) * self._gtol
+        )
+
+        logger.info(
+            f"Updating target distance to {self._target_dist:.3f} Å"
+            f" and updating target RMS gradient to "
+            f"{self._target_rms_g:.3f} Ha/Å"
+        )
+        return None

autodE/source/autode/bracket/imagepair.py

@@ -0,0 +1,628 @@
+"""
+Base classes for implementing all bracketing methods
+that require a pair of images
+"""
+import itertools
+import numpy as np
+from abc import ABC, abstractmethod
+from typing import Optional, Tuple, TYPE_CHECKING, Union, Iterator
+from enum import Enum
+
+from autode.values import Distance, PotentialEnergy, Gradient
+from autode.geom import get_rot_mat_kabsch
+from autode.methods import get_lmethod
+from autode.neb import CINEB
+from autode.opt.coordinates import CartesianCoordinates
+from autode.opt.optimisers.hessian_update import BofillUpdate
+from autode.opt.optimisers.utils import Polynomial2PointFit
+from autode.opt.optimisers.base import OptimiserHistory, print_geometries_from
+from autode.plotting import plot_bracket_method_energy_profile
+from autode.utils import work_in_tmp_dir, ProcessPool
+from autode.log import logger
+
+if TYPE_CHECKING:
+    from autode.species import Species
+    from autode.wrappers.methods import Method
+    from autode.hessians import Hessian
+
+
+def _calculate_engrad_for_species(
+    species: "Species",
+    method: "Method",
+    n_cores: int,
+) -> Tuple[PotentialEnergy, Gradient]:
+    """
+    Convenience function for calculating the energy/gradient
+    for a molecule; removes all input and output files after
+    the calculation is finished
+
+    Returns:
+        (tuple[PotentialEnergy, Gradient]): Energy and gradient as tuple
+    """
+    from autode.calculations import Calculation
+
+    engrad_calc = Calculation(
+        name=f"{species.name}_engrad",
+        molecule=species,
+        method=method,
+        keywords=method.keywords.grad,
+        n_cores=n_cores,
+    )
+    engrad_calc.run()
+    engrad_calc.clean_up(force=True, everything=True)
+    assert species.energy and species.gradient is not None, "Calc must be ok"
+
+    return species.energy, species.gradient
+
+
+@work_in_tmp_dir()
+def _calculate_hessian_for_species(
+    species: "Species",
+    method: "Method",
+    n_cores: int,
+) -> "Hessian":
+    """
+    Convenience function for calculating the Hessian for a
+    molecule; removes all input and output files after
+    the calculation is finished
+
+    Returns:
+        (Hessian): Hessian matrix
+    """
+    from autode.calculations import Calculation
+
+    species = species.new_species()
+
+    hess_calc = Calculation(
+        name=f"{species.name}_hess",
+        molecule=species,
+        method=method,
+        keywords=method.keywords.hess,
+        n_cores=n_cores,
+    )
+    hess_calc.run()
+    hess_calc.clean_up(force=True, everything=True)
+    assert species.hessian is not None, "Calc must be ok"
+
+    return species.hessian
+
+
+class BaseImagePair(ABC):
+    """
+    Base class for a pair of images (e.g., reactant and product) of
+    the same species. The images are called 'left' and 'right' to
+    distinguish them, but there is no requirement for one to be
+    reactant or product. Calculations can be performed on both sides
+    parallely
+    """
+
+    def __init__(
+        self,
+        left_image: "Species",
+        right_image: "Species",
+    ):
+        """
+        Initialize the image pair, does not set methods/n_cores
+
+        Args:
+            left_image: One molecule of the pair
+            right_image: Another molecule of the pair
+        """
+        from autode.species.species import Species
+
+        assert isinstance(left_image, Species)
+        assert isinstance(right_image, Species)
+        self._left_image = left_image.new_species(name="left_image")
+        self._right_image = right_image.new_species(name="right_image")
+        self._sanity_check()
+        self._align_species()
+
+        # for calculation
+        self._method = None
+        self._hess_method = None
+        self._n_cores = None
+        self._hessian_update_types = [BofillUpdate]
+
+        self._left_history = OptimiserHistory()
+        self._right_history = OptimiserHistory()
+        # push the first coordinates into history
+        self.left_coords = CartesianCoordinates(self._left_image.coordinates)
+        self.right_coords = CartesianCoordinates(self._right_image.coordinates)
+
+    def _sanity_check(self) -> None:
+        """
+        Check if the two supplied images have the same solvent,
+        charge, multiplicity and the same atoms in the same order
+        """
+
+        if self._left_image.n_atoms != self._right_image.n_atoms:
+            raise ValueError(
+                "The initial_species and final_species must "
+                "have the same number of atoms!"
+            )
+
+        if (
+            self._left_image.charge != self._right_image.charge
+            or self._left_image.mult != self._right_image.mult
+            or self._left_image.solvent != self._right_image.solvent
+        ):
+            raise ValueError(
+                "Charge/multiplicity/solvent of initial_species "
+                "and final_species supplied are not the same"
+            )
+
+        for idx in range(len(self._left_image.atoms)):
+            if (
+                self._left_image.atoms[idx].label
+                != self._right_image.atoms[idx].label
+            ):
+                raise ValueError(
+                    "The order of atoms in initial_species "
+                    "and final_species must be the same. The "
+                    f"atom at position {idx} is different in"
+                    "the two species"
+                )
+
+        return None
+
+    def _align_species(self) -> None:
+        """
+        Translates both molecules to origin and then performs
+        a Kabsch rotation to orient the molecules as close as
+        possible against each other
+        """
+        # first translate the molecules to the origin
+        logger.info(
+            "Translating initial_species (reactant) "
+            "and final_species (product) to origin"
+        )
+        p_mat = self._left_image.coordinates.copy()
+        p_mat -= np.average(p_mat, axis=0)
+        self._left_image.coordinates = p_mat
+
+        q_mat = self._right_image.coordinates.copy()
+        q_mat -= np.average(q_mat, axis=0)
+        self._right_image.coordinates = q_mat
+
+        logger.info(
+            "Rotating initial_species (reactant) "
+            "to align with final_species (product) "
+            "as much as possible"
+        )
+        rot_mat = get_rot_mat_kabsch(p_mat, q_mat)
+        rotated_p_mat = np.dot(rot_mat, p_mat.T).T
+        self._left_image.coordinates = rotated_p_mat
+
+    def initialise_trj(
+        self,
+        left_history_name: str = "left_history_save.zip",
+        right_history_name: str = "right_history_save.zip",
+    ) -> None:
+        """
+        Initialise the trajectory save files (history of coordinates on
+        left and right images)
+
+        Args:
+            left_history_name: Name of savefile for left history
+            right_history_name: Name of savefile for right history
+        """
+        self._left_history.open(left_history_name)
+        self._right_history.open(right_history_name)
+
+    def close_trj(self):
+        """
+        Put all coordinates in memory onto disk in the trajectory
+        save files, and close the trajectories
+        """
+        self._left_history.close()
+        self._right_history.close()
+
+    def set_method_and_n_cores(
+        self,
+        method: "Method",
+        n_cores: int,
+        hess_method: Optional["Method"] = None,
+    ) -> None:
+        """
+        Sets the methods for en/grad calculation, and the total
+        number of cores used for any calculation in this image pair.
+        Optionally, also set the method for hessian calculation; if
+        not set, the available lmethod will be used.
+
+        Args:
+            method (Method): Method used for calculating energy/gradient
+            n_cores (int): Number of cores available
+            hess_method (Method|None): Method used for calculating
+                                       Hessian (optional)
+        """
+        from autode.wrappers.methods import Method
+
+        if not isinstance(method, Method):
+            raise TypeError(
+                f"The method needs to be of type autode."
+                f"wrappers.method.Method, But "
+                f"{type(method)} was supplied."
+            )
+        self._method = method
+
+        if hess_method is None:
+            hess_method = get_lmethod()
+
+        if not isinstance(hess_method, Method):
+            raise TypeError(
+                f"The hessian method needs to be of type autode."
+                f"wrappers.method.Method, But {type(hess_method)}"
+                f"was supplied"
+            )
+        self._hess_method = hess_method
+
+        self._n_cores = int(n_cores)
+        return None
+
+    @property
+    def n_atoms(self) -> int:
+        """Number of atoms"""
+        return self._left_image.n_atoms
+
+    @property
+    def total_iters(self) -> int:
+        """Total number of iterations done on this image pair"""
+        return len(self._left_history) + len(self._right_history) - 2
+
+    @property
+    def left_coords(self) -> CartesianCoordinates:
+        """The coordinates of the left image"""
+        assert isinstance(self._left_history[-1], CartesianCoordinates)
+        return self._left_history[-1]
+
+    @left_coords.setter
+    def left_coords(self, value: CartesianCoordinates):
+        """
+        Sets the coordinates of the left image, also updates
+        the coordinates of the species
+
+        Args:
+            value (CartesianCoordinates|None): new set of coordinates
+
+        Raises:
+            (TypeError): If input is not of type CartesianCoordinates
+            (ValueError): If input does not have correct shape
+        """
+        if value.shape[0] != 3 * self.n_atoms:
+            raise ValueError(f"Must have {self.n_atoms * 3} entries")
+
+        if isinstance(value, CartesianCoordinates):
+            self._left_history.add(value.copy())
+        else:
+            raise TypeError
+
+        self._left_image.coordinates = self.left_coords
+
+    @property
+    def right_coords(self) -> CartesianCoordinates:
+        """The coordinates of the right image"""
+        assert isinstance(self._right_history[-1], CartesianCoordinates)
+        return self._right_history[-1]
+
+    @right_coords.setter
+    def right_coords(self, value: CartesianCoordinates):
+        """
+        Sets the coordinates of the right image, also updates
+        the coordinates of the species
+
+        Args:
+            value (CartesianCoordinates|None): new set of coordinates
+
+        Raises:
+            (TypeError): If input is not of type CartesianCoordinates
+            (ValueError): If input does not have correct shape
+        """
+        if value.shape[0] != 3 * self.n_atoms:
+            raise ValueError(f"Must have {self.n_atoms * 3} entries")
+
+        if isinstance(value, CartesianCoordinates):
+            self._right_history.add(value.copy())
+        else:
+            raise TypeError
+
+        self._right_image.coordinates = self.right_coords
+
+    @property
+    @abstractmethod
+    def ts_guess(self) -> Optional["Species"]:
+        """TS guess species for this image-pair"""
+
+    @property
+    @abstractmethod
+    def dist_vec(self) -> np.ndarray:
+        """Distance vector defined from left to right image"""
+
+    @property
+    @abstractmethod
+    def dist(self) -> Distance:
+        """Distance defined between two images in the image-pair"""
+
+    @property
+    @abstractmethod
+    def has_jumped_over_barrier(self) -> bool:
+        """Whether one image has jumped over the barrier on the other side"""
+
+    def update_both_img_engrad(self):
+        """
+        Update the energy/gradient for both images, with parallel processing
+        """
+        assert self._method is not None
+        assert self._n_cores is not None
+        n_cores_per_pp = self._n_cores // 2 if self._n_cores > 1 else 1
+        n_procs = 1 if self._n_cores < 2 else 2
+        with ProcessPool(max_workers=n_procs) as pool:
+            jobs = [
+                pool.submit(
+                    _calculate_engrad_for_species,
+                    species=img,
+                    method=self._method,
+                    n_cores=n_cores_per_pp,
+                )
+                for img in [self._left_image, self._right_image]
+            ]
+            left_engrad, right_engrad = [job.result() for job in jobs]
+
+        self.left_coords.e = left_engrad[0]
+        self.left_coords.update_g_from_cart_g(left_engrad[1])
+        self.right_coords.e = right_engrad[0]
+        self.right_coords.update_g_from_cart_g(right_engrad[1])
+        return None
+
+    def update_both_img_hessian_by_calc(self):
+        """
+        Update the molecular hessian of both images by calculation
+        """
+        # TODO: refactor into ll_hessian code
+        assert self._hess_method is not None
+        assert self._n_cores is not None
+        n_cores_per_pp = self._n_cores // 2 if self._n_cores > 1 else 1
+        n_procs = 1 if self._n_cores < 2 else 2
+        with ProcessPool(max_workers=n_procs) as pool:
+            jobs = [
+                pool.submit(
+                    _calculate_hessian_for_species,
+                    species=img,
+                    method=self._hess_method,
+                    n_cores=n_cores_per_pp,
+                )
+                for img in [self._left_image, self._right_image]
+            ]
+            left_hess, right_hess = [job.result() for job in jobs]
+
+        self.left_coords.update_h_from_cart_h(left_hess)
+        self.right_coords.update_h_from_cart_h(right_hess)
+        return None
+
+    def update_both_img_hessian_by_formula(self):
+        """
+        Update the molecular hessian for both images by update formula
+        """
+        for history in [self._left_history, self._right_history]:
+            history.final.update_h_from_old_h(
+                history.penultimate, self._hessian_update_types
+            )
+
+        return None
+
+
+class EuclideanImagePair(BaseImagePair, ABC):
+    """
+    Image-pair that defines the distance between the images as
+    the Euclidean distance. It can also run CI-NEB calculation
+    from the final two points added to the image-pair, and
+    plot the energies of the total path
+    """
+
+    def __init__(
+        self,
+        left_image: "Species",
+        right_image: "Species",
+    ):
+        super().__init__(left_image=left_image, right_image=right_image)
+
+        # for storing results from CINEB
+        self._cineb_coords: Optional[CartesianCoordinates] = None
+
+    @property
+    def dist_vec(self) -> np.ndarray:
+        """
+        Distance vector in cartesian coordinates, it is defined here to
+        go from right to left image (i.e. right -> left)
+        """
+        return np.array(
+            self.left_coords.to("cart") - self.right_coords.to("cart")
+        )
+
+    @property
+    def dist(self) -> Distance:
+        """
+        Euclidean distance between the images in image-pair
+
+        Returns:
+            (Distance): Distance in Angstrom
+        """
+        return Distance(np.linalg.norm(self.dist_vec), units="ang")
+
+    @property
+    def has_jumped_over_barrier(self) -> bool:
+        """
+        A quick test of whether the images are still separated by a barrier,
+        implemented via fitting a cubic polynomial along the linear path
+        connecting the two images and checking for a peak. This is only an
+        approximation.
+        """
+        assert self.left_coords is not None and self.right_coords is not None
+        assert self.left_coords.e and self.right_coords.e
+        assert (
+            self.left_coords.g is not None and self.right_coords.g is not None
+        )
+        cubic_poly = Polynomial2PointFit.cubic_fit(
+            self.left_coords, self.right_coords
+        )
+
+        # NOTE: Interpolation seems reasonable upto ~1.2 Angstrom. If distance
+        # is larger, detecting peak is impossible without calculating energies
+        # so we assume there is a barrier between the images
+        if self.dist > Distance(1.2, "ang"):
+            return False
+        else:
+            return cubic_poly.get_extremum(0.0, 1.0, get_max=True) is None
+
+    def run_cineb_from_end_points(self) -> None:
+        """
+        Runs a CI-NEB calculation from the end-points of the image-pair
+        and then stores the coordinates of the peak point obtained
+        from the CI-NEB run
+
+        Returns:
+            (CartesianCoordinates): Coordinates of the peak species obtained
+                                    from the CI-NEB run
+        """
+        assert self._method is not None, "Methods must be set"
+        assert self._n_cores is not None, "Number of cores must be set"
+
+        cineb = CINEB.from_end_points(
+            self._left_image, self._right_image, num=3
+        )
+        cineb.calculate(method=self._method, n_cores=self._n_cores)
+
+        if not cineb.images.contains_peak:
+            logger.error("CI-NEB failed to find the peak")
+            return None
+
+        peak = cineb.images[cineb.images.peak_idx]  # type: ignore
+        ci_coords = CartesianCoordinates(peak.coordinates)
+        ci_coords.e = peak.energy
+        ci_coords.update_g_from_cart_g(peak.gradient)
+
+        self._cineb_coords = ci_coords
+        return None
+
+    @property
+    def _total_history(self) -> Iterator[CartesianCoordinates]:
+        """
+        The total history of the image-pair, including any CI run
+        from the endpoints
+        """
+        cineb_coords = []
+        if self._cineb_coords is not None:
+            cineb_coords.append(self._cineb_coords)
+        return itertools.chain(
+            self._left_history, cineb_coords, reversed(self._right_history)
+        )
+
+    def print_geometries(
+        self,
+        init_trj_filename: str,
+        final_trj_filename: str,
+        total_trj_filename: str,
+    ) -> None:
+        """
+        Write trajectories as *.xyz files, one for the initial species,
+        one for final species, and one for the whole trajectory, including
+        any CI-NEB run from the final end points
+        """
+        if self.total_iters < 2:
+            logger.warning("Cannot write trajectory, not enough points")
+            return None
+
+        print_geometries_from(
+            self._left_history,
+            species=self._left_image,
+            filename=init_trj_filename,
+        )
+        print_geometries_from(
+            self._right_history,
+            species=self._right_image,
+            filename=final_trj_filename,
+        )
+        print_geometries_from(
+            self._total_history,
+            species=self._left_image,
+            filename=total_trj_filename,
+        )
+
+        return None
+
+    def plot_energies(
+        self,
+        filename: str,
+        distance_metric: str,
+    ) -> None:
+        """
+        Plots the energies of the image-pair, including any CI-NEB
+        calculation done at the end. The distance metric argument
+        determines how the x-axis values are plotted and their
+        meaning (Described in more detail in BaseBracketMethod)
+
+        Args:
+            filename (str): name of the plot file to save
+            distance_metric (str): "relative" or "from_start" or "index"
+
+        See Also:
+            :py:meth:`BaseBracketMethod <autode.bracket.base.BaseBracketMethod.plot_energies>`
+        """
+
+        class Metrics(Enum):
+            relative = 1
+            from_start = 2
+            index = 3
+
+        metric = Metrics[distance_metric]
+
+        if self.total_iters < 2:
+            logger.warning("Cannot plot energies, not enough points")
+            return None
+
+        all_energies = [coord.e for coord in self._total_history]
+        if any(en is None for en in all_energies):
+            logger.error(
+                "One or more coordinates do not have associated"
+                " energies, unable to produce energy plot!"
+            )
+            return None
+
+        num_left_points = len(self._left_history)
+        num_right_points = len(self._right_history)
+        first_point = self._left_history[0]
+        points: list = []  # list of tuples
+
+        lowest_en = min(all_energies)  # type: ignore
+
+        last_coord = None
+        for idx, coord in enumerate(self._total_history):
+            en = coord.e - lowest_en  # type: ignore
+            if metric == Metrics.relative:
+                if idx == 0:
+                    x = 0
+                else:
+                    x = np.linalg.norm(coord - last_coord)
+                    x += points[idx - 1][0]  # add previous distance
+            elif metric == Metrics.from_start:
+                x = np.linalg.norm(coord - first_point)
+            else:  # metric == Metrics.index:
+                x = idx
+            points.append((x, en))
+            last_coord = coord
+
+        left_points = points[:num_left_points]
+        if self._cineb_coords is not None:
+            cineb_point = points[num_left_points]
+        else:
+            cineb_point = None
+        right_points = points[-num_right_points:]
+        if distance_metric == "relative":
+            x_axis_title = "Change in Euclidean Distance (Å)"
+        elif distance_metric == "from_start":
+            x_axis_title = "Euclidean Distance from Reactant Structure (Å)"
+        else:
+            x_axis_title = "Point in Reaction Path"
+
+        plot_bracket_method_energy_profile(
+            filename, left_points, cineb_point, right_points, x_axis_title
+        )

autodE/source/autode/calculations/__init__.py

@@ -0,0 +1,5 @@
+from autode.calculations.calculation import Calculation
+from autode.calculations.input import CalculationInput
+from autode.calculations.output import CalculationOutput
+
+__all__ = ["Calculation", "CalculationInput", "CalculationOutput"]

autodE/source/autode/calculations/calculation.py

@@ -0,0 +1,328 @@
+import autode.wrappers.keywords as kws
+import autode.exceptions as ex
+
+from copy import deepcopy
+from typing import Optional, List, TYPE_CHECKING
+
+from autode.point_charges import PointCharge
+from autode.log import logger
+from autode.calculations.types import CalculationType
+from autode.calculations.executors import (
+    CalculationExecutor,
+    CalculationExecutorO,
+    CalculationExecutorG,
+    CalculationExecutorH,
+)
+
+if TYPE_CHECKING:
+    from autode.species.species import Species
+    from autode.wrappers.methods import Method
+    from autode.wrappers.keywords import Keywords
+    from autode.calculations.input import CalculationInput
+    from autode.calculations.output import CalculationOutput
+    from autode.calculations.executors import CalculationExecutor
+    from autode.opt.optimisers.base import BaseOptimiser
+
+output_exts = (
+    ".out",
+    ".hess",
+    ".xyz",
+    ".inp",
+    ".com",
+    ".log",
+    ".nw",
+    ".pc",
+    ".grad",
+)
+
+
+class Calculation:
+    def __init__(
+        self,
+        name: str,
+        molecule: "Species",
+        method: "Method",
+        keywords: "Keywords",
+        n_cores: int = 1,
+        point_charges: Optional[List[PointCharge]] = None,
+    ):
+        """
+        Calculation e.g. single point energy evaluation on a molecule. This
+        will update the molecule inplace. For example, an optimisation will
+        alter molecule.atoms.
+
+        -----------------------------------------------------------------------
+        Arguments:
+            name: Name of the calculation. Will be modified with a method
+                  suffix
+
+            molecule: Molecule to be calculated. This may have a set of
+                      associated cartesian or distance constraints
+
+            method: Wrapped electronic structure method, or other e.g.
+                    forcefield capable of calculating energies and gradients
+
+            keywords: Keywords defining the type of calculation and e.g. what
+                      basis set and functional to use.
+
+            n_cores: Number of cores available (default: {1})
+
+            point_charges: List of  float of point charges
+        """
+
+        self.name = name
+        self.n_cores = int(n_cores)
+        self.point_charges = point_charges
+        self._executor = self._executor_for(molecule, method, keywords)
+
+        self._check()
+
+    def _executor_for(
+        self,
+        molecule: "Species",
+        method: "Method",
+        keywords: "Keywords",
+    ) -> "CalculationExecutor":
+        """
+        Return a calculation executor depending on the calculation modes
+        implemented in the wrapped method. For instance if the method does not
+        implement any optimisation then use an executor that uses the in built
+        autodE optimisers (in autode/opt/). Equally if the method does not
+        implement way of calculating Hessians then use a numerical evaluation
+        of the Hessian
+        """
+        _type = CalculationExecutor  # base type, implements all calc types
+
+        if _are_opt(keywords) and not method.implements(CalculationType.opt):
+            _type = CalculationExecutorO
+
+        if _are_grad(keywords) and not method.implements(
+            CalculationType.gradient
+        ):
+            _type = CalculationExecutorG
+
+        if _are_hess(keywords) and not method.implements(
+            CalculationType.hessian
+        ):
+            _type = CalculationExecutorH
+
+        return _type(
+            self.name,
+            molecule,
+            method,
+            keywords,
+            self.n_cores,
+            self.point_charges,
+        )
+
+    def run(self) -> None:
+        """Run the calculation using the EST method"""
+        logger.info(f"Running calculation: {self.name}")
+
+        self._executor.run()
+        self._check_properties_exist()
+        self._add_to_comp_methods()
+
+        return None
+
+    def clean_up(self, force: bool = False, everything: bool = False) -> None:
+        """
+        Clean up input and output files, if Config.keep_input_files is False
+        (and not force=True)
+
+        -----------------------------------------------------------------------
+        Keyword Arguments:
+
+            force (bool): If True then override Config.keep_input_files
+
+            everything (bool): Remove both input and output files
+        """
+        return self._executor.clean_up(force, everything)
+
+    def generate_input(self) -> None:
+        """Generate the input required for this calculation"""
+
+        if not self.method.uses_external_io:
+            logger.warning(
+                "Calculation does not create an input file. No "
+                "input has been generated"
+            )
+        else:
+            self._executor.generate_input()
+
+    @property
+    def terminated_normally(self) -> bool:
+        """
+        Determine if the calculation terminated without error
+
+        -----------------------------------------------------------------------
+        Returns:
+            (bool): Normal termination of the calculation?
+        """
+        return self._executor.terminated_normally
+
+    @property
+    def input(self) -> "CalculationInput":
+        """The input used to run this calculation"""
+        return self._executor.input
+
+    @property
+    def output(self) -> "CalculationOutput":
+        """The output generated by this calculation"""
+        return self._executor.output
+
+    def set_output_filename(self, filename: str) -> None:
+        """
+        Set the output filename. If it exists then the properties of
+        the molecule this calculation was created with from will be
+        set
+        """
+        self._executor.output.filename = filename
+        self._executor.set_properties()
+        self._check_properties_exist()
+        return None
+
+    @property
+    def optimiser(self) -> "BaseOptimiser":
+        """The optimiser used to run this calculation"""
+        return self._executor.optimiser
+
+    def copy(self) -> "Calculation":
+        return deepcopy(self)
+
+    @property
+    def molecule(self) -> "Species":
+        return self._executor.molecule
+
+    @molecule.setter
+    def molecule(self, value: "Species"):
+        self._executor.molecule = value
+
+    @property
+    def keywords(self) -> "Keywords":
+        return self._executor.input.keywords
+
+    @property
+    def method(self) -> "Method":
+        return self._executor.method
+
+    def _check(self) -> None:
+        """
+        Ensure the molecule has the required properties and raise exceptions
+        if they are not present. Also ensure that the method has the requsted
+        solvent available.
+
+        -----------------------------------------------------------------------
+        Raises:
+            (ValueError | autode.exceptions.CalculationException):
+        """
+        from autode.species.species import Species
+
+        assert isinstance(self.molecule, Species)
+
+        if self.molecule.atoms is None or self.molecule.n_atoms == 0:
+            raise ex.NoInputError("Have no atoms. Can't form a calculation")
+
+        if not self.molecule.has_valid_spin_state:
+            raise ex.CalculationException(
+                f"Cannot execute a calculation without a valid spin state: "
+                f"Spin multiplicity (2S+1) = {self.molecule.mult}"
+            )
+
+        return None
+
+    def _add_to_comp_methods(self) -> None:
+        """Add the methods used in this calculation to the used methods list"""
+        from autode.log.methods import methods
+
+        methods.add(
+            f"Calculations were performed using {self.method.name} v. "
+            f"{self.method.version_in(self._executor)} "
+            f"({self.method.doi_str})."
+        )
+
+        # Type of calculation ----
+        if isinstance(self.input.keywords, kws.SinglePointKeywords):
+            string = "Single point "
+
+        elif isinstance(self.input.keywords, kws.OptKeywords):
+            string = "Optimisation "
+
+        else:
+            logger.warning(
+                "Not adding gradient or hessian to methods section "
+                "anticipating that they will be the same as opt"
+            )
+            # and have been already added to the methods section
+            return
+
+        # Level of theory ----
+        string += (
+            f"calculations performed at the "
+            f"{self.input.keywords.method_string} level"
+        )
+
+        basis = self.input.keywords.basis_set
+        if basis is not None:
+            string += (
+                f" in combination with the {str(basis)} "
+                f"({basis.doi_str}) basis set"
+            )
+
+        if (
+            self.molecule.solvent is not None
+            and self.molecule.solvent.is_implicit
+        ):
+            solv_type = self.method.implicit_solvation_type
+            assert solv_type is not None, "Must have an implicit solvent type"
+            doi = solv_type.doi_str if hasattr(solv_type, "doi_str") else "?"
+
+            string += (
+                f" and {solv_type.upper()} ({doi}) "
+                f"solvation, with parameters appropriate for "
+                f"{self.molecule.solvent}"
+            )
+
+        methods.add(f"{string}.\n")
+        return None
+
+    def _check_properties_exist(self) -> None:
+        """
+        Check that the requested properties, as defined by the type of keywords
+        that this calculation was requested with have been set.
+
+        -----------------------------------------------------------------------
+        Raises:
+            (CouldNotGetProperty): If the required property couldn't be found
+        """
+        logger.info("Checking required properties exist")
+
+        if not self.terminated_normally:
+            logger.error(
+                f"Calculation of {self.molecule} did not terminate "
+                f"normally"
+            )
+            raise ex.CouldNotGetProperty()
+
+        if self.molecule.energy is None:
+            raise ex.CouldNotGetProperty(name="energy")
+
+        if _are_grad(self.keywords) and self.molecule.gradient is None:
+            raise ex.CouldNotGetProperty(name="gradient")
+
+        if _are_hess(self.keywords) and self.molecule.hessian is None:
+            raise ex.CouldNotGetProperty(name="Hessian")
+
+        return None
+
+
+def _are_opt(keywords) -> bool:
+    return isinstance(keywords, kws.OptKeywords)
+
+
+def _are_grad(keywords) -> bool:
+    return isinstance(keywords, kws.GradientKeywords)
+
+
+def _are_hess(keywords) -> bool:
+    return isinstance(keywords, kws.HessianKeywords)

autodE/source/autode/calculations/executors.py

@@ -0,0 +1,524 @@
+"""
+A collection of calculation executors which can execute the correct set of
+steps to run a calculation for a specific method, depending on what it
+implements
+"""
+import os
+import hashlib
+import base64
+import autode.exceptions as ex
+import autode.wrappers.keywords as kws
+
+from typing import Optional, List, Tuple, TYPE_CHECKING
+from copy import deepcopy
+
+from autode.log import logger
+from autode.config import Config
+from autode.values import Distance
+from autode.utils import no_exceptions, requires_output_to_exist
+from autode.point_charges import PointCharge
+from autode.opt.optimisers.base import NullOptimiser, BaseOptimiser
+from autode.calculations.input import CalculationInput
+from autode.calculations.output import (
+    CalculationOutput,
+    BlankCalculationOutput,
+)
+from autode.values import PotentialEnergy, GradientRMS
+
+if TYPE_CHECKING:
+    from autode.species.species import Species
+    from autode.wrappers.methods import Method
+    from autode.wrappers.keywords import Keywords
+    from autode.opt.optimisers.base import NDOptimiser
+
+
+class CalculationExecutor:
+    def __init__(
+        self,
+        name: str,
+        molecule: "Species",
+        method: "Method",
+        keywords: "Keywords",
+        n_cores: int = 1,
+        point_charges: Optional[List[PointCharge]] = None,
+    ):
+        # Calculation names that start with "-" can break EST methods
+        self.name = f"{_string_without_leading_hyphen(name)}_{method.name}"
+
+        self.molecule = molecule
+        self.method = method
+        self.optimiser: BaseOptimiser = NullOptimiser()
+        self.n_cores = int(n_cores)
+
+        self.input = CalculationInput(
+            keywords=keywords,
+            added_internals=_active_bonds(molecule),
+            point_charges=point_charges,
+        )
+        self._external_output = CalculationOutput()
+        self._check()
+
+    def _check(self) -> None:
+        """Check that the method has the required properties to run the calc"""
+
+        if self.molecule.solvent is None or self.molecule.solvent.is_explicit:
+            return
+
+        if getattr(self.molecule.solvent, self.method.name) is None:
+            err_str = (
+                f"Could not find {self.molecule.solvent} for "
+                f"{self.method.name}. Available solvents for {self.method.name} "
+                f"are: {self.method.available_implicit_solvents}"
+            )
+
+            raise ex.SolventUnavailable(err_str)
+
+        return None
+
+    def run(self) -> None:
+        """Run/execute the calculation"""
+
+        if self.method.uses_external_io:
+            self.generate_input()
+            self.output.filename = self.method.output_filename_for(self)
+            self._execute_external()
+            self.set_properties()
+            self.clean_up()
+
+        else:
+            self.method.execute(self)
+
+        return None
+
+    def generate_input(self) -> None:
+        """Generate the required input file"""
+        logger.info(f"Generating input file(s) for {self.name}")
+
+        # Can switch off uniqueness testing with e.g.
+        # export AUTODE_FIXUNIQUE=False   used for testing
+        if os.getenv("AUTODE_FIXUNIQUE", True) != "False":
+            self._fix_unique()
+
+        self.input.filename = self.method.input_filename_for(self)
+
+        # Check that if the keyword is a autode.wrappers.keywords.Keyword then
+        # it has the required name in the method used for this calculation
+        for keyword in self.input.keywords:
+            if not isinstance(keyword, kws.Keyword):  # allow string keywords
+                continue
+
+            # Allow for the unambiguous setting of a keyword with only a name
+            if keyword.has_only_name:
+                # set e.g. keyword.orca = 'b3lyp'
+                setattr(keyword, self.method.name, keyword.name)
+                continue
+
+            # For a keyword e.g. Keyword(name='pbe', orca='PBE') then the
+            # definition in this method is not obvious, so raise an exception
+            if getattr(keyword, self.method.name) is None:
+                err_str = (
+                    f"Keyword: {keyword} is not supported set "
+                    f"{repr(keyword)}.{self.method.name} as a string"
+                )
+                raise ex.UnsupportedCalculationInput(err_str)
+
+        return self.method.generate_input_for(self)
+
+    def _execute_external(self) -> None:
+        """
+        Execute an external calculation i.e. one that saves a log file if it
+        has not been run, or if it did not finish with a normal termination
+        """
+        logger.info(f"Running {self.input.filename} using {self.method.name}")
+
+        if not self.input.exists:
+            raise ex.NoInputError("Input did not exist")
+
+        if self.output.exists and self.terminated_normally:
+            logger.info("Calculation already terminated normally. Skipping")
+            return None
+
+        if not self.method.is_available:
+            raise ex.MethodUnavailable(f"{self.method} was not available")
+
+        self.output.clear()
+        self.method.execute(self)
+
+        return None
+
+    @requires_output_to_exist
+    def set_properties(self) -> None:
+        """Set the properties of a molecule from this calculation"""
+        keywords = self.input.keywords
+
+        if isinstance(keywords, kws.OptKeywords):
+            self.optimiser = self.method.optimiser_from(self)
+            self.molecule.coordinates = self.method.coordinates_from(self)
+
+        self.molecule.energy = self.method.energy_from(self)
+
+        if isinstance(keywords, kws.GradientKeywords):
+            self.molecule.gradient = self.method.gradient_from(self)
+        else:  # Try to set the gradient anyway
+            self._no_except_set_gradient()
+
+        if isinstance(keywords, kws.HessianKeywords):
+            self.molecule.hessian = self.method.hessian_from(self)
+        else:  # Try to set hessian anyway
+            self._no_except_set_hessian()
+
+        try:
+            self.molecule.partial_charges = self.method.partial_charges_from(
+                self
+            )
+        except (ValueError, IndexError, ex.AutodeException):
+            logger.warning("Failed to set partial charges")
+
+        return None
+
+    @no_exceptions
+    def _no_except_set_gradient(self) -> None:
+        self.molecule.gradient = self.method.gradient_from(self)
+
+    @no_exceptions
+    def _no_except_set_hessian(self) -> None:
+        self.molecule.hessian = self.method.hessian_from(self)
+
+    def clean_up(self, force: bool = False, everything: bool = False) -> None:
+        if not self.method.uses_external_io:  # Then there are no i/o files
+            return None
+
+        if Config.keep_input_files and not force:
+            logger.info("Keeping input files")
+            return None
+
+        filenames = self.input.filenames
+        if everything:
+            filenames.append(self.output.filename)
+            filenames += [
+                fn for fn in os.listdir() if fn.startswith(self.name)
+            ]
+
+        logger.info(f"Deleting: {set(filenames)}")
+
+        for filename in [fn for fn in set(filenames) if fn is not None]:
+            try:
+                os.remove(filename)
+            except FileNotFoundError:
+                logger.warning(f"Could not delete {filename} it did not exist")
+
+        return None
+
+    @property
+    def terminated_normally(self) -> bool:
+        """
+        Determine if the calculation terminated without error
+
+        -----------------------------------------------------------------------
+        Returns:
+            (bool): Normal termination of the calculation?
+        """
+        logger.info(f"Checking for {self.output.filename} normal termination")
+
+        if self.method.uses_external_io and not self.output.exists:
+            logger.warning("Calculation did not generate any output")
+            return False
+
+        return self.method.terminated_normally_in(self)
+
+    @property
+    def output(self) -> "CalculationOutput":
+        """
+        Calculation output. If the method does not use any external files
+        then a blank calculation output is returned
+        """
+
+        if self.method.uses_external_io:
+            return self._external_output
+        else:
+            return BlankCalculationOutput()
+
+    @output.setter
+    def output(self, value: CalculationOutput):
+        """Set the value of the calculation output"""
+        assert isinstance(value, CalculationOutput)
+
+        self._external_output = value
+
+    def copy(self) -> "CalculationExecutor":
+        return deepcopy(self)
+
+    def __str__(self):
+        """Create a unique string(/hash) of the calculation"""
+        string = (
+            f"{self.name}{self.method.name}{repr(self.input.keywords)}"
+            f"{self.molecule}{self.method.implicit_solvation_type}"
+            f"{self.molecule.constraints}"
+        )
+
+        hasher = hashlib.sha1(string.encode()).digest()
+        return base64.urlsafe_b64encode(hasher).decode()
+
+    def _fix_unique(self, register_name=".autode_calculations") -> None:
+        """
+        If a calculation has already been run for this molecule then it
+        shouldn't be run again, unless the input keywords have changed, in
+        which case it should be run while retaining the previous data. This
+        function fixes this problem by checking .autode_calculations and adding
+        a number to the end of self.name if the calculation input is different
+        """
+
+        def append_register():
+            with open(register_name, "a") as register_file:
+                print(self.name, str(self), file=register_file)
+
+        def exists():
+            return any(reg_name == self.name for reg_name in register.keys())
+
+        def is_identical():
+            return any(reg_id == str(self) for reg_id in register.values())
+
+        # If there is no register yet in this folder then create it
+        if not os.path.exists(register_name):
+            logger.info("No calculations have been performed here yet")
+            append_register()
+            return None
+
+        # Populate a register of calculation names and their unique identifiers
+        register = {}
+        for line in open(register_name, "r"):
+            if len(line.split()) == 2:  # Expecting: name id
+                calc_name, identifier = line.split()
+                register[calc_name] = identifier
+
+        if is_identical():
+            logger.info("Calculation exists in registry")
+            return None
+
+        # If this calculation doesn't yet appear in the register add it
+        if not exists():
+            logger.info("This calculation has not yet been run")
+            append_register()
+            return None
+
+        # If we're here then this calculation - with these input - has not yet
+        # been run. Therefore, add an integer to the calculation name until
+        # either the calculation has been run before and is the same or it's
+        # not been run
+        logger.info(
+            "Calculation with this name has been run before but "
+            "with different input"
+        )
+        name, n = self.name, 0
+        while True:
+            self.name = f"{name}{n}"
+            logger.info(f"New calculation name is: {self.name}")
+
+            if is_identical():
+                return None
+
+            if not exists():
+                append_register()
+                return None
+
+            n += 1
+
+
+class _IndirectCalculationExecutor(CalculationExecutor):
+    """
+    An 'indirect' executor is one that, given a calculation to perform,
+    calls the method multiple times and aggregates the results in some way.
+    Therefore, there is no direct calculation output.
+    """
+
+    @property
+    def output(self) -> "CalculationOutput":
+        return BlankCalculationOutput()
+
+    @output.setter
+    def output(self, value: CalculationOutput):
+        raise ValueError("Cannot set the output of an indirect calculation")
+
+
+class CalculationExecutorO(_IndirectCalculationExecutor):
+    """Calculation executor that uses autodE inbuilt optimisation"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.conv_tol = "normal"
+        self._fix_unique()
+
+    def run(self) -> None:
+        """Run an optimisation with using default autodE optimisers"""
+        from autode.opt.optimisers.crfo import CRFOptimiser
+        from autode.opt.optimisers.prfo import PRFOptimiser
+
+        if self._opt_trajectory_exists:
+            self.optimiser = CRFOptimiser.from_file(self._opt_trajectory_name)
+            self._set_properties_from_optimiser()
+            return None
+
+        type_ = PRFOptimiser if self._calc_is_ts_opt else CRFOptimiser
+
+        self.optimiser: "NDOptimiser" = type_(
+            init_alpha=self._step_size,
+            maxiter=self._max_opt_cycles,
+            conv_tol=self.conv_tol,
+        )
+        method = self.method.copy()
+        method.keywords.grad = kws.GradientKeywords(self.input.keywords)
+
+        self.optimiser.run(
+            species=self.molecule,
+            method=method,
+            n_cores=self.n_cores,
+            name=self._opt_trajectory_name,
+        )
+        self.optimiser.print_geometries(
+            self._opt_trajectory_name[:-4]
+            if self._opt_trajectory_name.endswith(".zip")
+            else self._opt_trajectory_name
+        )
+
+        if self.molecule.n_atoms == 1:
+            return self._run_single_energy_evaluation()
+
+        if self._calc_is_ts_opt:
+            # If this calculation is a transition state optimisation then a
+            # hessian on the final structure is required
+            self.molecule.calc_hessian(
+                method=self.method, n_cores=self.n_cores
+            )
+        return None
+
+    def _run_single_energy_evaluation(self) -> None:
+        """Run a single point energy evaluation, suitable for a single atom"""
+        from autode.calculations.calculation import Calculation
+
+        calc = Calculation(
+            name=f"{self.molecule.name}_energy",
+            molecule=self.molecule,
+            method=self.method,
+            keywords=kws.SinglePointKeywords(self.input.keywords),
+            n_cores=self.n_cores,
+        )
+        calc.run()
+        return None
+
+    @property
+    def terminated_normally(self) -> bool:
+        """
+        Using inbuilt optimisers raise exceptions if something goes wrong, so
+        this property is always true, provided the output exists
+
+        -----------------------------------------------------------------------
+        Returns:
+            (bool): Normal termination of the calculation?
+        """
+        return self._opt_trajectory_exists or self.molecule.n_atoms == 1
+
+    def set_properties(self) -> None:
+        """
+        Nothing needs to be set as the energy/gradient/Hessian of the
+        molecule are set within the optimiser
+        """
+        return None
+
+    @property
+    def _calc_is_ts_opt(self) -> bool:
+        """Does this calculation correspond to a transition state opt"""
+        return isinstance(self.input.keywords, kws.OptTSKeywords)
+
+    @property
+    def _max_opt_cycles(self) -> int:
+        """Get the maximum num of optimisation cycles for this calculation"""
+        try:
+            return next(
+                int(kwd)
+                for kwd in self.input.keywords
+                if isinstance(kwd, kws.MaxOptCycles)
+            )
+        except StopIteration:
+            return 50
+
+    @property
+    def _step_size(self) -> float:
+        return 0.05 if self._calc_is_ts_opt else 0.1
+
+    @property
+    def _opt_trajectory_name(self) -> str:
+        return f"{self.name}_opt_trj.zip"
+
+    @property
+    def _opt_trajectory_exists(self) -> bool:
+        return os.path.exists(self._opt_trajectory_name)
+
+    def _set_properties_from_optimiser(self) -> None:
+        """Set the properties from the trajectory file, that must exist"""
+        logger.info(
+            "Setting optimised coordinates, gradient and energy from "
+            "the reloaded optimiser state"
+        )
+
+        final_coords = self.optimiser.final_coordinates
+        if final_coords is None:
+            raise ex.CalculationException("Final coordinates undefined")
+
+        cart_coords = final_coords.to("cart")
+        self.molecule.coordinates = cart_coords.reshape((-1, 3))
+        if cart_coords.g is not None:
+            self.molecule.gradient = cart_coords.g.reshape((-1, 3))
+
+        self.molecule.energy = final_coords.e
+        return None
+
+
+class CalculationExecutorG(_IndirectCalculationExecutor):
+    """Calculation executor with a numerical gradient evaluation"""
+
+    def run(self) -> None:
+        raise NotImplementedError
+
+
+class CalculationExecutorH(_IndirectCalculationExecutor):
+    """Calculation executor with a numerical Hessian evaluation"""
+
+    def run(self) -> None:
+        logger.warning(
+            f"{self.method} does not implement Hessian "
+            f"calculations. Evaluating a numerical Hessian"
+        )
+
+        from autode.hessians import NumericalHessianCalculator
+
+        nhc = NumericalHessianCalculator(
+            species=self.molecule,
+            method=self.method,
+            keywords=kws.GradientKeywords(self.input.keywords.tolist()),
+            do_c_diff=False,
+            shift=Distance(2e-3, units="Å"),
+            n_cores=self.n_cores,
+        )
+        nhc.calculate()
+        self.molecule.hessian = nhc.hessian
+
+    @property
+    def terminated_normally(self) -> bool:
+        """
+        This calculation executor terminated normally if the Hessian exists and
+        did not raise any exceptions along the way
+
+        -----------------------------------------------------------------------
+        Returns:
+            (bool):
+        """
+        return self.molecule.hessian is not None
+
+
+def _string_without_leading_hyphen(s: str) -> str:
+    return s if not s.startswith("-") else f"_{s}"
+
+
+def _active_bonds(molecule: "Species") -> List[Tuple[int, int]]:
+    return [] if molecule.graph is None else molecule.graph.active_bonds

autodE/source/autode/calculations/input.py

@@ -0,0 +1,72 @@
+import os
+import autode.wrappers.keywords as kws
+
+from typing import Optional, List, TYPE_CHECKING
+from autode.point_charges import PointCharge
+
+if TYPE_CHECKING:
+    from autode.wrappers.keywords import Keywords
+
+
+class CalculationInput:
+    def __init__(
+        self,
+        keywords: "Keywords",
+        added_internals: Optional[list] = None,
+        point_charges: Optional[List[PointCharge]] = None,
+    ):
+        """
+        Calculation input
+
+        -----------------------------------------------------------------------
+        Arguments:
+            keywords: Keywords that a method will use to run the calculation
+                      e.g. ['pbe', 'def2-svp'] for an ORCA single point at
+                      PBE/def2-SVP
+
+            added_internals: Atom indexes to add to the internal coordinates
+
+            point_charges: Optional list of float of point charges, x, y, z
+                           coordinates for each point charge
+        """
+        self.keywords: Keywords = keywords.copy()
+
+        self.added_internals: Optional[list] = None
+        if added_internals is not None and len(added_internals) > 0:
+            self.added_internals = added_internals
+
+        self.point_charges = point_charges
+
+        self.filename: Optional[str] = None
+        self.additional_filenames: List[str] = []
+
+        self._check()
+
+    def _check(self):
+        """Check that the input parameters have the expected format"""
+        if self.keywords is not None:
+            assert isinstance(self.keywords, kws.Keywords)
+
+        # Ensure the point charges are given as a list of PointCharge objects
+        if self.point_charges is not None:
+            assert type(self.point_charges) is list
+            assert all(type(pc) is PointCharge for pc in self.point_charges)
+
+        if self.added_internals is not None:
+            assert type(self.added_internals) is list
+            assert all(len(idxs) == 2 for idxs in self.added_internals)
+
+    @property
+    def exists(self):
+        """Does the input (files) exist?"""
+        return self.filename is not None and all(
+            os.path.exists(fn) for fn in self.filenames
+        )
+
+    @property
+    def filenames(self):
+        """Return a list of all the input files"""
+        if self.filename is None:
+            return self.additional_filenames
+
+        return [self.filename] + self.additional_filenames

autodE/source/autode/calculations/output.py

@@ -0,0 +1,87 @@
+import os
+import autode.exceptions as ex
+
+from typing import Optional, List
+from functools import cached_property
+from autode.log import logger
+
+
+class CalculationOutput:
+    def __init__(self, filename: Optional[str] = None):
+        self._filename = filename
+
+    @property
+    def filename(self) -> Optional[str]:
+        return self._filename
+
+    @filename.setter
+    def filename(self, value: str):
+        self._filename = str(value)
+        self.clear()
+
+    @cached_property
+    def file_lines(self) -> List[str]:
+        """
+        Output files lines. This may be slow for large files but should
+        not become a bottleneck when running standard DFT/WF calculations,
+        are cached so only read once
+
+        -----------------------------------------------------------------------
+        Returns:
+            (list(str)): Lines from the output file
+
+        Raises:
+            (autode.exceptions.NoCalculationOutput): If the file doesn't exist
+        """
+        logger.info("Setting output file lines")
+
+        if self.filename is None or not os.path.exists(self.filename):
+            raise ex.NoCalculationOutput
+
+        file = open(self.filename, "r", encoding="utf-8", errors="ignore")
+        return file.readlines()
+
+    @property
+    def exists(self) -> bool:
+        """Does the calculation output exist?"""
+        return self.filename is not None and os.path.exists(self.filename)
+
+    def clear(self) -> None:
+        """Clear the cached file lines"""
+
+        if "file_lines" in self.__dict__:
+            del self.__dict__["file_lines"]
+
+        return None
+
+    def try_to_print_final_lines(self, n: int = 50) -> None:
+        """
+        Attempt to print the final n output lines, if the output exists
+
+        -----------------------------------------------------------------------
+        Arguments:
+            n: Number of lines
+        """
+
+        if self.exists:
+            print("".join(self.file_lines[-n:]))
+
+        return None
+
+
+class BlankCalculationOutput(CalculationOutput):
+    @property
+    def filename(self) -> Optional[str]:
+        return None
+
+    @filename.setter
+    def filename(self, value: str):
+        raise ValueError("Cannot set the filename of a blank output")
+
+    @property
+    def file_lines(self) -> List[str]:
+        return []
+
+    @property
+    def exists(self) -> bool:
+        return True

autodE/source/autode/calculations/types.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CalculationType(Enum):
+    """Enum defining a mode/type of a calculation"""
+
+    opt = 0
+    energy = 1
+    gradient = 2
+    hessian = 3

autodE/source/autode/common/NEB.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:694f945d2516a306819efe16cca784e12b6d657c7bae52e989ba4b0368b3899a
+size 106121

autodE/source/autode/common/NEB.tex

@@ -0,0 +1,60 @@
+\documentclass[10pt]{article}
+\usepackage{bm}% bold math
+\usepackage{amsmath}
+
+\begin{document}
+
+\subsection{Original NEB}
+
+Nudged elastic band (NEB) approaches to locating transition states are efficient alternatives to evaluating the PES on a uniform grid over some coordinates of interest. The implementation in \emph{autodE} follows that in [\emph{J. Chem. Phys.}, 2000, {\bfseries{113}}, 9978]
+\\\\
+For an image $i$ in the nudged elastic band
+\begin{equation}
+\boldsymbol{\tau}_i =
+\begin{cases}
+\boldsymbol{\tau}_i^+ &\quad\text{if}\quad V_{i-1} < V_i < V_{i+1} \\
+\boldsymbol{\tau}_i^- &\quad\text{if}\quad V_{i+1} < V_i < V_{i-1} \\
+\boldsymbol{\tau}_i^+\Delta V_i^{max} + \boldsymbol{\tau}_i^-\Delta V_i^{min} &\quad\text{if}\quad V_{i-1} <  V_{i+1} \\
+\boldsymbol{\tau}_i^+\Delta V_i^{min} + \boldsymbol{\tau}_i^-\Delta V_i^{max} &\quad\text{if}\quad V_{i+1} < V_{i-1} \\
+\end{cases}
+\end{equation}
+where
+\begin{equation}
+\begin{aligned}
+\boldsymbol{\tau}_i^+ &= \boldsymbol{x}_{i+1} - \boldsymbol{x}_i \\
+\boldsymbol{\tau}_i^- &= \boldsymbol{x}_{i} - \boldsymbol{x}_{i-1}
+\end{aligned}
+\end{equation}
+and
+\begin{equation}
+\begin{aligned}
+\Delta V_i^{max} &= \max(|V_{i+1} - V_i|, |V_{i-1} - V_i|) \\
+\Delta V_i^{min} &= \min(|V_{i+1} - V_i|, |V_{i-1} - V_i|)
+\end{aligned}
+\end{equation}
+and $\boldsymbol{x}_i$ are the coordinates of image $i$. The spring force is
+\begin{equation}
+\boldsymbol{F}^s_i|_{\parallel} = (k_i|\boldsymbol{x}_{i+1} - \boldsymbol{x}_i| - k_{i-1}|\boldsymbol{x}_i - \boldsymbol{x}_{i-1}|) \hat{\boldsymbol{\tau}}_i
+\end{equation}
+and the total force on the image
+\begin{equation}
+\boldsymbol{F}_i = \boldsymbol{F}^s_i|_{\parallel} - \nabla V(\boldsymbol{x}_i)|_\perp
+\end{equation}
+where
+\begin{equation}
+\nabla V(\boldsymbol{x}_i)|_\perp = \nabla V(\boldsymbol{x}_i) - \nabla V(\boldsymbol{x}_i)\cdot \hat{\boldsymbol{\tau}}_i\hat{\boldsymbol{\tau}}_i
+\end{equation}
+and finally $\hat{\boldsymbol{\tau}} = \boldsymbol{\tau}_i/|\boldsymbol{\tau}_i|$.
+\\\\
+\subsection{CI-NEB}
+
+The climbing image (CI) NEB implementation follows that in [\emph{J. Chem. Phys.}, 2000, {\bfseries{113}}, 9901] where after a few iterations the force on the maximum energy image ($m$) is given by
+
+\begin{equation}
+\boldsymbol{F}_{m} = -\nabla V(\boldsymbol{x}_m) + 2\nabla V(\boldsymbol{x}_m)\cdot \hat{\boldsymbol{\tau}}_i\hat{\boldsymbol{\tau}}_i
+\end{equation}
+
+which is the force due to the potential along the band being inverted.
+
+
+\end{document}

autodE/source/autode/common/adaptive_path.tex

@@ -0,0 +1,32 @@
+\documentclass[10pt]{article}
+\usepackage{bm}% bold math
+\usepackage{amsmath}
+\DeclareMathOperator{\sgn}{sgn}
+
+\begin{document}
+
+\subsection{Adaptive Path}
+
+The adaptive path algorithm in \emph{autodE} attempts to traverse the minimum energy pathway from reactants to products with constrained optimisations using a gradient dependent step size. The initial constraints for the first point are
+
+\begin{equation}
+r_b^{(1)} = r_b^{(0)} + \sgn(r_b^\text{final} - r_b^{(0)})\Delta r_\text{init}
+\end{equation}
+\\
+for a bond $b$, where the superscript denotes the current step. $\Delta r_\text{init}$ is an initial step size, e.g. 0.2 Å. Constraints for subsequent steps are then given by
+\\\\
+\begin{equation}
+r_b^{(k)} = r_b^{(k-1)} + \sgn(r_b^\text{final} - r_b^{(0)})\Delta r_b^{(k-1)}
+\end{equation}
+
+\begin{equation}
+\Delta r_b^{(k)} =
+\begin{cases}
+\Delta r_\text{max} \quad &\text{if } \sgn(r_b^\text{final} - r_b^{(0)}) \nabla E_{j} \cdot \boldsymbol{r}_{ij} > 0 \\
+\Delta r_\text{m}\exp\left[-\left({\nabla E_{j}^{(k)} \cdot \boldsymbol{r}_{ij}}/{g} \right)^2\right] + \Delta r_\text{min} \quad &\text{otherwise}
+\end{cases}
+\end{equation}
+\\
+where $\Delta r_\text{m} = \Delta r_\text{max} - \Delta r_\text{min}$, $E$ the total potential energy (in the absence of any harmonic constraints) and $g$ a parameter to control the interpolation between $\Delta r_\text{max}$ and $\Delta r_\text{min}$ e.g. 0.05 Ha Å$^{-1}$. Atom indices $i, j$ form part of the bond indexed by $b$ with $j$ being an atom not being substituted. In the case that neither $i$ nor $j$ are being substituted the gradient is taken as an average over $i$ and $j$.
+
+\end{document}

autodE/source/autode/common/hessians.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8dfd38c9dbaf48e024f972a70c7546b08390c644af5cc839712c49bb4532426c
+size 154155

autodE/source/autode/common/hessians.tex

@@ -0,0 +1,192 @@
+\documentclass[10pt]{article}
+\usepackage{bm}% bold math
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{color}
+\DeclareMathOperator{\sgn}{sgn}
+\renewcommand{\thefootnote}{\alph{footnote}}
+
+\begin{document}
+
+\subsection{Hessian Diagonalization}
+
+Frequencies and normal modes are obtained from Hessian diagonalization, following the method from {\color{blue} https://tinyurl.com/4a75skfm}, which in turn uses (V. Barone, JCP, 2005, 122, 014108; V. Barone et al. IJQ. Chem., 2012, 112, 2185). Without projection frequencies and normal modes are just (transformed) eigenvalues and eigenvectors of the Hessian,
+
+\begin{equation}
+	\mathsf{H} = \begin{pmatrix}
+		\frac{\partial^2 E}{\partial x_1^2} & \frac{\partial^2 E}{\partial x_1y_1} &
+		\frac{\partial^2 E}{\partial x_1z_1} & \cdots\\
+		\frac{\partial^2 E}{\partial y_1x_1} & \frac{\partial^2 E}{\partial y_1^2} &
+		\frac{\partial^2 E}{\partial y_1z_1} & \cdots\\
+		\vdots & \vdots & \vdots & \ddots
+	\end{pmatrix}
+\end{equation}
+\\
+appropriately mass weighted,
+\begin{equation}
+	\mathsf{H}_\text{w} = \begin{pmatrix}
+		\frac{\mathsf{H}_{11}}{\sqrt{m_1 m_1}} & \cdots & \frac{\mathsf{H}_{1,3i}}{\sqrt{m_1 m_i}} & \cdots \\
+		\vdots & \vdots & \vdots & \ddots
+	\end{pmatrix}
+\end{equation}
+\\
+which is real symmetric so Hermitian ($\mathsf{H} \in \mathbb{R}^{3N\times3N}$ for a system of $N$ atoms). The frequencies are then square roots of the eigenvalues i.e. $\nu_i = \sqrt{\lambda_i}$\footnote{With an appropriate unit conversion.} and the normal modes $\boldsymbol{s}_i$ where,
+
+\begin{equation}
+	\mathsf{H}_\text{w} = \mathsf{S D S}^T \quad ; \quad \mathsf{D} = \begin{pmatrix}
+		\lambda_1 & 0  & \cdots \\
+		0 & \lambda_2 & \cdots \\
+		\vdots & \vdots & \ddots
+	\end{pmatrix}
+	%
+	\quad ; \quad
+	%
+	\mathsf{S} = \begin{pmatrix}
+		\uparrow & \uparrow &  \\
+		\boldsymbol{s}_1 & \boldsymbol{s}_2 & \cdots \\
+		\downarrow & \downarrow &
+	\end{pmatrix}
+\end{equation}
+\\
+To project out translational and rotational motion for a non linear molecule requires a transformation of $\mathsf{H}_\text{w}$,
+
+\begin{equation}
+	\mathsf{H}_\text{w}' = \mathsf{T}^T \mathsf{H}_\text{w} \mathsf{T} \qquad ; \qquad \mathsf{H}_\text{w}' = \begin{pmatrix}
+		\boldsymbol{0} & \boldsymbol{0} \\
+		\boldsymbol{0} & \bar{\mathsf{H}}_\text{w}
+	\end{pmatrix}
+\end{equation}
+\\
+where
+\begin{equation}
+	\mathsf{T} = \begin{pmatrix}
+		\uparrow & \uparrow  & \\
+		\hat{\boldsymbol{t}}_1 & \hat{\boldsymbol{t}}_2 & \cdots \\
+		\downarrow & \downarrow &
+	\end{pmatrix}
+\end{equation}
+\\
+and the columns of $\mathsf{M}$ are,
+
+\begin{equation}
+	\boldsymbol{t}_1 = \begin{bmatrix}
+		(\hat{\boldsymbol{e}}_1)_1 \\
+		\vdots \\
+		(\hat{\boldsymbol{e}}_1)_N \\
+	\end{bmatrix}
+	%
+	\quad ; \quad
+	%
+	\boldsymbol{t}_2 = \begin{bmatrix}
+		(\hat{\boldsymbol{e}}_2)_1 \\
+		\vdots \\
+		(\hat{\boldsymbol{e}}_2)_N \\
+	\end{bmatrix}
+	%
+	\quad ; \quad
+	%
+	\boldsymbol{t}_3 = \begin{bmatrix}
+		(\hat{\boldsymbol{e}}_3)_1 \\
+		\vdots \\
+		(\hat{\boldsymbol{e}}_3)_N \\
+	\end{bmatrix}
+\end{equation}
+\\
+where $\hat{\boldsymbol{e}}_k$ is a unit vector in 3D (i.e. $\hat{\boldsymbol{e}}_1 = (1, 0, 0)^T$). The rotation vectors are
+
+\begin{equation}
+	\boldsymbol{t}_4 = \begin{bmatrix}
+		\boldsymbol{e}_1 \times \boldsymbol{r}_1 \\
+		\vdots \\
+		\boldsymbol{e}_1 \times \boldsymbol{r}_N \\
+	\end{bmatrix}
+	%
+	\quad ; \quad
+	%
+	\boldsymbol{t}_5 = \begin{bmatrix}
+		\boldsymbol{e}_2 \times \boldsymbol{r}_1 \\
+		\vdots \\
+		\boldsymbol{e}_2 \times \boldsymbol{r}_N \\
+	\end{bmatrix}
+	%
+	\quad ; \quad
+	%
+	\boldsymbol{t}_6 = \begin{bmatrix}
+		\boldsymbol{e}_3 \times \boldsymbol{r}_1 \\
+		\vdots \\
+		\boldsymbol{e}_3 \times \boldsymbol{r}_N \\
+	\end{bmatrix}
+\end{equation}
+\\
+where $\boldsymbol{r}_i$ is the vector from the centre of mass of the system to the atom $i$. The remaining $\boldsymbol{t}_n$ are filled with random vectors that are orthogonal to $\boldsymbol{t}_1\text{--}\boldsymbol{t}_6$, which can be achieved by QR factorisation once the remaining elements of $\mathsf{T}$ have been seeded with random numbers. Normalisation requires,
+
+\begin{equation}
+	\hat{\boldsymbol{t}}_i = \frac{\mathsf{M}^{1/2}\boldsymbol{t}_i}{|\mathsf{M}^{1/2}\boldsymbol{t}_i|}
+	%
+	\qquad ; \qquad
+	%
+	\mathsf{M} = \begin{pmatrix}
+		m_1 & 0 & 0 & 0 &\cdots \\
+		0 & m_1 & 0 & 0& \cdots \\
+		0 & 0 & m_1 & 0& \cdots \\
+		0 & 0 & 0 & m_2 & \cdots \\
+		\vdots & \vdots & \vdots & \vdots & \ddots
+	\end{pmatrix}
+\end{equation}
+\\
+where $m_i$ is the mass of atom $i$.
+
+\vspace{0.4cm}
+
+Projected frequencies are then obtained from the submatrix of $\mathsf{H}_\text{w}'$,
+
+
+\begin{equation}
+	\bar{\mathsf{H}}_\text{w} = \mathsf{\bar{S} \bar{D}\bar{S}}^T
+	%
+	\quad ; \quad
+	%
+	\bar{\mathsf{S}} =
+	\begin{pmatrix}
+		\uparrow & \\
+		\bar{\boldsymbol{s}}_7 & \cdots \\
+		\downarrow &
+	\end{pmatrix}
+	%
+	\quad ; \quad
+	%
+	\bar{\mathsf{D}} =
+	\begin{pmatrix}
+		\bar{\lambda}_7 &  0& \cdots \\
+		0 & \bar{\lambda}_8 & \cdots \\
+		\vdots & \vdots & \ddots
+	\end{pmatrix}
+\end{equation}
+with $\bar{\nu}_{0\text{--}6} = 0$ cm${}^{-1}$, while the eigenvectors are,
+
+\begin{equation}
+	\boldsymbol{s}_i = \mathsf{T}\boldsymbol{s}_i'
+	%
+	\quad ; \quad
+	%
+	\mathsf{S}' = \begin{pmatrix}
+		\uparrow & \\
+		\boldsymbol{s}_1' & \cdots\\
+		\downarrow &
+	\end{pmatrix}
+    =
+	\begin{pmatrix}
+		\boldsymbol{0} & \boldsymbol{0} \\
+		\boldsymbol{0} & \bar{\mathsf{S}}
+	\end{pmatrix}
+\end{equation}
+\\
+which correspond to the normal modes in the original coordinates. For a linear molecule the vibrational frequencies are then the $3N-5$ modes, rather than $3N-6$, with $\mathsf{H}_w'$ contains a different number of non-zero entries.
+
+
+
+
+
+
+
+\end{document}

autodE/source/autode/common/logo.pages

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:408f692d6bc6bc309fcf189fa15a7de7eb44f2e7726c9ada3379d1ff3f8d3d86
+size 101212

autodE/source/autode/common/thermochemistry.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3372faf8528e9aa2118cf95289cff147ed553bc10a5f9cad0dd4169184a5dc1c
+size 119353

autodE/source/autode/common/thermochemistry.tex

@@ -0,0 +1,91 @@
+\documentclass[10pt]{article}
+\usepackage{bm}% bold math
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{color}
+\DeclareMathOperator{\sgn}{sgn}
+\renewcommand{\thefootnote}{\alph{footnote}}
+
+\begin{document}
+
+\subsection{Ideal Gas Model}
+
+From (McQuarrie, Statistical mechanics, 2000) the ideal gas method (IGM) for calculating an absolute free energy is outlined below.
+\begin{equation}
+	G  = H - TS
+\end{equation}
+\begin{equation}
+	H = U + RT
+\end{equation}
+\begin{equation}
+	U = E_\text{pot} + E_\text{ZPE} + E_\text{trns} + E_\text{rot} + E_\text{vib} \end{equation}
+\begin{equation}
+	S = S_\text{trns} + S_\text{rot} + S_\text{vib} + S_\text{elec}
+\end{equation}
+
+where $T$ is temperature, $R$ the ideal gas constant and $S_\text{elec}$ is taken to be zero for all molecules. The internal energy components are then
+
+\begin{equation}
+	E_\text{ZPE} = \frac{N_a}{2}\sum_i h \nu_i
+\end{equation}
+\begin{equation}
+	E_\text{trns} = \frac{3}{2}RT
+\end{equation}
+\begin{equation}
+	E_\text{rot} =
+	\begin{cases}
+		0 &\quad \text{if  } N = 1 \\
+		RT &\quad \text{if linear} \\
+		\frac{3}{2} RT &\quad \text{otherwise}
+	\end{cases}
+\end{equation}
+\begin{equation}
+	E_\text{vib} = R \sum_i \frac{\theta_i}{e^{\theta_i / T} - 1} \quad ,\quad \theta_i = h\nu_i / k_B
+\end{equation}
+
+where $N_a$ is Avogadro's's constant, $N$ is the number of atoms in the molecule, $k_B$ Boltzmann's constant, $ \nu_i$ the $i$-th harmonic frequency and $h$ is Planks constant. The entropic components are
+
+\begin{equation}
+	S_\text{trns} = R  \ln(q_\text{trns}) + \frac{5}{2}R
+\end{equation}
+\begin{equation}
+	S_\text{rot} = \begin{cases}
+		0 &\quad \text{if  } N = 1 \\
+		R  \ln(q_\text{rot}) + R &\quad \text{if linear} \\
+		R  \ln(q_\text{rot}) + \frac{3}{2}R &\quad \text{otherwise}
+	\end{cases}
+\end{equation}
+\begin{equation}
+	S_\text{vib}^\text{HO} = R \sum_i \frac{\theta_i}{T(e^{\theta_i / T} - 1)} - \ln(1 - e^{-\theta_i / T})
+\end{equation}
+\begin{equation}
+	q_\text{trans} = {\Big (} \frac{2\pi m k_B T}{h^2} {\Big )}^{3/2}  V_\text{eff} \quad , \quad V_\text{eff} =  \begin{cases}
+		k_B T / p^{\circ} \quad&\text{if 1 atm standard state} \\
+		1 / c^\circ N_a \quad&\text{if 1 M standard state}
+	\end{cases}
+\end{equation}
+\begin{equation}
+	q_\text{rot} = \frac{T^{3/2}}{\sigma_r} \sqrt{\frac{\pi}{\omega_r}} \quad,\quad \omega_r = \prod_{k} \frac{h^2}{8 \pi^2 k_B I_k}
+\end{equation}
+
+where $q$ are molecular partition functions, $p^{\circ}$ is the standard pressure (1 atm) and $c^\circ$ the standard concentration (1 mol dm$^{-3}$), $\sigma_r$ is the rotational symmetry number for the molecule and $I_k$ a diagonal element of the moment of inertia matrix.
+\\\\
+Due to the vibrational entropy contribution being overestimated for low frequency modes Thrular proposed a correction, which instead of summing over frequencies in $S_\text{vib}^\text{HO}$ does so over $\max(\nu_\text{thresh},\; \nu_i)$ to shift all low frequencies to a threshold value (\emph{J. Phys. Chem. B} 2011, {\bfseries{115}}, 14556). An alternative method from Grimme (\emph{Chem. Eur. J.}, 2012, {\bfseries{18}}, 9955) uses an interpolation between a harmonic oscillator and rigid rotor to scale down the contribution from the low frequency modes as
+\begin{equation}
+	S_\text{vib}^\text{Grimme} = \sum_i w_i S_ \text{vib}^\text{HO}(i) + (1-w_i) {\Big (} R\ln {\Big (} \sqrt{\frac{8 \pi^3 \mu_i' k_B T}{h^2}} {\Big )} + \frac{R}{2} {\Big )}
+\end{equation}
+\begin{eqnarray}
+	\mu_i' = \frac{\mu_i \bar{B}}{\mu_i + \bar{B}} \quad,\quad \mu_i = \frac{h}{8\pi^2 \nu_i} \quad,\quad \bar{B} = \text{Tr}[I] / 3
+\end{eqnarray}
+\begin{equation}
+	w_i = \frac{1}{1 + (\omega_0/ \nu_i)^\alpha}
+\end{equation}
+where $\omega_0$ and $\alpha$ are adjustable parameters.
+
+
+
+
+
+
+
+\end{document}

autodE/source/autode/config.py

@@ -0,0 +1,459 @@
+import os
+from typing import Any
+from autode.values import Frequency, Distance, Allocation
+from autode.wrappers.keywords import implicit_solvent_types as solv
+from autode.wrappers.keywords import KeywordsSet, MaxOptCycles
+from autode.wrappers.keywords.basis_sets import (
+    def2svp,
+    def2tzvp,
+    def2ecp,
+    def2tzecp,
+)
+from autode.wrappers.keywords.functionals import pbe0
+from autode.wrappers.keywords.dispersion import d3bj
+from autode.wrappers.keywords.ri import rijcosx
+
+location = os.path.abspath(__file__)
+
+
+class _ConfigClass:
+    # -------------------------------------------------------------------------
+    # Total number of cores available
+    #
+    n_cores = 4
+    # -------------------------------------------------------------------------
+    # Per core memory available
+    #
+    max_core = Allocation(4, units="GB")
+    # -------------------------------------------------------------------------
+    # DFT code to use. If set to None then the highest priority available code
+    # will be used:
+    # 1. 'orca', 2. 'g09' 3. 'nwchem'
+    #
+    hcode = None
+    # -------------------------------------------------------------------------
+    # Semi-empirical/tight binding method to use. If set to None then the
+    # highest priority available will be used:   1. 'xtb', 2. 'mopac'
+    #
+    lcode = None
+    # -------------------------------------------------------------------------
+    # When using explicit solvent is stable this will be uncommented
+    #
+    # explicit_solvent = False
+    #
+    # -------------------------------------------------------------------------
+    # Setting to keep input files, otherwise they will be removed
+    #
+    keep_input_files = True
+    # -------------------------------------------------------------------------
+    # Use a different base directory for calculations with low-level methods
+    # e.g. /dev/shm with a low level method, if None then will use the default
+    # in tempfile.mkdtemp
+    #
+    ll_tmp_dir = None
+    # -------------------------------------------------------------------------
+    # By default templates are saved to /path/to/autode/transition_states/lib/
+    # unless ts_template_folder_path is set
+    #
+    ts_template_folder_path = None
+    # -------------------------------------------------------------------------
+    # Whether or not to create and save transition state templates
+    #
+    make_ts_template = True
+    # -------------------------------------------------------------------------
+    # Save plots with dpi = 400
+    #
+    high_quality_plots = True
+    # -------------------------------------------------------------------------
+    # RMSD in angstroms threshold for conformers. Larger values will remove
+    # more conformers that need to be calculated but also reduces the chance
+    # that the lowest energy conformer is found
+    #
+    rmsd_threshold = Distance(0.3, units="Å")
+    # -------------------------------------------------------------------------
+    # Total number of conformers generated in find_lowest_energy_conformer()
+    # for single molecules/TSs
+    #
+    num_conformers = 300
+    # -------------------------------------------------------------------------
+    # Maximum random displacement in angstroms for conformational searching
+    #
+    max_atom_displacement = Distance(4.0, units="Å")
+    # -------------------------------------------------------------------------
+    # Number of evenly spaced points on a sphere that will be used to generate
+    # NCI and Reactant and Product complex conformers. Total number of
+    # conformers will be:
+    #   (num_complex_sphere_points ×
+    #              num_complex_random_rotations) ^ (n molecules in complex - 1)
+    #
+    num_complex_sphere_points = 10
+    # -------------------------------------------------------------------------
+    # Number of random rotations of a molecule that is added to a NCI or
+    # Reactant/Product complex
+    #
+    num_complex_random_rotations = 10
+    # -------------------------------------------------------------------------
+    # For more than 2 molecules in a complex the conformational space explodes,
+    # so limit the maximum number to this value
+    #
+    max_num_complex_conformers = 300
+    # -------------------------------------------------------------------------
+    # Use the high + low level method to find the lowest energy
+    # conformer, to use energies at the low_opt level of the low level code
+    # set this to False
+    #
+    hmethod_conformers = True
+    # -------------------------------------------------------------------------
+    # Set to True to use single point energy evaluations to rank conformers and
+    # select the lowest energy. Requires keywords.low_sp to be set and
+    # hmethod_conformers = True
+    # WARNING: This relies on the low-level geometry being accurate enough for
+    # the system in question – switching this on without benchmarking may lead
+    # to large errors!
+    #
+    hmethod_sp_conformers = False
+    # -------------------------------------------------------------------------
+    # Use adaptive force constant modification in NEB calculations to improve
+    # sampling around the saddle point
+    #
+    adaptive_neb_k = True
+    # -------------------------------------------------------------------------
+    # Minimum and maximum step size to use for the adaptive path search
+    #
+    min_step_size = Distance(0.05, units="Å")
+    max_step_size = Distance(0.3, units="Å")
+    # -------------------------------------------------------------------------
+    # Heuristic for pruning the bond rearrangement set. If there are only bond
+    # rearrangements that involve small rings then TSs involving small rings
+    # are possible. However, when there are multiple possibilities involving
+    # the same set of atoms then discard any rearrangements that would involve
+    # a 3 or 4-membered TS e.g. skip the possible 4-membered TS for a Cope
+    # rearrangement in hexadiene
+    #
+    skip_small_ring_tss = True
+    # -------------------------------------------------------------------------
+    # Minimum magnitude of the imaginary frequency (cm-1) to consider for a
+    # 'true' TS. For very shallow saddle points this may need to be reduced
+    # to e.g. -10 cm-1. Although most TSs have |v_imag| > 100 cm-1 this
+    # threshold is designed to be conservative
+    #
+    min_imag_freq = Frequency(-40, units="cm-1")
+    # -------------------------------------------------------------------------
+    # Configuration parameters for ideal gas free energy calculations. Can be
+    # configured to use different standard states, quasi-rigid rotor harmonic
+    # oscillator (qRRHO) or pure RRHO
+    #
+    #  One of: '1M', '1atm'
+    standard_state = "1M"
+    #
+    # Method to treat low frequency modes (LFMs). Either standard RRHO ('igm'),
+    # Truhlar's method where all frequencies below a threshold are scaled to
+    # a shifted value (see J. Phys. Chem. B, 2011, 115, 14556), Grimme's
+    # method of interpolating between HO and RR (i.e. qRRHO, see
+    # Chem. Eur. J. 2012, 18, 9955), or 'minenkov' where free rotor/vibrational
+    # interpolation is useed for U and S (i.e. mRRHO, see
+    # J. Comput. Chem., 2023 44, 1807)
+    #
+    # One of: 'igm', 'truhlar', 'grimme', 'minenkov'
+    lfm_method = "grimme"
+    #
+    # Parameters for Grimme's method (only used when lfm_method='grimme'),
+    # w0 is a frequency in cm-1
+    grimme_w0 = Frequency(100, units="cm-1")
+    grimme_alpha = 4
+    #
+    # Parameters for Truhlar's method (only used when lfm_method='truhlar')
+    # vibrational frequencies below this value (cm-1) will be shifted to this
+    # value before the entropy is calculated
+    vib_freq_shift = Frequency(100, units="cm-1")
+    # -------------------------------------------------------------------------
+    # Frequency scale factor, useful for DFT functions known to have a
+    # systematic error. This value must be between 0 and 1 inclusive. For
+    # example, PBEh-3c has a scale factor of 0.95.
+    #
+    freq_scale_factor = None
+    # -------------------------------------------------------------------------
+    # Minimum number of atoms that are removed for truncation to be used in
+    # locating TSs. Below this number any truncation is skipped
+    #
+    min_num_atom_removed_in_truncation = 10
+    # -------------------------------------------------------------------------
+    # Flag for allowing free energies to be calculated with association
+    # complexes. This is *not* recommended to be turned on due to the
+    # approximations made in the entropy calculations.
+    #
+    allow_association_complex_G = False
+    # -------------------------------------------------------------------------
+    # Flag to allow use of an experimental timeout function wrapper for
+    # Windows, using loky. The default case has no timeout for Windows, and
+    # timeout only works on Linux/macOS. This flag is ignored on Linux/macOS.
+    #
+    use_experimental_timeout = False
+    # -------------------------------------------------------------------------
+
+    class ORCA:
+        # ---------------------------------------------------------------------
+        # Parameters for orca   https://sites.google.com/site/orcainputlibrary/
+        # ---------------------------------------------------------------------
+        #
+        # Path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        # File extensions to copy when a calculation completes
+        copied_output_exts = [".out", ".hess", ".xyz", ".inp", ".pc"]
+
+        optts_block = (
+            "\n%geom\n"
+            "Calc_Hess true\n"
+            "Recalc_Hess 20\n"
+            "Trust -0.1\n"
+            "MaxIter 100\n"
+            "end"
+        )
+
+        keywords = KeywordsSet(
+            low_opt=[
+                "LooseOpt",
+                pbe0,
+                rijcosx,
+                d3bj,
+                def2svp,
+                "def2/J",
+                MaxOptCycles(10),
+            ],
+            grad=["EnGrad", pbe0, rijcosx, d3bj, def2svp, "def2/J"],
+            low_sp=["SP", pbe0, rijcosx, d3bj, def2svp, "def2/J"],
+            opt=["Opt", pbe0, rijcosx, d3bj, def2svp, "def2/J"],
+            opt_ts=[
+                "OptTS",
+                "Freq",
+                pbe0,
+                rijcosx,
+                d3bj,
+                def2svp,
+                "def2/J",
+                optts_block,
+            ],
+            hess=["Freq", pbe0, rijcosx, d3bj, def2svp, "def2/J"],
+            sp=["SP", pbe0, rijcosx, d3bj, def2tzvp, "def2/J"],
+            ecp=def2ecp,
+        )
+
+        # Implicit solvent in ORCA is either treated with CPCM or SMD, the
+        # former has support for a VdW surface construction which provides
+        # better geometry convergence (https://doi.org/10.1002/jcc.26139) SMD
+        # is in general more accurate, but does not (yet) have support for the
+        # VdW charge scheme. Use either (1) solv.cpcm, (2) solv.smd
+        implicit_solvation_type = solv.cpcm
+
+    class G09:
+        # ---------------------------------------------------------------------
+        # Parameters for g09                 https://gaussian.com/glossary/g09/
+        # ---------------------------------------------------------------------
+        #
+        # path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        grid = "integral=ultrafinegrid"
+        optts_block = (
+            "Opt=(TS, CalcFC, NoEigenTest, MaxCycles=100, "
+            "MaxStep=10, NoTrustUpdate)"
+        )
+
+        keywords = KeywordsSet(
+            low_opt=[pbe0, def2svp, "Opt=Loose", MaxOptCycles(10), d3bj, grid],
+            grad=[pbe0, def2svp, "Force(NoStep)", d3bj, grid],
+            low_sp=[pbe0, def2svp, d3bj, grid],
+            opt=[pbe0, def2svp, "Opt", d3bj, grid],
+            opt_ts=[pbe0, def2svp, "Freq", d3bj, grid, optts_block],
+            hess=[pbe0, def2svp, "Freq", d3bj, grid],
+            sp=[pbe0, def2tzvp, d3bj, grid],
+            ecp=def2tzecp,
+        )
+
+        # Only SMD implemented
+        implicit_solvation_type = solv.smd
+
+    class G16:
+        # ---------------------------------------------------------------------
+        # Parameters for g16                   https://gaussian.com/gaussian16/
+        # ---------------------------------------------------------------------
+        #
+        # path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        ts_str = (
+            "Opt=(TS, CalcFC, NoEigenTest, MaxCycles=100, MaxStep=10, "
+            "NoTrustUpdate, RecalcFC=30)"
+        )
+
+        keywords = KeywordsSet(
+            low_opt=[pbe0, def2svp, "Opt=Loose", d3bj, MaxOptCycles(10)],
+            grad=[pbe0, def2svp, "Force(NoStep)", d3bj],
+            low_sp=[pbe0, def2svp, d3bj],
+            opt=[pbe0, def2svp, "Opt", d3bj],
+            opt_ts=[pbe0, def2svp, "Freq", d3bj, ts_str],
+            hess=[pbe0, def2svp, "Freq", d3bj],
+            sp=[pbe0, def2tzvp, d3bj],
+            ecp=def2tzecp,
+        )
+
+        # Only SMD implemented
+        implicit_solvation_type = solv.smd
+
+    class NWChem:
+        # ---------------------------------------------------------------------
+        # Parameters for nwchem    http://www.nwchem-sw.org/index.php/Main_Page
+        # ---------------------------------------------------------------------
+        #
+        # Path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        # Note that the default NWChem level is PBE0 and PBE rather than
+        # PBE0-D3BJ and PBE-D3BJ as only D3 is available. The optimisation
+        # keywords contain 'gradient' as the optimisation is driven by autodE
+        keywords = KeywordsSet(
+            low_opt=[def2svp, pbe0, MaxOptCycles(10), "task dft gradient"],
+            grad=[def2svp, pbe0, "task dft gradient"],
+            low_sp=[def2svp, pbe0, "task dft energy"],
+            opt=[def2svp, pbe0, MaxOptCycles(100), "task dft gradient"],
+            opt_ts=[def2svp, pbe0, MaxOptCycles(50), "task dft gradient"],
+            hess=[def2svp, pbe0, "task dft freq"],
+            sp=[def2tzvp, pbe0, "task dft energy"],
+            ecp=def2ecp,
+        )
+
+        # Only SMD implemented
+        implicit_solvation_type = solv.smd
+
+    class XTB:
+        # ---------------------------------------------------------------------
+        # Parameters for xtb                  https://github.com/grimme-lab/xtb
+        # ---------------------------------------------------------------------
+        #
+        # path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        keywords = KeywordsSet()
+        #
+        # Only GBSA implemented
+        implicit_solvation_type = solv.gbsa
+        #
+        # Force constant used for harmonic restraints in constrained
+        # optimisations (Ha/a0)
+        force_constant = 2
+        #
+        # Electronic temperature for all calculations (Kelvin)
+        # None means unset (default), set to 300.0 to have 300K for example
+        electronic_temp = None
+        #
+        # Version of xTB hamiltonian parameterisation: 0,1 or 2
+        # corresponding to GFN0-xTB, GFN1-xTB, GFN2-xTB respectively
+        # When unset, uses the default
+        gfn_version = None
+
+    class MOPAC:
+        # ---------------------------------------------------------------------
+        # Parameters for mopac                             http://openmopac.net
+        # ---------------------------------------------------------------------
+        #
+        # path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        # Note: all optimisations at this low level will be in the gas phase
+        # using the keywords_list specified here. Solvent in mopac is defined
+        # by EPS and the dielectric
+        keywords = KeywordsSet(low_opt=["PM7", "PRECISE"])
+        #
+        # Only COSMO implemented
+        implicit_solvation_type = solv.cosmo
+
+    class QChem:
+        # ---------------------------------------------------------------------
+        # Parameters for QChem                          https://www.q-chem.com/
+        # ---------------------------------------------------------------------
+        #
+        # path can be unset and will be assigned if it can be found in $PATH
+        path = None
+        #
+        # Default set of keywords to use for different types of calculation
+        keywords = KeywordsSet(
+            low_opt=[pbe0, def2svp, "jobtype opt", MaxOptCycles(10), d3bj],
+            grad=[pbe0, def2svp, "jobtype force", d3bj],
+            low_sp=[pbe0, def2svp, d3bj],
+            opt=[pbe0, def2svp, "jobtype opt", d3bj],
+            opt_ts=[pbe0, def2svp, "jobtype TS", d3bj],
+            hess=[pbe0, def2svp, "jobtype Freq", d3bj],
+            sp=[pbe0, def2tzvp, d3bj],
+            ecp=def2ecp,
+        )
+
+        #
+        # Only SMD is implemented
+        implicit_solvation_type = solv.smd
+
+    # =========================================================================
+    # =============               End                        ==================
+    # =========================================================================
+
+    def __setattr__(self, key, value):
+        """Custom setters"""
+
+        if not hasattr(self, key):
+            raise KeyError(f"Cannot set {key}. Not present in ade.Config")
+
+        if key == "max_core":
+            value = Allocation(value).to("MB")
+
+        if key == "freq_scale_factor":
+            if value is not None:
+                if not (0.0 < value <= 1.0):
+                    raise ValueError(
+                        "Cannot set the frequency scale factor "
+                        "outside of (0, 1]"
+                    )
+
+                value = float(value)
+
+        if key in ("max_atom_displacement", "min_step_size", "max_step_size"):
+            if float(value) < 0:
+                raise ValueError(f"Distances cannot be negative. Had: {value}")
+
+            value = Distance(value).to("ang")
+
+        return super().__setattr__(key, value)
+
+
+def _instantiate_config_opts(cls: type) -> Any:
+    """
+    Instantiate a config class containing options defined
+    as class variables. It generates an instance of the
+    class, and then creates instance variables of the same
+    name as class variables, recursively converting any
+    nested class into instances.
+    (This is required because class variables are not pickled,
+    only instance variables are)
+
+    Args:
+        cls (type): Must be a class containing class
+         variables (not instance)
+
+    Returns:
+        (Any): The generated class instance
+    """
+    if not isinstance(cls, type):
+        raise ValueError("Must be a class, not an instance")
+    cls_instance = cls()
+    for name, attr in cls.__dict__.items():
+        if name.startswith("__"):
+            continue
+        if isinstance(attr, type):
+            attr_val = _instantiate_config_opts(attr)  # recursive
+        else:
+            attr_val = attr
+        setattr(cls_instance, name, attr_val)
+    return cls_instance
+
+
+# Single instance of the configuration
+Config = _instantiate_config_opts(_ConfigClass)

autodE/source/autode/conformers/__init__.py

@@ -0,0 +1,4 @@
+from autode.conformers.conformer import Conformer
+from autode.conformers.conformers import Conformers
+
+__all__ = ["Conformer", "Conformers"]

autodE/source/autode/conformers/cconf_gen.pyx

@@ -0,0 +1,131 @@
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: cdivision=True
+from cpython.array cimport array, clone
+from libc.math cimport sqrt, pow
+import numpy as np
+
+
+cdef calc_energy(int n_atoms, array coords, int[:, :] bond_matrix, double k, double[:, :] d0, double c,
+                 int exponent):
+
+    cdef int i, j
+    cdef double delta_x = 0.0
+    cdef double delta_y = 0.0
+    cdef double delta_z = 0.0
+
+    cdef double d = 0.0
+    cdef double repulsion = 0.0
+    cdef double bonded = 0.0
+
+    cdef double energy = 0.0
+
+
+    for i in range(n_atoms):
+        for j in range(n_atoms):
+            if i > j:
+                delta_x = coords.data.as_doubles[3*j] - coords.data.as_doubles[3*i]
+                delta_y = coords.data.as_doubles[3*j+1] - coords.data.as_doubles[3*i+1]
+                delta_z = coords.data.as_doubles[3*j+2] - coords.data.as_doubles[3*i+2]
+                d = sqrt(delta_x*delta_x + delta_y*delta_y + delta_z*delta_z)
+
+                energy += c / pow(d, exponent)
+
+                if bond_matrix[i][j] == 1:
+                    energy += k * pow((d - d0[i][j]), 2)
+
+                if bond_matrix[i][j] == 2:
+                    energy += 10 * pow((d - d0[i][j]), 2)
+    return energy
+
+cdef calc_deriv(int n_atoms, array deriv, array coords, int[:, :] bond_matrix,
+                double k, double[:, :] d0, double c, int exponent):
+
+    cdef int i, j
+    cdef double delta_x
+    cdef double delta_y
+    cdef double delta_z
+
+    cdef double d
+    cdef double repulsion
+    cdef double bonded
+    cdef double fixed
+
+    exponent_minus_2 = exponent + 2
+
+    for i in range(n_atoms):
+        for j in range(n_atoms):
+            if i != j:
+                delta_x = coords.data.as_doubles[3*j] - coords.data.as_doubles[3*i]
+                delta_y = coords.data.as_doubles[3*j+1] - coords.data.as_doubles[3*i+1]
+                delta_z = coords.data.as_doubles[3*j+2] - coords.data.as_doubles[3*i+2]
+                d = sqrt(delta_x*delta_x + delta_y*delta_y + delta_z*delta_z)
+
+                repulsion = -exponent * c / pow(d, exponent_minus_2)
+                deriv.data.as_doubles[3*i] += repulsion * delta_x
+                deriv.data.as_doubles[3*i+1] += repulsion * delta_y
+                deriv.data.as_doubles[3*i+2] += repulsion * delta_z
+
+                if bond_matrix[i][j] == 1:
+                    bonded = 2.0 * k * (1.0 - d0[i][j]/d)
+                    deriv.data.as_doubles[3*i] += bonded * delta_x
+                    deriv.data.as_doubles[3*i+1] += bonded * delta_y
+                    deriv.data.as_doubles[3*i+2] += bonded * delta_z
+
+                if bond_matrix[i][j] == 2:
+                    fixed = 20.0 * (1.0 - d0[i][j]/d)
+                    deriv.data.as_doubles[3*i] += fixed * delta_x
+                    deriv.data.as_doubles[3*i+1] += fixed * delta_y
+                    deriv.data.as_doubles[3*i+2] += fixed * delta_z
+
+    return -np.array(deriv)
+
+
+def dvdr(py_flat_coords, py_bond_matrix, py_k, py_d0, py_c, py_exponent,
+         py_fixed_atoms):
+
+    py_n_atoms = int(len(py_flat_coords) / 3)
+    cdef int n_atoms = py_n_atoms
+    cdef int[:, :] bond_matrix = py_bond_matrix
+    cdef double k = py_k
+    cdef double[:, :] d0 = py_d0
+    cdef double c = py_c
+    cdef int i
+    cdef exponent = py_exponent
+
+    cdef array coords, template = array('d')
+    coords = clone(template, 3*n_atoms, False)
+    init_array = clone(template, 3*n_atoms, False)
+
+    # Initalise arrays
+    for i in range(3*n_atoms):
+        init_array[i] = 0.0
+        coords[i] = py_flat_coords[i]
+
+    dvdr = calc_deriv(n_atoms, init_array, coords, bond_matrix, k, d0, c, exponent)
+
+    # Zero the gradients for all the fixed atoms
+    dvdr = dvdr.reshape(-1, 3)
+    dvdr[py_fixed_atoms, :] = 0.0
+
+    return dvdr.flatten()
+
+
+def v(py_flat_coords, py_bond_matrix, py_k, py_d0, py_c, py_exponent, *args):
+
+    py_n_atoms = int(len(py_flat_coords) / 3)
+    cdef int n_atoms = py_n_atoms
+    cdef int[:, :] bond_matrix = py_bond_matrix
+    cdef double k = py_k
+    cdef double[:, :] d0 = py_d0
+    cdef double c = py_c
+    cdef exponent = py_exponent
+
+    cdef array coords, template = array('d')
+    coords = clone(template, 3*n_atoms, False)
+
+    cdef int i
+    for i in range(3*n_atoms):
+        coords[i] = py_flat_coords[i]
+
+    return calc_energy(n_atoms, coords, bond_matrix, k, d0, c, exponent)

autodE/source/autode/conformers/conf_gen.py

@@ -0,0 +1,537 @@
+import os
+import numpy as np
+import autode as ade
+from copy import deepcopy
+from typing import Dict, Optional, TYPE_CHECKING
+from itertools import combinations
+from scipy.optimize import minimize
+
+from autode.conformers import Conformer
+import autode.exceptions as ex
+from autode.utils import log_time
+from autode.input_output import xyz_file_to_atoms, atoms_to_xyz_file
+from autode.mol_graphs import split_mol_across_bond
+from autode.log import logger
+
+if TYPE_CHECKING:
+    from autode.species.species import Species
+    from autode.wrappers.keywords import Keywords
+    from autode.wrappers.methods import Method
+
+
+def _get_bond_matrix(n_atoms, bonds, fixed_bonds):
+    """
+    Populate a bond matrix with 1 if i, j are bonded, 2 if i, j are bonded and
+    fixed and 0 otherwise. Can support a partial structure with bonds to atoms
+    that don't (yet) exist.
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        n_atoms (int):
+        bonds (list(tuple)):
+        fixed_bonds (list(tuple)):
+
+    Returns:
+        (np.ndarray): Bond matrix, shape = (n_atoms, n_atoms)
+    """
+    bond_matrix = np.zeros((n_atoms, n_atoms), dtype=np.intc)
+
+    for i, j in bonds:
+        if i < n_atoms and j < n_atoms:
+            bond_matrix[i, j] = 1
+            bond_matrix[j, i] = 1
+    for i, j in fixed_bonds:
+        if i < n_atoms and j < n_atoms:
+            bond_matrix[i, j] = 2
+            bond_matrix[j, i] = 2
+
+    return bond_matrix
+
+
+def _get_coords_energy(
+    coords, bonds, k, c, d0, tol, fixed_bonds, exponent=8, fixed_idxs=None
+):
+    """
+    Get the coordinates that minimise a FF with a bonds + repulsion FF
+    where the repulsion is c/r^exponent
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        coords (np.ndarray): Initial coordinates, shape = (n_atoms, 3)
+        bonds (list(tuple(int))): List of bonds
+        fixed_bonds (list(tuple(int))): List of constrained bonds will use 10k
+                    as the harmonic force constant
+        k (float):
+        c (float):
+
+    Keyword Arguments:
+        exponent (int): Exponent in the repulsive pairwise term
+
+    Returns:
+        (np.ndarray): Optimised coordinates, shape = (n_atoms, 3)
+    """
+    # TODO divide and conquer?
+    from cconf_gen import v
+    from cconf_gen import dvdr
+
+    n_atoms = len(coords)
+    os.environ["OMP_NUM_THREADS"] = str(1)
+
+    bond_matrix = _get_bond_matrix(
+        n_atoms=len(coords), bonds=bonds, fixed_bonds=fixed_bonds
+    )
+
+    if fixed_idxs is None:
+        fixed_idxs = np.array([], dtype=int)
+
+    res = minimize(
+        v,
+        x0=coords.reshape(3 * n_atoms),
+        args=(bond_matrix, k, d0, c, exponent, fixed_idxs),
+        method="CG",
+        tol=tol,
+        jac=dvdr,
+    )
+
+    return res.x.reshape(n_atoms, 3), res.fun
+
+
+def _get_v(coords, bonds, k, c, d0, fixed_bonds, exponent=8):
+    """Get the energy using a bond + repulsion FF where
+
+    V(r) = Σ_bonds k(d - d0)^2 + Σ_ij c/d^exponent
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        coords (np.ndarray): shape = (n_atoms, 3)
+        bonds (list(tuple(int))): List of bonds
+        fixed_bonds (list(tuple(int))): List of constrained bonds will use 10k
+                    as the harmonic force constant
+        k (float):
+        c (float):
+        exponent (int): Exponent in the repulsive pairwise term
+
+    Returns:
+        (float): Energy
+    """
+    from cconf_gen import v
+
+    n_atoms = len(coords)
+    os.environ["OMP_NUM_THREADS"] = str(1)
+
+    init_coords = coords.reshape(3 * n_atoms)
+    bond_matrix = _get_bond_matrix(
+        n_atoms=n_atoms, bonds=bonds, fixed_bonds=fixed_bonds
+    )
+
+    return v(init_coords, bond_matrix, k, d0, c, exponent)
+
+
+def _get_atoms_rotated_stereocentres(species, atoms, rand):
+    """If two stereocentres are bonded, rotate them randomly with respect
+    to each other
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        species (autode.species.Species):
+        atoms (list(autode.atoms.Atom)):
+        rand (np.RandomState): random state
+
+    Returns:
+        (list(autode.atoms.Atom)): Atoms
+    """
+
+    stereocentres = [
+        node
+        for node in species.graph.nodes
+        if species.graph.nodes[node]["stereo"] is True
+    ]
+
+    # Check on every pair of stereocenters
+    for i, j in combinations(stereocentres, 2):
+        if (i, j) not in species.graph.edges:
+            continue
+
+        # Don't rotate if the bond connecting the centers is a π-bond
+        if species.graph.edges[i, j]["pi"] is True:
+            logger.info("Stereocenters were π bonded – not rotating")
+            continue
+
+        try:
+            left_idxs, right_idxs = split_mol_across_bond(
+                species.graph, bond=(i, j)
+            )
+
+        except ex.CannotSplitAcrossBond:
+            logger.warning(
+                "Splitting across this bond does not give two "
+                "components - could have a ring"
+            )
+            return atoms
+
+        # Rotate the left hand side randomly
+        rot_axis = atoms[i].coord - atoms[j].coord
+        theta = 2 * np.pi * rand.rand()
+        idxs_to_rotate = left_idxs if i in left_idxs else right_idxs
+
+        # Rotate all the atoms to the left of this bond, missing out i as that
+        # is the origin for rotation and thus won't move
+        for n in idxs_to_rotate:
+            if n == i:
+                continue
+            atoms[n].rotate(axis=rot_axis, theta=theta, origin=atoms[i].coord)
+
+    return atoms
+
+
+def _add_dist_consts_for_stereocentres(species, dist_consts):
+    """
+    Add distances constraints across two bonded stereocentres, for example
+    for a Z alkene, (hopefully) ensuring that in the conformer generation the
+    stereochemistry is retained. Will also add distance constraints from
+    one nearest neighbour to the other nearest neighbours for that chiral
+    centre
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        species (autode.species.Species):
+        dist_consts (dict): keyed with tuple of atom indexes and valued with
+                    the distance (Å), or None
+
+    Returns:
+        (dict): Distance constraints
+    """
+    if not ade.geom.are_coords_reasonable(coords=species.coordinates):
+        # TODO generate a reasonable initial structure: molassembler?
+        logger.error(
+            "Cannot constrain stereochemistry if the initial "
+            "structure is not sensible"
+        )
+        return dist_consts
+
+    stereocentres = [
+        node
+        for node in species.graph.nodes
+        if species.graph.nodes[node]["stereo"] is True
+    ]
+
+    # Get the stereocentres with 4 bonds as ~ chiral centres
+    chiral_centres = [
+        centre
+        for centre in stereocentres
+        if len(list(species.graph.neighbors(centre))) == 4
+    ]
+
+    # Add distance constraints from one atom to the other 3 atoms to fix the
+    # configuration
+    for chiral_centre in chiral_centres:
+        neighbors = list(species.graph.neighbors(chiral_centre))
+        atom_i = neighbors[0]
+
+        for atom_j in neighbors[1:]:
+            dist_consts[(atom_i, atom_j)] = species.distance(atom_i, atom_j)
+
+    # Check on every pair of stereocenters
+    for atom_i, atom_j in combinations(stereocentres, 2):
+        # If they are not bonded don't alter
+        if (atom_i, atom_j) not in species.graph.edges:
+            continue
+
+        # Add a single distance constraint between the nearest neighbours of
+        # each stereocentre
+        for i_neighbour in species.graph.neighbors(atom_i):
+            for j_neighbour in species.graph.neighbors(atom_j):
+                if i_neighbour != atom_j and j_neighbour != atom_i:
+                    # Fix the distance to the current value
+                    dist = species.distance(i_neighbour, j_neighbour)
+                    dist_consts[(i_neighbour, j_neighbour)] = dist
+
+    logger.info(f"Have {len(dist_consts)} distance constraint(s)")
+    return dist_consts
+
+
+def _get_non_random_atoms(species):
+    """
+    Get the atoms that won't be randomised in the conformer generation.
+    Stereocentres and nearest neighbours
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        species (autode.species.Species):
+
+    Returns:
+        (set(int)): Atoms indexes to not randomise
+    """
+    stereocentres = [
+        node
+        for node in species.graph.nodes
+        if species.graph.nodes[node]["stereo"] is True
+    ]
+
+    non_rand_atoms = deepcopy(stereocentres)
+    for stereocentre in stereocentres:
+        non_rand_atoms += list(species.graph.neighbors(stereocentre))
+
+    if len(non_rand_atoms) > 0:
+        logger.info(f"Not randomising atom index(es) {set(non_rand_atoms)}")
+
+    return np.array(list(set(non_rand_atoms)), dtype=int)
+
+
+def _get_atoms_from_generated_file(species, xyz_filename):
+    """
+    Get atoms from a previously generated  .xyz file, if the atoms match
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        species (autode.species.Species):
+        xyz_filename (str):
+
+    Returns:
+        (list(autode.atoms.Atoms)) or None: Atoms from file
+    """
+
+    if not os.path.exists(xyz_filename):
+        return None
+
+    atoms = xyz_file_to_atoms(filename=xyz_filename)
+
+    if len(atoms) != species.n_atoms:
+        return None
+
+    all_atoms_match = all(
+        atoms[i].label == species.atoms[i].label
+        for i in range(species.n_atoms)
+    )
+
+    if all_atoms_match:
+        logger.info("Conformer has already been generated")
+        return atoms
+
+    return None
+
+
+def _get_coords_no_init_structure(atoms, species, d0, constrained_bonds):
+    """
+    Generate coordinates where no initial structure is present - this fixes(?)
+     a problem for large molecule where if all the atoms are initially bonded
+     and minimised then high energy minima are often found
+
+    Args:
+        atoms (list(autode.atoms.Atom)):
+        species (autode.species.Species):
+        d0 (np.ndarray):
+        constrained_bonds (list):
+
+    Returns:
+        (np.ndarray): Optimised coordinates, shape = (n_atoms, 3)
+    """
+    # Minimise atoms with no bonds between them
+    far_coords, _ = _get_coords_energy(
+        coords=np.array([atom.coord for atom in atoms]),
+        bonds=species.graph.edges,
+        fixed_bonds=constrained_bonds,
+        k=0.0,
+        c=0.1,
+        d0=d0,
+        tol=5e-3,
+        exponent=2,
+    )
+    coords = far_coords[:2]
+
+    # Add the atoms one by one to the structure. Thanks to Dr. Cyrille Lavigne
+    #  for this suggestion!
+    for n in range(2, species.n_atoms):
+        new_coords = np.concatenate((coords, far_coords[len(coords) : n + 1]))
+        coords, _ = _get_coords_energy(
+            new_coords,
+            bonds=species.graph.edges,
+            fixed_bonds=constrained_bonds,
+            k=0.1,
+            c=0.1,
+            d0=d0,
+            tol=1e-3,
+            exponent=2,
+        )
+
+    # Perform a final minimisation
+    coords, energy = _get_coords_energy(
+        coords=coords,
+        bonds=species.graph.edges,
+        fixed_bonds=constrained_bonds,
+        k=1.0,
+        c=0.01,
+        d0=d0,
+        tol=1e-5,
+    )
+    return coords, energy
+
+
+@log_time(prefix="Generated RR atoms in:", units="s")
+def get_simanl_atoms(
+    species: "Species",
+    dist_consts: Optional[Dict] = None,
+    conf_n: int = 0,
+    save_xyz: bool = True,
+    also_return_energy: bool = False,
+):
+    r"""
+    Use a bonded + repulsive force field to generate 3D structure for a
+    species. If the initial coordinates are reasonable e.g. from a previously
+    generated 3D structure then add random displacement vectors and minimise
+    to generate a conformer. Otherwise add atoms to the box sequentially
+    until all atoms have been added, which generates a qualitatively reasonable
+    3D geometry which should be optimised using a electronic structure method::
+
+        V(x) = Σ_bonds k(d - d0)^2 + Σ_ij c/d^n
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        species (autode.species.Species):
+
+        dist_consts (dict): Key = tuple of atom indexes, Value = distance
+
+        conf_n (int): Number of this conformer
+
+        save_xyz (bool): Whether or not to save a .xyz file of the structure
+                         for fast reloading
+
+        also_return_energy (bool): Whether or not to return the energy
+
+    Returns:
+        (list(autode.atoms.Atom)): Atoms
+    """
+    xyz_filename = f"{species.name}_conf{conf_n}_siman.xyz"
+
+    saved_atoms = _get_atoms_from_generated_file(species, xyz_filename)
+    if saved_atoms is not None and not also_return_energy:
+        return saved_atoms
+
+    # To generate the potential requires bonds between atoms defined in a
+    # molecular graph
+    if species.graph is None:
+        raise ex.NoMolecularGraph
+
+    # Initialise a new random seed and make a copy of the species' atoms.
+    # RandomState is thread safe
+    rand = np.random.RandomState()
+    atoms = _get_atoms_rotated_stereocentres(
+        species=species, atoms=deepcopy(species.atoms), rand=rand
+    )
+
+    # Add the distance constraints as fixed bonds
+    d0 = species.graph.eqm_bond_distance_matrix
+
+    # Add distance constraints across stereocentres e.g. for a Z double bond
+    # then modify d0 appropriately
+    curr_dist_consts = {} if dist_consts is None else dist_consts
+    distance_constraints = _add_dist_consts_for_stereocentres(
+        species=species, dist_consts=curr_dist_consts
+    )
+
+    constrained_bonds = []
+    for bond, length in distance_constraints.items():
+        i, j = bond
+        d0[i, j] = length
+        d0[j, i] = length
+        constrained_bonds.append(bond)
+
+    # Randomise coordinates that aren't fixed by shifting a maximum of
+    # autode.Config.max_atom_displacement in x, y, z
+    fixed_atom_indexes = _get_non_random_atoms(species=species)
+
+    # Shift by a factor defined in the config file if the coordinates are
+    # reasonable but otherwise init in a 10 A cube
+    reasonable_init_coords = ade.geom.are_coords_reasonable(
+        species.coordinates
+    )
+
+    if reasonable_init_coords:
+        factor = ade.Config.max_atom_displacement / np.sqrt(3)
+        for i, atom in enumerate(atoms):
+            if i not in fixed_atom_indexes:
+                atom.translate(vec=factor * rand.uniform(-1, 1, 3))
+    else:
+        # Randomise in a 10 Å cubic box
+        [atom.translate(vec=rand.uniform(-5, 5, 3)) for atom in atoms]
+
+    if reasonable_init_coords:
+        init_coords = np.array([atom.coord for atom in atoms])
+        coords, energy = _get_coords_energy(
+            coords=init_coords,
+            bonds=species.graph.edges,
+            k=1.0,
+            c=0.01,
+            d0=d0,
+            tol=1e-5,
+            fixed_idxs=fixed_atom_indexes,
+            fixed_bonds=constrained_bonds,
+        )
+    else:
+        coords, energy = _get_coords_no_init_structure(
+            atoms, species, d0, constrained_bonds
+        )
+
+    # Set the coordinates of the new atoms
+    for i, atom in enumerate(atoms):
+        atom.coord = coords[i]
+
+    # Print an xyz file so rerunning will read the file
+    if save_xyz:
+        atoms_to_xyz_file(atoms=atoms, filename=xyz_filename)
+
+    if also_return_energy:
+        logger.info(f"E_RR = {energy:.6f}")
+        return atoms, energy
+
+    return atoms
+
+
+def get_simanl_conformer(
+    species: "Species",
+    dist_consts: Optional[Dict] = None,
+    conf_n: int = 0,
+    save_xyz: bool = True,
+) -> "Conformer":
+    """
+    Generate a conformer of a species using randomise+relax with a simple FF
+    (see get_simanl_atoms). Example
+
+    .. code-block:: Python
+        >>> import autode as ade
+        >>> from autode.conformers.conf_gen import get_simanl_conformer
+        >>> mol = ade.Molecule(smiles='CCCC', name='butane')
+        >>> conf0 = get_simanl_conformer(mol, conf_n=0, save_xyz=False)
+        Conformer(butane_conf0, n_atoms=14, charge=0, mult=1)
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        species (autode.species.Species):
+
+        dist_consts (dict): Key = tuple of atom indexes, Value = distance
+
+        conf_n (int): Number of this conformer
+
+        save_xyz (bool): Whether or not to save a .xyz file of the structure
+
+    Returns:
+        (autode.conformers.Conformer): Conformer
+    """
+
+    conformer = Conformer(
+        species=species,
+        name=f"{species.name}_conf{conf_n}",
+        dist_consts=dist_consts,
+    )
+
+    atoms, energy = get_simanl_atoms(
+        species,
+        dist_consts=dist_consts,
+        conf_n=conf_n,
+        save_xyz=save_xyz,
+        also_return_energy=True,
+    )
+    conformer.atoms = atoms
+    conformer.energy = energy
+
+    return conformer

autodE/source/autode/conformers/conformer.py

@@ -0,0 +1,184 @@
+import numpy as np
+
+from typing import Optional, TYPE_CHECKING
+
+from autode.atoms import Atoms
+from autode.values import Coordinates
+from autode.exceptions import AtomsNotFound
+from autode.log import logger
+from autode.species.species import Species
+
+if TYPE_CHECKING:
+    from autode.calculations.calculation import Calculation
+    from autode.wrappers.methods import Method
+    from autode.wrappers.keywords import Keywords
+
+
+class Conformer(Species):
+    def __init__(
+        self,
+        name: str = "conf",
+        atoms: Optional["Atoms"] = None,
+        solvent_name: Optional[str] = None,
+        charge: int = 0,
+        mult: int = 1,
+        dist_consts: Optional[dict] = None,
+        species: Optional[Species] = None,
+    ):
+        """
+        Construct a conformer either using the standard species constructor,
+        or from a species directly.
+
+        -----------------------------------------------------------------------
+        See Also:
+            (autode.species.species.Species):
+        """
+        super().__init__(name, atoms, charge, mult, solvent_name=solvent_name)
+        self._parent_atoms = None
+        self._coordinates = None
+
+        if species is not None:
+            self._parent_atoms = species.atoms
+            self._coordinates = species.coordinates.copy()
+            self.charge = species.charge  # Require identical charge/mult/solv
+            self.mult = species.mult
+            self.solvent = species.solvent
+
+        if atoms is not None:  # Specified atoms overrides species
+            self.atoms = Atoms(atoms)
+
+        self.constraints.update(distance=dist_consts)
+
+    def __repr__(self):
+        """Representation of a conformer"""
+        return self._repr(prefix="Conformer")
+
+    def __eq__(self, other):
+        return super().__eq__(other)
+
+    def single_point(
+        self,
+        method: "Method",
+        keywords: Optional["Keywords"] = None,
+        n_cores: Optional[int] = None,
+    ):
+        """
+        Calculate a single point and default to a low level single point method
+
+        ----------------------------------------------------------------------
+        Arguments:
+            method (autode.wrappers.base.ElectronicStructureMethod):
+
+            keywords (autode.wrappers.keywords.Keywords):
+
+            n_cores (int | None): If None then defaults to Config.n_cores
+        """
+        keywords = method.keywords.low_sp if keywords is None else keywords
+
+        return super().single_point(method, keywords, n_cores=n_cores)
+
+    def optimise(
+        self,
+        method: Optional["Method"] = None,
+        reset_graph: bool = False,
+        calc: Optional["Calculation"] = None,
+        keywords: Optional["Keywords"] = None,
+        n_cores: Optional[int] = None,
+    ):
+        """
+        Optimise the geometry of this conformer using a method. Will use
+        low_opt keywords if no keywords are given.
+
+        -----------------------------------------------------------------------
+        Arguments:
+            method (autode.wrappers.base.ElectronicStructureMethod):
+
+            reset_graph (bool):
+
+            calc (autode.calculation.Calculation):
+
+            keywords (autode.wrappers.keywords.Keywords):
+
+            n_cores (int | None): If None then defaults to Config.n_cores
+        """
+        try:
+            if keywords is None and method is not None:
+                keywords = method.keywords.low_opt
+
+            super().optimise(
+                method, keywords=keywords, calc=calc, n_cores=n_cores
+            )
+
+        except AtomsNotFound:
+            logger.error(f"Atoms not found for {self.name} but not critical")
+            self.atoms = None
+
+        return None
+
+    @property
+    def coordinates(self) -> Optional[Coordinates]:
+        """Coordinates of this conformer"""
+        return self._coordinates
+
+    @coordinates.setter
+    def coordinates(self, value: np.ndarray):
+        """Set the coordinates of this conformer"""
+        if self._parent_atoms is None:
+            raise ValueError(
+                "Conformer has no parent atoms. Setting the "
+                "coordinates will leave the atoms undefined"
+            )
+
+        self._coordinates = Coordinates(value)
+
+    @property
+    def atoms(self) -> Optional[Atoms]:
+        """
+        Atoms of this conformer are built from the parent atoms and the
+        coordinates that are unique to this conformer.
+        """
+
+        if self._parent_atoms is None or self._coordinates is None:
+            return None
+
+        atoms = Atoms()
+        for parent_atom, coord in zip(self._parent_atoms, self._coordinates):
+            atom = parent_atom.copy()
+            atom.coord = coord
+
+            atoms.append(atom)
+
+        return atoms
+
+    @atoms.setter
+    def atoms(self, value: Optional[Atoms]):
+        """
+        Set the atoms of this conformer.
+
+        If None then set the corresponding coordinates of this conformer to
+        None (such that self.atoms is None). If this conformer has coordinates
+        then set those from the individual atomic coordinates otherwise
+        set the coordinates as a batch
+        """
+
+        if value is None:  # Clear the coordinates
+            self._coordinates = None
+            return
+
+        if self._parent_atoms is None:
+            self._parent_atoms = value
+
+        if self._coordinates is None:
+            self._coordinates = value.coordinates
+            return
+
+        for i, atom in enumerate(value):
+            parent_atom = self._parent_atoms[i]
+            if atom.label != parent_atom.label:
+                raise ValueError(
+                    "Cannot alter the atomic symbols of a "
+                    "conformer. Parent molecule was different: "
+                    f"{atom.label} != {parent_atom.label}"
+                )
+
+            self._coordinates[i] = atom.coord.copy()

autodE/source/autode/conformers/conformers.py

@@ -0,0 +1,360 @@
+import numpy as np
+
+from typing import Optional, Union, TYPE_CHECKING
+from rdkit import Chem
+
+from autode.values import Distance, Energy
+from autode.atoms import Atom, Atoms
+from autode.config import Config
+from autode.mol_graphs import make_graph, is_isomorphic
+from autode.geom import calc_heavy_atom_rmsd
+from autode.log import logger
+from autode.utils import ProcessPool
+from autode.exceptions import NoConformers, CouldNotGetProperty
+
+
+if TYPE_CHECKING:
+    from autode.conformers.conformer import Conformer
+    from autode.wrappers.methods import Method
+    from autode.mol_graphs import MolecularGraph
+    from autode.wrappers.keywords import Keywords
+
+
+def _calc_conformer(conformer, calc_type, method, keywords, n_cores=1):
+    """Top-level hashable function to call in parallel"""
+    func = getattr(conformer, calc_type)
+    try:
+        func(method=method, keywords=keywords, n_cores=n_cores)
+    except CouldNotGetProperty as e:
+        logger.warning(
+            f"Failed to run calculation on conformer {conformer.name} due to {e}"
+        )
+
+    return conformer
+
+
+class Conformers(list):
+    @property
+    def lowest_energy(self) -> Optional["Conformer"]:
+        """
+        Return the lowest energy conformer state from this set. If no
+        conformers have an energy then return None
+
+        -----------------------------------------------------------------------
+        Returns:
+            (autode.conformers.Conformer | None): Conformer
+        """
+        if all(c.energy is None for c in self):
+            logger.error("Have no conformers with an energy, so no lowest")
+            return None
+
+        energies = [c.energy if c.energy is not None else np.inf for c in self]
+        return self[np.argmin(energies)]
+
+    def prune(
+        self,
+        e_tol: Union[Energy, float] = Energy(1.0, "kJ mol-1"),
+        rmsd_tol: Union[Distance, float, None] = None,
+        n_sigma: float = 5,
+        remove_no_energy: bool = False,
+    ) -> None:
+        """
+        Prune conformers based on both energy and root mean squared deviation
+        (RMSD) values. Will discard any conformers that are within e_tol in
+        energy (Ha) and rmsd in RMSD (Å) to any other
+
+        -----------------------------------------------------------------------
+        Arguments:
+            e_tol (Energy): Energy tolerance
+
+            rmsd_tol (Distance | None): RMSD tolerance. Defaults to
+                                        autode.Config.rmsd_threshold
+
+            n_sigma (float | int):
+
+            remove_no_energy (bool):
+        """
+
+        if remove_no_energy:
+            self.remove_no_energy()
+
+        self.prune_on_energy(e_tol=e_tol, n_sigma=n_sigma)
+        self.prune_on_rmsd(rmsd_tol=rmsd_tol)
+
+        return None
+
+    def prune_on_energy(
+        self,
+        e_tol: Union[Energy, float] = Energy(1.0, "kJ mol-1"),
+        n_sigma: float = 5,
+    ) -> None:
+        """
+        Prune the conformers based on an energy threshold, discarding those
+        that have energies that are similar to within e_tol. Also discards
+        conformers with very high energies (indicating a problem
+        with the calculation) if the are more than n_sigma standard deviations
+        away from the mean
+
+        -----------------------------------------------------------------------
+        Arguments:
+            e_tol (autode.values.Energy | float | None):
+
+            n_sigma (int): Number of standard deviations a conformer energy
+                   must be from the average for it not to be added
+        """
+        idxs_with_energy = [
+            idx for idx, conf in enumerate(self) if conf.energy is not None
+        ]
+        n_prev_confs = len(self)
+
+        if len(idxs_with_energy) < 2:
+            logger.info(
+                f"Only have {len(self)} conformers with an energy. No "
+                f"need to prune"
+            )
+            return None
+
+        energies = [self[idx].energy for idx in idxs_with_energy]
+
+        # Use a lower-bounded σ to prevent division by zero
+        std_dev_e = max(float(np.std(energies)), 1e-8)
+        avg_e = np.average(energies)
+
+        logger.info(
+            f"Have {len(energies)} energies with μ={avg_e:.6f} Ha "
+            f"σ={std_dev_e:.6f} Ha"
+        )
+
+        if isinstance(e_tol, Energy):
+            e_tol = float(e_tol.to("Ha"))
+        else:
+            logger.warning(
+                f"Assuming energy tolerance {e_tol:.6f} has units " f"of Ha"
+            )
+
+        # Delete from the end of the list to preserve the order when deleting
+        for i, idx in enumerate(reversed(idxs_with_energy)):
+            conf = self[idx]
+            idxs_with_energy = [j for j in idxs_with_energy if j < len(self)]
+
+            if np.abs(conf.energy - avg_e) / std_dev_e > n_sigma:
+                logger.warning(
+                    f"Conformer {idx} had an energy >{n_sigma}σ "
+                    f"from the average - removing"
+                )
+                del self[idx]
+                continue
+
+            if i == 0:
+                # The first (last) conformer must be unique
+                continue
+
+            if any(
+                np.abs(conf.energy - self[o_idx].energy) < e_tol
+                for o_idx in idxs_with_energy
+                if o_idx != idx
+            ):
+                logger.info(f"Conformer {idx} had a non unique energy")
+                del self[idx]
+                continue
+
+        logger.info(
+            f"Stripped {n_prev_confs - len(self)} conformer(s)."
+            f" {n_prev_confs} -> {len(self)}"
+        )
+        return None
+
+    def prune_on_rmsd(
+        self, rmsd_tol: Union[Distance, float, None] = None
+    ) -> None:
+        """
+        Given a list of conformers add those that are unique based on an RMSD
+        tolerance. If rmsd=None then use autode.Config.rmsd_threshold
+
+        -----------------------------------------------------------------------
+        Arguments:
+            rmsd_tol (autode.values.Distance | float | None):
+        """
+        if len(self) < 2:
+            logger.info(
+                f"Only have {len(self)} conformers. No need to prune "
+                f"on RMSD"
+            )
+            return None
+
+        rmsd_tol = Config.rmsd_threshold if rmsd_tol is None else rmsd_tol
+
+        if isinstance(rmsd_tol, float):
+            logger.warning(
+                f"Assuming RMSD tolerance {rmsd_tol:.2f} has units" f" of Å"
+            )
+            rmsd_tol = Distance(rmsd_tol, "Å")
+
+        logger.info(
+            f'Removing conformers with RMSD < {rmsd_tol.to("ang")} Å '
+            f"to any other (heavy atoms only, with no symmetry)"
+        )
+
+        # Only enumerate up to but not including the final index, as at
+        # least one of the conformers must be unique in geometry
+        for idx in reversed(range(len(self) - 1)):
+            conf = self[idx]
+
+            if any(
+                calc_heavy_atom_rmsd(conf.atoms, other.atoms) < rmsd_tol
+                for o_idx, other in enumerate(self)
+                if o_idx != idx
+            ):
+                logger.info(
+                    f"Conformer {idx} was close in geometry to at "
+                    f"least one other - removing"
+                )
+
+                del self[idx]
+
+        logger.info(f"Pruned to {len(self)} unique conformer(s) on RMSD")
+        return None
+
+    def prune_diff_graph(self, graph: "MolecularGraph") -> None:
+        """
+        Remove conformers with a different molecular graph to a defined
+        reference. Although all conformers should have the same molecular
+        graph there are situations where not pruning these is useful
+
+        -----------------------------------------------------------------------
+
+        Arguments:
+            graph: Reference graph
+        """
+        n_prev_confs = len(self)
+
+        for idx in reversed(range(len(self))):
+            conformer = self[idx]
+            make_graph(conformer)
+
+            if not is_isomorphic(
+                conformer.graph, graph, ignore_active_bonds=True
+            ):
+                logger.warning("Conformer had a different graph. Ignoring")
+                del self[idx]
+
+        logger.info(f"Pruned on connectivity {n_prev_confs} -> {len(self)}")
+        return None
+
+    def remove_no_energy(self) -> None:
+        """Remove all conformers from this list that do not have an energy"""
+        n_conformers_before_remove = len(self)
+
+        for idx in reversed(range(len(self))):  # Enumerate backwards
+            if self[idx].energy is None:
+                del self[idx]
+
+        n_conformers = len(self)
+        if n_conformers == 0 and n_conformers != n_conformers_before_remove:
+            raise NoConformers(
+                f"Removed all the conformers "
+                f"{n_conformers_before_remove} -> 0"
+            )
+
+    def _parallel_calc(self, calc_type, method, keywords):
+        """
+        Run a set of calculations (single point energy evaluations or geometry
+        optimisations) in parallel over every conformer in this set. Will
+        attempt to use all autode.Config.n_cores as fully as possible
+
+        Arguments:
+            calc_type (str):
+
+            method (autode.wrappers.base.ElectronicStructureMethod):
+
+            keywords (autode.wrappers.keywords.Keywords):
+        """
+        # TODO: Test efficiency + improve with dynamic load balancing
+        if len(self) == 0:
+            logger.error(f"Cannot run {calc_type} over 0 conformers")
+            return None
+
+        n_cores_pp = max(Config.n_cores // len(self), 1)
+
+        with ProcessPool(max_workers=Config.n_cores // n_cores_pp) as pool:
+            jobs = [
+                pool.submit(
+                    _calc_conformer,
+                    conf,
+                    calc_type,
+                    method,
+                    keywords,
+                    n_cores=n_cores_pp,
+                )
+                for conf in self
+            ]
+
+            for idx, res in enumerate(jobs):
+                self[idx] = res.result()
+
+        return None
+
+    def optimise(
+        self,
+        method: "Method",
+        keywords: Optional["Keywords"] = None,
+    ) -> None:
+        """
+        Optimise a set of conformers in parallel
+
+        -----------------------------------------------------------------------
+        Arguments:
+            method (autode.wrappers.base.ElectronicStructureMethod):
+
+            keywords (autode.wrappers.keywords.Keywords):
+        """
+        return self._parallel_calc("optimise", method, keywords)
+
+    def single_point(
+        self,
+        method: "Method",
+        keywords: Optional["Keywords"] = None,
+    ) -> None:
+        """
+        Evaluate single point energies for a set of conformers in parallel
+
+        -----------------------------------------------------------------------
+        Arguments:
+            method (autode.wrappers.base.ElectronicStructureMethod):
+
+            keywords (autode.wrappers.keywords.Keywords):
+        """
+        return self._parallel_calc("single_point", method, keywords)
+
+    def copy(self) -> "Conformers":
+        return Conformers([conformer.copy() for conformer in self])
+
+
+def atoms_from_rdkit_mol(rdkit_mol_obj: Chem.Mol, conf_id: int = 0) -> Atoms:
+    """
+    Generate atoms for a conformer contained within an RDKit molecule object
+
+    ---------------------------------------------------------------------------
+    Arguments:
+        rdkit_mol_obj (rdkit.Chem.Mol): RDKit molecule
+
+        conf_id (int): Conformer id to convert to atoms
+
+    Returns:
+        (list(autode.atoms.Atom)): Atoms
+    """
+
+    mol_block_lines = Chem.MolToMolBlock(rdkit_mol_obj, confId=conf_id).split(
+        "\n"
+    )
+    mol_file_atoms = Atoms()
+
+    # Extract atoms from the mol block
+    for line in mol_block_lines:
+        split_line = line.split()
+
+        if len(split_line) == 16:
+            x, y, z, atom_label = split_line[:4]
+            mol_file_atoms.append(Atom(atom_label, x=x, y=y, z=z))
+
+    return mol_file_atoms