firecode 1.0.0__tar.gz → 1.1.1__tar.gz

{firecode-1.0.0 → firecode-1.1.1}/CHANGELOG.md

@@ -4,6 +4,20 @@
 <!-- - ... mep_relax> BETA
 - ... IMAGES kw, also implement it for neb>-->
 
+## FIRECODE 1.1.1 🔥 (January 2025)
+- Added pretty error traceback with rich.
+<!-- SMARTS Constraint class -->
+
+
+## FIRECODE 1.1.0 🔥 (December 24 2024)
+- Implemented planar angle and dihedral constraints in ensemble optimization (only intra-file, but also available in embedding runs). These are propagated to xtb, ASE-mediated calculators and PyTorch models, as well as to operators like mtd> (CREST). These constraints can be specified in new input lines that start with a blank space under the reference molecule line, with the syntax "i1 i2 i3 \[i4\] target(float)" (i.e. "0 1 2 3 90.0" for dihedrals or "0 1 2 0.0" for planar angles). For now, these constraints are enforced at every step (as capital letter constraints, but not associated to any letter).
+- Improved comments parsing: possible to comment in any input line (with "#", following a Pyhton-style syntax).
+- Tweaked similarity_refining maximum ensemble size thresholds to carry different pruning steps.
+- Turned off interactive ASE GUI specification of Sp3 atoms leaving groups for orbital building.
+
+## FIRECODE 1.0.1 🔥 (September 29 2024)
+- Minor bugfixes and printout clean-ups.
+
 ## FIRECODE 1.0.0 🔥 (July 5 2024)
 - Renamed project to better reflect the expanded functionality of the toolbox! 🔥
 - New Pruner class: simpler, more homogenized implementation of iterative subset pruning, sharing the same basic architecture across different similarity evaluation functions, with cached calls to the eval similarity function.

{firecode-1.0.0/firecode.egg-info → firecode-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: firecode
-Version: 1.0.0
+Version: 1.1.1
 Summary: Computational chemistry general purpose ensemble optimizer and transition state builder
 Home-page: https://www.github.com/ntampellini/firecode
 Author: Nicolò Tampellini
@@ -23,11 +23,14 @@ Requires-Dist: networkx==2.5.1
 Requires-Dist: ase==3.21.1
 Requires-Dist: sella==2.3.2
 Requires-Dist: scikit-learn==1.0.1
-Requires-Dist: numba==0.54.1
+Requires-Dist: numba==0.58.1
 Requires-Dist: prettytable==3.3.0
 Requires-Dist: typing-extensions==4.8.0
-Requires-Dist: llvmlite
+Requires-Dist: llvmlite==0.41.1
 Requires-Dist: importlib-metadata==7.0.1
+Requires-Dist: psutil==5.9.6
+Requires-Dist: setuptools==75.3.0
+Requires-Dist: rich
 
 ## FIRECODE: Filtering Refiner and Embedder for Conformationally Dense Ensembles.
 Ensemble optimizer. Systematic generation of multimolecular arrangements for mono/bi/trimolecular transition states. Numerous utilities for conformational exploration, selection, pruning and constrained ensemble optimization.
@@ -38,6 +41,20 @@ Ensemble optimizer. Systematic generation of multimolecular arrangements for mon
 <!-- - ... mep_relax> BETA
 - ... IMAGES kw, also implement it for neb>-->
 
+## FIRECODE 1.1.1 🔥 (January 2025)
+- Added pretty error traceback with rich.
+<!-- SMARTS Constraint class -->
+
+
+## FIRECODE 1.1.0 🔥 (December 24 2024)
+- Implemented planar angle and dihedral constraints in ensemble optimization (only intra-file, but also available in embedding runs). These are propagated to xtb, ASE-mediated calculators and PyTorch models, as well as to operators like mtd> (CREST). These constraints can be specified in new input lines that start with a blank space under the reference molecule line, with the syntax "i1 i2 i3 \[i4\] target(float)" (i.e. "0 1 2 3 90.0" for dihedrals or "0 1 2 0.0" for planar angles). For now, these constraints are enforced at every step (as capital letter constraints, but not associated to any letter).
+- Improved comments parsing: possible to comment in any input line (with "#", following a Pyhton-style syntax).
+- Tweaked similarity_refining maximum ensemble size thresholds to carry different pruning steps.
+- Turned off interactive ASE GUI specification of Sp3 atoms leaving groups for orbital building.
+
+## FIRECODE 1.0.1 🔥 (September 29 2024)
+- Minor bugfixes and printout clean-ups.
+
 ## FIRECODE 1.0.0 🔥 (July 5 2024)
 - Renamed project to better reflect the expanded functionality of the toolbox! 🔥
 - New Pruner class: simpler, more homogenized implementation of iterative subset pruning, sharing the same basic architecture across different similarity evaluation functions, with cached calls to the eval similarity function.

{firecode-1.0.0 → firecode-1.1.1}/README.md

@@ -4,16 +4,17 @@
 <div align="center">
 
 [![License: GNU LGPL v3](https://img.shields.io/github/license/ntampellini/firecode)](https://opensource.org/licenses/LGPL-3.0)
-[![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/ntampellini/firecode)](https://www.codefactor.io/repository/github/ntampellini/firecode)
 ![Python Version](https://img.shields.io/badge/Python-3.8.10-blue)
 ![Size](https://img.shields.io/github/languages/code-size/ntampellini/firecode)
-
 ![Lines](https://sloc.xyz/github/ntampellini/firecode/)
+[![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/ntampellini/firecode)](https://www.codefactor.io/repository/github/ntampellini/firecode)
+
 [![PyPI](https://img.shields.io/pypi/v/firecode)](https://pypi.org/project/firecode/)
 [![Wheel](https://img.shields.io/pypi/wheel/firecode)](https://pypi.org/project/firecode/)
 [![Documentation Status](https://readthedocs.org/projects/firecode/badge/?version=latest)](https://firecode.readthedocs.io/en/latest/?badge=latest)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/firecode)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
+
 ![Twitter](https://img.shields.io/twitter/url?url=https%3A%2F%2Ftwitter.com%2Fntampellini_&label=%40ntampellini_&link=https%3A%2F%2Ftwitter.com%2Fntampellini_)
 
 </div>

{firecode-1.0.0 → firecode-1.1.1}/docs/conf.py

@@ -12,7 +12,6 @@
 #
 import os
 import sys
-from firecode.__main__ import __version__
 
 # sys.path.insert(0, os.path.abspath('.'))
 sys.path.insert(0, os.path.join(os.path.abspath('..'), 'firecode'))
@@ -26,7 +25,7 @@ author = 'Nicolò Tampellini'
 
 # The full version, including alpha/beta/rc tags
 
-release = __version__
+release = '1.1.0'
 # release='latest'
 
 # -- General configuration ---------------------------------------------------

{firecode-1.0.0 → firecode-1.1.1}/firecode/__main__.py

@@ -22,8 +22,10 @@ Nicolo' Tampellini - nicolo.tampellini@yale.edu
 import argparse
 import os
 import sys
+from rich.traceback import install
+install(show_locals=True)
 
-__version__ = '1.0.0'
+__version__ = '1.1.0'
 
 if __name__ == '__main__':
 

{firecode-1.0.0 → firecode-1.1.1}/firecode/algebra.py

@@ -73,8 +73,11 @@ def clip(n, lower, higher):
     else:
         return n
 
-@nb.njit
+# @nb.njit
 def point_angle(p1, p2, p3):
+    '''
+    Returns the planar angle between three points in space, in degrees.
+    '''
     return np.arccos(np.clip(norm(p1 - p2) @ norm(p3 - p2), -1.0, 1.0))*180/np.pi
 
 @nb.njit

{firecode-1.0.0 → firecode-1.1.1}/firecode/ase_manipulations.py

@@ -40,14 +40,14 @@ from ase.optimize import BFGS, LBFGS
 from ase.vibrations import Vibrations
 from sella import Sella
 
-from firecode.algebra import norm, norm_of
+from firecode.algebra import dihedral, norm, norm_of, point_angle
 from firecode.graph_manipulations import findPaths, graphize, neighbors
 from firecode.rmsd import get_alignment_matrix
 from firecode.settings import COMMANDS, MEM_GB
 from firecode.solvents import get_solvent_line
 from firecode.utils import (HiddenPrints, align_structures, clean_directory,
-                          get_double_bonds_indices, molecule_check,
-                          scramble_check, time_to_string, write_xyz)
+                            get_double_bonds_indices, molecule_check,
+                            scramble_check, time_to_string, write_xyz)
 
 
 class Spring:
@@ -57,7 +57,7 @@ class Spring:
     Spring constant is very high to achieve tight convergence,
     but maximum force is dampened so as not to ruin structures.
     '''
-    def __init__(self, i1, i2, d_eq, k=100):
+    def __init__(self, i1, i2, d_eq, k=300):
         self.i1, self.i2 = i1, i2
         self.d_eq = d_eq
         self.k = k
@@ -119,6 +119,176 @@ class HalfSpring:
     def __repr__(self):
         return f'Spring - ids:{self.i1}/{self.i2} - d_max:{self.d_max}, k:{self.k}'
 
+class PlanarAngleSpring:
+    '''
+    ASE Custom Constraint Class
+    Adds an harmonic force among a triad of atoms.
+    Spring constant is dinamycally adjusted to achieve tight convergence,
+    but maximum force is dampened so as not to ruin structures.
+    eq_angle: in degrees
+    '''
+    def __init__(self, i1, i2, i3, eq_angle):
+        self.i1, self.i2, self.i3 = i1, i2, i3
+        self.eq_angle = eq_angle
+
+        self.k_min = 0.2
+        self.k_max = 2
+        self.theta_mid = 3
+
+    def adjust_positions(self, atoms, newpositions):
+        pass
+
+    def adjust_forces(self, atoms, forces):
+
+        # Get positions
+        p1 = atoms.positions[self.i1]
+        p2 = atoms.positions[self.i2]
+        p3 = atoms.positions[self.i3]
+
+        # Calculate vectors
+        v21 = p1 - p2  # Vector from atom 2 to 1
+        v23 = p3 - p2  # Vector from atom 2 to 3
+        
+        # Get bond lengths
+        r1 = norm_of(v21)
+        r3 = norm_of(v23)
+
+        # Calculate current angle
+        current_angle = point_angle(p1, p2, p3)
+        delta_angle = self.eq_angle - current_angle
+
+        # Calculate unit vectors
+        e21 = v21 / r1
+        e23 = v23 / r3
+
+        # Normal to the plane
+        normal = np.cross(e21, e23)
+        if norm_of(normal) > 1e-10:  # Check if atoms aren't collinear
+            
+            normal = norm(normal)
+            
+            # Calculate perpendicular directions in the plane
+            f1_direction = np.cross(e21, normal)
+            f3_direction = np.cross(normal, e23)
+            
+            # Dynamically adjust force constant: k_min for large delta_angles,
+            # up to k_max for smaller ones. Sigmoid-like function centered on self.theta_mid.
+            sigmoid = 1-(delta_angle-self.theta_mid)/(1+np.abs(delta_angle-self.theta_mid))
+            k_dynamic = (self.k_max-self.k_min)/2 * (sigmoid) + self.k_min
+                
+            force_magnitude = np.clip(delta_angle * k_dynamic, -2, 2)
+
+            # Calculate forces perpendicular to bonds
+            f1 = force_magnitude * f1_direction
+            f3 = force_magnitude * f3_direction
+            
+            # The central force needs to maintain both force and torque balance
+            f2 = -(f1 + f3)
+
+            forces[self.i1] += f1
+            forces[self.i2] += f2
+            forces[self.i3] += f3
+
+    def __repr__(self):
+        return f'PlanarAngleSpring - ids:{self.i1}/{self.i2}/{self.i3} - eq_angle:{self.eq_angle}'
+
+class DihedralSpring:
+    '''
+    ASE Custom Constraint Class
+    Adds a harmonic force to control a dihedral angle between four atoms.
+    Improved handling of stiff bonds and out-of-plane rotations.
+    
+    Parameters:
+    -----------
+    i1, i2, i3, i4 : int
+        Indices of the four atoms defining the dihedral angle
+    eq_angle : float
+        Target dihedral angle in degrees
+    k_min : float, optional
+        Minimum force constant (default: 0.1)
+    k_max : float, optional
+        Maximum force constant (default: 1)
+    '''
+    def __init__(self, i1, i2, i3, i4, eq_angle, k_min=0.1, k_max=1):
+        self.i1, self.i2, self.i3, self.i4 = i1, i2, i3, i4
+        self.eq_angle = eq_angle
+        
+        self.k_min = k_min
+        self.k_max = k_max
+        self.theta_mid = 30.0
+
+    def adjust_positions(self, atoms, newpositions):
+        pass
+
+    def get_delta_angle(self, current, target):
+        """
+        Calculate the smallest angle difference considering periodicity.
+        Returns the difference in degrees.
+        """
+        diff = ((target - current + 180) % 360) - 180
+        return diff
+
+    def adjust_forces(self, atoms, forces):
+        # Get positions         
+        p1 = atoms.positions[self.i1].copy()
+        p2 = atoms.positions[self.i2].copy()
+        p3 = atoms.positions[self.i3].copy()
+        p4 = atoms.positions[self.i4].copy()
+
+        # Calculate current dihedral angle
+        current_angle =dihedral((p1, p2, p3, p4))
+        
+        # Calculate periodic angle difference
+        delta_angle = self.get_delta_angle(current_angle, self.eq_angle)
+        
+        # Calculate central bond length (important for force scaling)
+        v23 = p3 - p2
+        bond_length = norm_of(v23)
+        
+        # Dynamic force constant calculation - quadratic scaling near target
+        rel_angle = np.abs(delta_angle) / self.theta_mid
+        k_dynamic = self.k_max * np.exp(-rel_angle) + self.k_min
+        
+        # Scale force by bond length (shorter bonds need more force)
+        force_scale = 1.0 / bond_length
+        
+        # Calculate force magnitude with scaled clipping
+        force_magnitude = np.clip(delta_angle * k_dynamic * force_scale, -5.0, 5.0)
+        
+        # Calculate force directions
+        v21 = p1 - p2
+        v34 = p4 - p3
+        
+        # Calculate perpendicular components for force application
+        n1 = np.cross(v21, v23)
+        n2 = np.cross(v23, v34)
+        
+        n1_norm = norm_of(n1)
+        n2_norm = norm_of(n2)
+        
+        if n1_norm < 1e-6 or n2_norm < 1e-6:
+            return
+            
+        f1_direction = n1 / n1_norm
+        f4_direction = n2 / n2_norm
+        
+        # Apply forces with improved balance
+        f1 = force_magnitude * f1_direction
+        f4 = force_magnitude * f4_direction
+        
+        # Distribute forces to maintain total force and torque
+        forces[self.i1] += f1
+        forces[self.i4] += f4
+        forces[self.i2] += -0.75 * f1
+        forces[self.i3] += -0.75 * f4
+        # Remaining -0.25 * (f1 + f4) is distributed equally
+        center_force = -0.25 * (f1 + f4)
+        forces[self.i2] += center_force
+        forces[self.i3] += center_force
+
+    def __repr__(self):
+        return f'DihedralSpring(ids: {self.i1}/{self.i2}/{self.i3}/{self.i4}, eq_angle: {self.eq_angle})'
+
 def get_ase_calc(embedder):
     '''
     Attach the correct ASE calculator
@@ -145,7 +315,7 @@ def get_ase_calc(embedder):
                              '(See https://github.com/grimme-lab/xtb-python)'))
 
         from firecode.solvents import (solvent_synonyms, xtb_solvents,
-                                     xtb_supported)
+                                       xtb_supported)
                                      
         solvent = solvent_synonyms[solvent] if solvent in solvent_synonyms else solvent
         solvent = 'none' if solvent is None else solvent
@@ -154,7 +324,19 @@ def get_ase_calc(embedder):
             raise Exception(f'Solvent \'{solvent}\' not supported by XTB. Supported solvents are:\n{xtb_supported}')
 
         return XTB(method=method, solvent=solvent)
-
+    
+    if calculator == 'AIMNET2':
+        try:
+            from aimnet2_firecode.interface import get_aimnet2_calc
+        except ImportError:
+            raise Exception(('Cannot import AIMNET2 python bindings. Install them with:\n'
+                             '>>> pip install aimnet2_firecode\n'))
+        
+        if hasattr(embedder.dispatcher, "aimnet2_calc"):
+            return embedder.dispatcher.aimnet2_calc
+        
+        else:
+            return get_aimnet2_calc(method=method, logfunction=embedder.log)
     
     command = COMMANDS[calculator]
 
@@ -212,104 +394,6 @@ def get_ase_calc(embedder):
 
             return calc
 
-# def ase_adjust_spacings(embedder, structure, atomnos, constrained_indices, title=0, traj=None):
-#     '''
-#     embedder: firecode embedder object
-#     structure: TS candidate coordinates to be adjusted
-#     atomnos: 1-d array with element numbering for the TS
-#     constrained_indices: (n,2)-shaped array of indices to be distance constrained
-#     mols_graphs: list of NetworkX graphs, ordered as the single molecules in the TS
-#     title: number to be used for referring to this structure in the embedder log
-#     traj: if set to a string, traj+'.traj' is used as a filename for the refinement trajectory.
-#     '''
-#     atoms = Atoms(atomnos, positions=structure)
-
-#     atoms.calc = get_ase_calc(embedder)
-    
-#     springs = [Spring(indices[0], indices[1], dist) for indices, dist in embedder.target_distances.items()]
-#     # adding springs to adjust the pairings for which we have target distances
-
-#     # if there are no springs, it is faster (and equivalent) to just do a classical full opitimization
-#     if not springs:
-#         from firecode.optimization_methods import optimize
-#         return optimize(
-#                         structure,
-#                         atomnos,
-#                         embedder.options.calculator,
-#                         method=embedder.options.theory_level,
-#                         mols_graphs=embedder.graphs if embedder.embed != 'monomolecular' else None,
-#                         procs=embedder.procs,
-#                         solvent=embedder.options.solvent,
-#                         max_newbonds=embedder.options.max_newbonds,
-#                         check=(embedder.embed != 'refine'),
-
-#                         logfunction=lambda s: embedder.log(s, p=False),
-#                         title=f'Candidate_{title}'
-#                     )
-
-#     nci_indices = [indices for letter, indices in embedder.pairings_table.items() if letter.islower()]
-#     halfsprings = [HalfSpring(i1, i2, 2.5) for i1, i2 in nci_indices]
-#     # HalfSprings get atoms involved in NCIs together if they are more than 2.5A apart,
-#     # but lets them achieve their natural equilibrium distance when closer
-
-#     psc = PreventScramblingConstraint(graphize(structure, atomnos),
-#                                         atoms,
-#                                         double_bond_protection=embedder.options.double_bond_protection,
-#                                         fix_angles=embedder.options.fix_angles_in_deformation)
-
-#     atoms.set_constraint(springs + halfsprings + [psc])
-
-#     t_start_opt = time.perf_counter()
-#     try:
-#         with LBFGS(atoms, maxstep=0.2, logfile=None, trajectory=traj) as opt:
-
-#             opt.run(fmax=0.05, steps=500)
-#             # initial coarse refinement with
-#             # Springs, Half Springs and PSC
-
-#             for spring in springs:
-#                 spring.tighten()
-#             atoms.set_constraint(springs)
-#             # Tightening Springs to improve
-#             # spacings accuracy, removing PSC
-#             # spacings accuracy, removing PSC
-
-#             opt.run(fmax=0.05, steps=200)
-#             # final accurate refinement
-
-#             iterations = opt.nsteps
-
-
-#         new_structure = atoms.get_positions()
-
-#         success = scramble_check(new_structure, atomnos, constrained_indices, embedder.graphs)
-#         if iterations == 200:
-#             exit_str = 'MAX ITER'            
-#         elif success:
-#             exit_str = 'REFINED'
-#         else:
-#             exit_str = 'SCRAMBLED'
-        
-#         if iterations == 200:
-#             exit_str = 'MAX ITER'            
-#         elif success:
-#             exit_str = 'REFINED'
-#         else:
-#             exit_str = 'SCRAMBLED'
-        
-#     except PropertyNotImplementedError:
-#         exit_str = 'CRASHED'
-
-#     embedder.log(f'    - {title} {exit_str} ({iterations} iterations, {time_to_string(time.perf_counter()-t_start_opt)})', p=False)
-#     embedder.log(f'    - {title} {exit_str} ({iterations} iterations, {time_to_string(time.perf_counter()-t_start_opt)})', p=False)
-
-#     if exit_str == 'CRASHED':
-#         return None, None, False
-
-#     energy = atoms.get_total_energy() * 23.06054194532933 #eV to kcal/mol
-
-#     return new_structure, energy, success
-
 def ase_saddle(embedder, coords, atomnos, constrained_indices=None, mols_graphs=None, title='temp', logfile=None, traj=None, freq=False, maxiterations=200):
     '''
     Runs a first order saddle optimization through the ASE package
@@ -632,9 +716,27 @@ def PreventScramblingConstraint(graph, atoms, double_bond_protection=False, fix_
 
     return FixInternals(dihedrals_deg=dihedrals_deg, angles_deg=angles_deg, bonds=bonds, epsilon=1)
 
-def ase_popt(embedder, coords, atomnos, constrained_indices=None,
-             steps=500, targets=None, safe=False, safe_mask=None,
-             traj=None, logfunction=None, title='temp'):
+def ase_popt(
+                embedder,
+                coords,
+                atomnos,
+
+                constrained_indices=None,
+                constrained_distances=None,
+
+                constrained_angles_indices=None,
+                constrained_angles_values=None,
+
+                constrained_dihedrals_indices=None,
+                constrained_dihedrals_values=None,
+
+                steps=500,
+                safe=False,
+                safe_mask=None,
+                traj=None,
+                logfunction=None,
+                title='temp',
+        ):
     '''
     embedder: firecode embedder object
     coords: 
@@ -650,11 +752,26 @@ def ase_popt(embedder, coords, atomnos, constrained_indices=None,
     constraints = []
 
     if constrained_indices is not None:
+        constrained_distances = constrained_distances or [None for _ in constrained_indices]
         for i, c in enumerate(constrained_indices):
             i1, i2 = c
-            tgt_dist = norm_of(coords[i1]-coords[i2]) if targets is None else targets[i]
+            tgt_dist = constrained_distances[i] or norm_of(coords[i1]-coords[i2])
             constraints.append(Spring(i1, i2, tgt_dist))
 
+    if constrained_angles_indices is not None:
+        constrained_angles_values = constrained_angles_values or [None for _ in constrained_angles_indices]
+        for i, c in enumerate(constrained_angles_indices):
+            i1, i2, i3 = c
+            tgt_angle = constrained_angles_values[i] or point_angle(coords[i1], coords[i2], coords[i3])
+            constraints.append(PlanarAngleSpring(i1, i2, i3, tgt_angle))
+
+    if constrained_dihedrals_indices is not None:
+        constrained_dihedrals_values = constrained_dihedrals_values or [None for _ in constrained_dihedrals_indices]
+        for i, c in enumerate(constrained_dihedrals_indices):
+            i1, i2, i3, i4 = c
+            tgt_angle = constrained_dihedrals_values[i] or dihedral((coords[i1], coords[i2], coords[i3], coords[i4]))
+            constraints.append(DihedralSpring(i1, i2, i3, i4, tgt_angle))
+
     if safe:
         constraints.append(PreventScramblingConstraint(graphize(coords, atomnos, safe_mask),
                                                         atoms,
@@ -789,7 +906,7 @@ def ase_bend(embedder, original_mol, conf, pivot, threshold, title='temp', traj=
             traj_obj.write()
 
         # check if we are stuck
-        if np.max(np.abs(np.linalg.norm(atoms.get_positions() - mol.atomcoords[0], axis=1))) < 0.01:
+        if np.max(np.abs(norm_of(atoms.get_positions() - mol.atomcoords[0], axis=1))) < 0.01:
             unproductive_iterations += 1
 
             if unproductive_iterations == 10:

{firecode-1.0.0 → firecode-1.1.1}/firecode/atropisomer_module.py

@@ -373,7 +373,6 @@ def ase_dih_scan(embedder,
 
                 iterations = opt.nsteps
 
-
             energies.append(atoms.get_total_energy() * 23.06054194532933) # eV to kcal/mol
 
         if logfile is not None:

{firecode-1.0.0 → firecode-1.1.1}/firecode/automep.py

@@ -43,8 +43,8 @@ def automep(embedder, n_images=9):
     ts_guess, _, _ = xtb_opt(
                             coords,
                             mol.atomnos,
-                            constrained_dihedrals=dihedrals+exocyclic,
-                            constrained_dih_angles=target_angles,
+                            constrained_dihedrals_indices=dihedrals+exocyclic,
+                            constrained_dihedrals_values=target_angles,
                             method=embedder.options.theory_level,
                             solvent=embedder.options.solvent,
                             procs=embedder.procs