firecode 1.5.0__tar.gz → 1.5.1__tar.gz

{firecode-1.5.0 → firecode-1.5.1}/CHANGELOG.md

@@ -10,7 +10,8 @@
 - Removed openbabel dependency.
 - Imports bugfixes.
 - Restructured setup to use [Pixi](https://pixi.prefix.dev/latest/).
- <!-- add documentation: SCRAMBLECHECK kw -->
+- Removed SMILES to 3D conversion.
+ <!-- add documentation: SCRAMBLECHECK kw, fsm>, neb>, rdkit_search>-->
 
 ## FIRECODE 1.4.0 🔥 (January 25 2026) - Big cleanup and reorganization!
 - Similarity pruning is now done via the standalone [PRISM](https://github.com/ntampellini/prism_pruner) library.

{firecode-1.5.0 → firecode-1.5.1}/PKG-INFO

@@ -1,16 +1,13 @@
 Metadata-Version: 2.4
 Name: firecode
-Version: 1.5.0
+Version: 1.5.1
 Summary: FIRECODE: Filtering Refiner and Embedder for Conformationally Dense Ensembles
 Author-email: Nicolò Tampellini <nicolo.tampellini@yale.edu>
 License-Expression: LGPL-3.0-or-later
 License-File: LICENSE
 Requires-Python: <3.13,>=3.10
 Requires-Dist: ase
-Requires-Dist: fairchem-core
-Requires-Dist: importlib-metadata
 Requires-Dist: inquirerpy
-Requires-Dist: llvmlite
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: numpy
@@ -20,7 +17,13 @@ Requires-Dist: psutil
 Requires-Dist: rdkit>=2025.9.3
 Requires-Dist: rich
 Requires-Dist: scipy
-Requires-Dist: typing-extensions
+Provides-Extra: aimnet2
+Requires-Dist: aimnet[ase]; extra == 'aimnet2'
+Provides-Extra: full
+Requires-Dist: aimnet[ase]; extra == 'full'
+Requires-Dist: fairchem-core; extra == 'full'
+Provides-Extra: uma
+Requires-Dist: fairchem-core; extra == 'uma'
 Description-Content-Type: text/markdown
 
 

{firecode-1.5.0 → firecode-1.5.1}/docs/examples.rst

@@ -11,13 +11,13 @@ For detailed descriptions of the operators and keywords present in the inputs, s
 
 Work is in progress to expand this section with more examples.
 
-1. Generation of a 3D structure from SMILES, conformational search and refinement
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+1. Conformational search and refinement
++++++++++++++++++++++++++++++++++++++++
 
 ::
 
    LEVEL=GFN-FF
-   refine> rsearch> opt> O=C(O)[C@H](NC([C@H](NC([C@@H](C)N)=O)C)=O)C
+   refine> rsearch> opt> tris_ala.xyz
 
    # This is a comment line!
 
@@ -25,11 +25,9 @@ Work is in progress to expand this section with more examples.
    # If XTB is not set as the default calculator, you can specify it
    # here adding CALC=XTB in the keyword line.
 
-   # First, the SMILES string is converted into a 3D structure
-   # (H2N-Ala-Ala-Ala-OH), then operators are applied starting
-   # from the inside out:
+   # The operators are applied starting from the inside out:
 
-   # opt> - the generated 3D structure will be optimized
+   # opt> - the structure will be optimized
 
    # rsearch> - a knowledge-based, torsion-based conformational search
    # is carried out. The number of conformers generated can be adjusted
@@ -75,7 +73,7 @@ Work is in progress to expand this section with more examples.
 
 ::
 
-    SADDLE KCAL=10
+    KCAL=10
     scan> atropisomer.xyz 1 2 9 10
 
     # scan> : (four indices specified) performs two dihedral
@@ -84,12 +82,7 @@ Work is in progress to expand this section with more examples.
     # 10 kcal/mol (KCAL keyword) form the lowest energy
     # structure are re-scanned at increased accuracy (1°
     # increments).
-
-    # SADDLE: Each maxima is then optimized to a saddle point.
-    
-    # It is also possible to replace SADDLE with NEB to use scan
-    # points to run a NEB in an automated way.
-
+   
 .. figure:: /images/atropo.png
    :alt: Example output structure
    :width: 75%

firecode-1.5.1/docs/installation.rst

@@ -0,0 +1,85 @@
+.. _installation:
+
+Installation
+============
+
+This program is written in Python (currently >=3.12). The recommended way to install it is through conda/mamba and uv. 
+
+::
+
+    # create a new conda environment and install firecode with uv
+    conda create --name firecode python=3.12 uv
+    conda activate firecode
+    uv pip install firecode
+
+After installation, run the guided utility to finalize the setup:
+
+::
+
+    firecode --setup
+
+
+Optional dependencies (WIP)
+===========================
+
+CREST
+-----
+
+This is free software. See the `GitHub repository <https://github.com/grimme-lab/crest>`__.
+Currently only CREST 2.12 is supported, working on supporting the latest version is in progress.
+
+::
+
+    # install mamba if you don't have it already
+    conda install -c conda-forge mamba
+
+    mamba install -c conda-forge crest==2.12
+
+
+AIMNET2 / UMA models
+--------------------
+
+The software can be interfaced with AIMNET2 and UMA models. Work is in progress to port AIMNET2 models to the new codebase.
+An interface to the UMA models is available provided that the models are present on the system at the location specified in
+the settings.py file (change with ``firecode --settings``). The UMA models can be obtained from HuggingFace at https://huggingface.co/facebook/UMA. 
+
+
+
+XTB (recommended for Force Field and semiempirical calculations)
+----------------------------------------------------------------
+
+This is free software. See the `GitHub
+repository <https://github.com/grimme-lab/xtb>`__ and the
+`documentation <https://xtb-docs.readthedocs.io/en/latest/contents.html>`__
+for how to install it on your machine. The package and its python bindings are available through conda as well.
+
+::
+
+    # install mamba if you don't have it already
+    conda install -c conda-forge mamba
+
+    mamba install -c conda-forge xtb xtb-python
+
+TBLITE
+------
+
+Light-weight version of the xTB, free for academic use. See the `GitHub repository <https://github.com/tblite/tblite>`__.
+
+::
+
+    # install mamba if you don't have it already
+    conda install -c conda-forge mamba
+
+    mamba install -c conda-forge tblite tblite-python
+
+
+ORCA
+----
+
+This software is only free for academic use at an academic institution.
+Detailed instructions on how to install and set up ORCA can be found in
+`the official
+website <https://sites.google.com/site/orcainputlibrary/setting-up-orca>`__.
+Make sure to install and set up OpenMPI along with ORCA if you wish to
+exploit multiple cores on your machine **(Note: semiempirical methods
+cannot yet be parallelized in ORCA!)**

{firecode-1.5.0 → firecode-1.5.1}/docs/usage.rst

@@ -7,7 +7,7 @@ The program can be run from terminal, with the command:
 
 ::
 
-    python -m firecode myinput.txt -n [custom_title]
+    firecode myinput.txt -n [custom_title]
 
 A custom name for the run can be optionally provided with the -n flag, otherwise a time
 stamp will be used to name the output files.
@@ -17,16 +17,14 @@ instruction in a string after the ``-cl``/``--command_line`` argument:
 
 ::
 
-    python -m firecode -cl "csearch> molecule.xyz"
-    python -m firecode --command_line "csearch> molecule.xyz"
+    firecode -cl "csearch> molecule.xyz"
 
 In this case, an input file will be written for you by the program.
 
 Input formatting
 ----------------
 
-The input can be any text file. The extension is arbitrary but I suggest
-sticking with ``.txt``.
+The input can be any text file, but sticking with ``.txt`` or ``.inp`` is recommended.
 
 -  Any blank line will be ignored
 -  Any line starting with ``#`` will be ignored
@@ -34,17 +32,15 @@ sticking with ``.txt``.
 
 Then, molecule files are specified. A molecule line is made up of these elements, in this order:
 
--  An operator (optional)
+-  Zero or more operators (*i.e.* ``csearch>``, ``opt>``, etc.) separated by spaces
 -  The molecule file name (required)
--  Indices (numbers) and pairings (letters) for the molecule (optional)
+-  Optional indices (numbers) and pairings (letters) for the molecule
+-  Optional properties of the molecule (*i.e.* ``charge=1``, ``property=value``)
 
-An example with all three is ``opt> butadiene.xyz 6a 8b``.
+An example with all four is ``refine> rsearch> butadiene.xyz 6a 8b charge=1``.
 
-FIRECODE can work with all molecular formats read by
-`cclib <https://github.com/cclib/cclib>`__, but best practice is using
-only the ``.xyz`` file format, particularly for multimolecular files
-containing different conformers of the same molecule. **Molecule indices
-are counted starting from zero!**
+FIRECODE works with ``.xyz`` files. **Molecule indices
+are zero-based! (counted starting from zero!)**
 
 Operators
 +++++++++

{firecode-1.5.0 → firecode-1.5.1}/firecode/ase_manipulations.py

@@ -27,6 +27,7 @@ import time
 import warnings
 from copy import deepcopy
 from shutil import rmtree
+from subprocess import getoutput
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -46,7 +47,7 @@ from prism_pruner.utils import (align_structures, get_double_bonds_indices,
 
 from firecode.algebra import norm_of, point_angle
 from firecode.calculators.__init__ import NewFolderContext
-from firecode.calculators.dummy_ase_calc import DummyCalculator
+from firecode.calculators._xtb import xtb_gsolv
 from firecode.units import EH_TO_EV, EH_TO_KCAL, EV_TO_KCAL
 from firecode.utils import (HiddenPrints, cartesian_product, clean_directory,
                             molecule_check, read_xyz, suppress_stdout_stderr,
@@ -701,107 +702,16 @@ def set_charge_and_mult_on_ase_atoms(ase_atoms, charge, mult):
     mult_list[0] = mult - 1
     ase_atoms.set_initial_magnetic_moments(mult_list)
 
-def ase_popt(
-                embedder,
-                atoms,
-                coords,
-                charge: int,
-                mult: int,
-
-                constrained_indices=None,
-                constrained_distances=None,
-
-                constrained_angles_indices=None,
-                constrained_angles_values=None,
-
-                constrained_dihedrals_indices=None,
-                constrained_dihedrals_values=None,
-
-                ase_constraints=None,
-
-                steps=500,
-                safe=False,
-                safe_mask=None,
-                traj=None,
-                logfunction=None,
-                title='temp',
-
-                **kwargs,
-        ):
-    '''
-    embedder: firecode embedder object
-    coords: 
-    atoms: 
-    constrained_indices:
-    safe: if True, adds a potential that prevents atoms from scrambling
-    safe_mask: bool array, with False for atoms to be excluded when calculating bonds to preserve
-    traj: if set to a string, traj is used as a filename for the bending trajectory.
-    not only the atoms will be printed, but also all the orbitals and the active pivot.
-    '''
-    ase_atoms = Atoms(atoms, positions=coords)
-    set_charge_and_mult_on_ase_atoms(ase_atoms, charge, mult)
-
-    # set calculator
-    ase_atoms.calc = embedder.dispatcher.get_ase_calc(embedder.options.theory_level, embedder.options.solvent)
-    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 = 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 ase_constraints is not None:
-        constraints.extend(ase_constraints)
-
-    if safe:
-        constraints.append(PreventScramblingConstraint(graphize(atoms, coords, safe_mask),
-                                                        atoms,
-                                                        double_bond_protection=embedder.options.double_bond_protection,
-                                                        fix_angles=embedder.options.fix_angles_in_deformation))
-
-    ase_atoms.set_constraint(constraints)
-
-    t_start_opt = time.perf_counter()
-    with LBFGS(ase_atoms, maxstep=0.1, logfile=None, trajectory=traj) as opt:
-        opt.run(fmax=0.05, steps=steps)
-        iterations = opt.nsteps
+    return ase_atoms
 
-    new_structure = ase_atoms.get_positions()
-    success = (iterations < 499)
-
-    if logfunction is not None:
-        exit_str = 'REFINED' if success else 'MAX ITER'
-        logfunction(f'    - {title} {exit_str} ({iterations} iterations, {time_to_string(time.perf_counter()-t_start_opt)})')
-
-    if embedder.options.final_sp_level is None:
-        energy = ase_atoms.get_total_energy() * EV_TO_KCAL
-
-    else:
-        ase_atoms.calc = embedder.dispatcher.get_ase_calc(embedder.options.final_sp_level, embedder.options.solvent)
-        energy = ase_atoms.get_total_energy() * EV_TO_KCAL
-
-    return new_structure, energy, success
-
-def ase_popt_lite(
+def ase_popt(
                 atoms,
                 coords,
                 ase_calc,
+                charge,
+                mult,
+                solvent=None,
+                add_alpb_solvation=False,
 
                 constrained_indices=None,
                 constrained_distances=None,
@@ -813,33 +723,23 @@ def ase_popt_lite(
                 constrained_dihedrals_values=None,
 
                 ase_constraints=None,
-                new_bond_preventer=None,
 
-                steps=500,
+                maxiter=None,
                 traj=None,
                 logfunction=None,
                 title='temp',
-
-                dummy_first=False,
+                debug=False,
 
                 **kwargs,
         ):
     '''
-    embedder: firecode embedder object
-    coords: 
-    atoms: 
-    constrained_indices:
- 
-    dummy_first: run a cycle with a fast, empty optimizer first, still enforcing constraints
 
     '''
-    atoms = Atoms(atoms, positions=coords)
 
-    if dummy_first:
-        atoms.calc = DummyCalculator()
-        new_bond_preventer = new_bond_preventer or []
-    else:
-        atoms.calc = ase_calc
+    ase_atoms = Atoms(atoms, positions=coords)
+    ase_atoms.calc = ase_calc
+    ase_atoms = set_charge_and_mult_on_ase_atoms(ase_atoms, charge, mult)
+    maxiter = maxiter or 750
 
     constraints = []
 
@@ -867,41 +767,49 @@ def ase_popt_lite(
     if ase_constraints is not None:
         constraints.extend(ase_constraints)
 
-    atoms.set_constraint(constraints)
+    ase_atoms.set_constraint(constraints)
 
-    t_start_opt = time.perf_counter()
-    with suppress_stdout_stderr():
+    # create working folder and cd into it
+    with NewFolderContext(title, delete_after=(not debug)):
 
-        if dummy_first:
+        t_start_opt = time.perf_counter()
 
-            # dummy with just bond distances
-            with LBFGS(atoms, maxstep=0.1, logfile=None, trajectory=traj[:-5]+"_dummy.traj") as opt:
-                opt.run(fmax=0.2, steps=50)
+        with suppress_stdout_stderr():
+            with LBFGS(ase_atoms, maxstep=0.2, logfile=None, trajectory=traj) as opt:
+                opt.run(fmax=0.05, steps=maxiter)
+                iterations = opt.nsteps
 
-            # add optional NewBondPreventer and do some more steps
-            atoms.set_constraint(constraints + [new_bond_preventer])
+        new_structure = ase_atoms.get_positions()
+        success = (iterations < maxiter-1)
 
-            with LBFGS(atoms, maxstep=0.1, logfile=None, trajectory=traj[:-5]+"_dummy.traj") as opt:
-                opt.run(fmax=0.2, steps=30)
+        if logfunction is not None:
+            exit_str = 'REFINED' if success else 'MAX ITER'
+            logfunction(f'    - {title} {exit_str} ({iterations} iterations, {time_to_string(time.perf_counter()-t_start_opt)})')
 
-            # remove additional NewBondPreventer constraint and set the desired calc
-            atoms.set_constraint(constraints)
-            atoms.calc = ase_calc
+        energy = ase_atoms.get_total_energy() * EV_TO_KCAL
 
-        with LBFGS(atoms, maxstep=0.1, logfile=None, trajectory=traj) as opt:
-            opt.run(fmax=0.05, steps=steps)
-            iterations = opt.nsteps
+        if traj is not None:
+            getoutput(f"ase convert {traj} {traj}.xyz")
+
+        if solvent is not None and add_alpb_solvation:
+            gsolv = xtb_gsolv(
+                                atoms,
+                                new_structure,
+                                model='alpb',
+                                charge=charge,
+                                mult=mult,
+                                solvent=solvent,
+                                title=title,
+                                assert_convergence=True,
+                            )
+            energy += gsolv
 
-    new_structure = atoms.get_positions()
-    success = (iterations < 499)
 
-    if logfunction is not None:
-        exit_str = 'REFINED' if success else 'MAX ITER'
-        logfunction(f'    - {title} {exit_str} ({iterations} iterations, {time_to_string(time.perf_counter()-t_start_opt)})')
+    return new_structure, energy, success
 
-    energy = atoms.get_total_energy() * EV_TO_KCAL
 
-    return new_structure, energy, success
+def ase_popt_with_alpb(*args, **kwargs):
+    return ase_popt(*args, add_alpb_solvation=True, **kwargs)    
 
 
 def ase_bend(embedder, original_mol, conf, pivot, threshold, title='temp', traj=None, check=True):
@@ -1371,7 +1279,6 @@ def fsm_operator(embedder, optimize_endpoints=True):
     from mlfsm.cos import FreezingString
     from mlfsm.opt import CartesianOptimizer, InternalsOptimizer, Optimizer
 
-
     # interp = 'ric'
     interp = 'cart'
     maxiter = 100 # default = 3
@@ -1393,7 +1300,7 @@ def fsm_operator(embedder, optimize_endpoints=True):
 
         reactant, _, _ = ase_popt(
             embedder=embedder,
-            atoms=mol.atoms,
+            ase_atoms=mol.atoms,
             coords=reactant,
             charge=mol.charge,
             mult=mol.mult,
@@ -1401,7 +1308,7 @@ def fsm_operator(embedder, optimize_endpoints=True):
 
         product, _, _ = ase_popt(
             embedder=embedder,
-            atoms=mol.atoms,
+            ase_atoms=mol.atoms,
             coords=product,
             charge=mol.charge,
             mult=mol.mult,
@@ -1410,10 +1317,10 @@ def fsm_operator(embedder, optimize_endpoints=True):
         reactant, product = align_structures(np.stack((reactant, product)))
 
     reactant = Atoms(mol.atoms, reactant)
-    set_charge_and_mult_on_ase_atoms(reactant, charge, mult)
+    reactant = set_charge_and_mult_on_ase_atoms(reactant, charge, mult)
 
     product = Atoms(mol.atoms, product)
-    set_charge_and_mult_on_ase_atoms(product, charge, mult)
+    product = set_charge_and_mult_on_ase_atoms(product, charge, mult)
 
 
     workdir = f'{mol.rootname}_freezing_string'

{firecode-1.5.0 → firecode-1.5.1}/firecode/atropisomer_module.py

@@ -37,6 +37,7 @@ from prism_pruner.utils import align_structures, time_to_string
 from firecode.ase_manipulations import ase_neb
 from firecode.errors import ZeroCandidatesError
 from firecode.optimization_methods import optimize
+from firecode.units import EV_TO_KCAL
 from firecode.utils import clean_directory, loadbar, molecule_check, write_xyz
 
 
@@ -357,7 +358,7 @@ def ase_dih_scan(embedder,
 
                 iterations = opt.nsteps
 
-            energies.append(atoms.get_total_energy() * 23.06054194532933) # eV to kcal/mol
+            energies.append(atoms.get_total_energy() * EV_TO_KCAL)
 
         if logfile is not None:
             elapsed = time() - t_start_step

{firecode-1.5.0 → firecode-1.5.1}/firecode/calculators/_ase_uma.py

@@ -13,6 +13,7 @@ from firecode.ase_manipulations import (DihedralSpring, PlanarAngleSpring,
 from firecode.calculators.__init__ import NewFolderContext
 from firecode.calculators._xtb import xtb_gsolv
 from firecode.settings import UMA_MODEL_PATH
+from firecode.units import EV_TO_KCAL
 
 
 def uma_opt(
@@ -120,7 +121,7 @@ def uma_opt(
             exit_str = 'REFINED' if success else 'MAX ITER'
             logfunction(f'    - {title} {exit_str} ({iterations} iterations, {time_to_string(time.perf_counter()-t_start_opt)})')
 
-        energy = ase_atoms.get_total_energy() * 23.06054194532933 #eV to kcal/mol
+        energy = ase_atoms.get_total_energy() * EV_TO_KCAL
 
         if traj is not None:
             os.system(f"ase convert {traj} {title}_trj.xyz")
@@ -158,7 +159,10 @@ def get_uma_calc(method="omol", logfunction=None):
 
     except ImportError as err:
         print(err)
-        raise ImportError('To run the UMA models, please install fairchem:\n    >>> pip install fairchem-core')
+        raise ImportError('To run the UMA models, please install fairchem:\n'
+        '    >>> uv pip install fairchem-core\n' \
+        'or alternatively, install the "uma" version of firecode:\n'
+        '    >>> uv pip install firecode[uma]\n')
 
     gpu_bool = cuda.is_available()
 

{firecode-1.5.0 → firecode-1.5.1}/firecode/calculators/_xtb.py

@@ -30,6 +30,7 @@ import numpy as np
 from firecode.algebra import norm_of, normalize
 from firecode.calculators.__init__ import NewFolderContext
 from firecode.graph_manipulations import get_sum_graph
+from firecode.units import EH_TO_KCAL
 from firecode.utils import clean_directory, read_xyz, write_xyz
 
 
@@ -377,7 +378,7 @@ def read_from_xtbtraj(filename):
     xyzblock = lines[first_coord_line:]
 
     coords = np.array([line.split()[1:] for line in xyzblock], dtype=float)
-    energy = float(lines[first_coord_line-1].split()[1]) * 627.5096080305927 # Eh to kcal/mol
+    energy = float(lines[first_coord_line-1].split()[1]) * EH_TO_KCAL
 
     return coords, energy
 
@@ -390,7 +391,7 @@ def energy_grepper(filename, signal_string, position):
         while True:
             line = f.readline()
             if signal_string in line:
-                return float(line.split()[position]) * 627.5096080305927 # Eh to kcal/mol
+                return float(line.split()[position]) * EH_TO_KCAL
             if not line:
                 raise Exception(f'Could not find \'{signal_string}\' in file ({filename}).')
 
@@ -552,7 +553,7 @@ def crest_mtd_search(
 
     '''
 
-    with NewFolderContext(title):
+    with NewFolderContext(title, delete_after=False):
 
         if constrained_indices is not None:
             if len(constrained_indices) == 0:

{firecode-1.5.0 → firecode-1.5.1}/firecode/embedder.py

@@ -57,11 +57,10 @@ from firecode.numba_functions import (compenetration_check, count_clashes,
 from firecode.operators import operate
 from firecode.optimization_methods import Opt_func_dispatcher, fitness_check
 from firecode.parameters import orb_dim_dict
-from firecode.pt import pt
 from firecode.references import references
 from firecode.settings import DEFAULT_LEVELS, PROCS
 from firecode.torsion_module import get_quadruplets
-from firecode.utils import (Constraint, _saturation_check, ase_view,
+from firecode.utils import (Constraint, saturation_check, ase_view,
                             auto_newline, cartesian_product, clean_directory,
                             loadbar, scramble_check, timing_wrapper, write_xyz)
 
@@ -399,7 +398,7 @@ class Embedder:
         for mol in self.objects:
             charge = int(mol.charge) if hasattr(mol, "charge") else self.options.charge
             
-            if _saturation_check(mol.atoms, charge):
+            if saturation_check(mol.atoms, charge):
                 self.log(f"--> {mol.filename}: saturation check passed (even saturation index with CHG={charge}, MULT={self.options.mult})")
 
             # this may be a radical (and we would expect an even multiplicity) or something is wrong
@@ -2223,6 +2222,7 @@ class RunEmbedding(Embedder):
                                             ase_calc=self.dispatcher.ase_calc,
                                             solvent=self.options.solvent,
                                             charge=self.options.charge,
+                                            mult=self.options.mult,
                                             maxiter=maxiter,
                                             conv_thr=conv_thr,
 
@@ -2291,8 +2291,8 @@ class RunEmbedding(Embedder):
             else:
                 self.energies[i] = 1E10
 
-            ### Update checkpoint every (20*max_workers) optimized structures, and give an estimate of the remaining time
-            chk_freq = int(self.avail_cpus//4) * self.options.checkpoint_frequency
+            ### Update checkpoint every 50 optimized structures, and give an estimate of the remaining time
+            chk_freq = self.options.checkpoint_frequency
             if i % chk_freq == chk_freq-1:
 
                 with open(self.outname, 'w') as f:        
@@ -2553,7 +2553,7 @@ class RunEmbedding(Embedder):
         self.write_mol_info()
 
         if self.embed is None:
-            self.log('--> No embed requested, exiting.\n')
+            self.log('--> No embed or refinement requested, exiting.\n')
             self.normal_termination()
 
         if self.embed == 'error':

{firecode-1.5.0 → firecode-1.5.1}/firecode/hypermolecule_class.py

@@ -32,7 +32,7 @@ from firecode.errors import CCReadError, NoOrbitalError
 from firecode.graph_manipulations import is_sigmatropic, is_vicinal
 from firecode.pt import pt
 from firecode.reactive_atoms_classes import get_atom_type
-from firecode.utils import read_xyz, smi_to_3d
+from firecode.utils import read_xyz
 
 warnings.simplefilter("ignore", UserWarning)
 
@@ -107,14 +107,6 @@ class Hypermolecule:
             if '.' in filename:
                 raise SyntaxError((f'Molecule {filename} cannot be read. Please check your syntax.'))
 
-            try:
-                filename = smi_to_3d(filename, "generated_3D_coords")
-                print(f"--> Embedded SMILES string to 3D structure, saved as {filename}")
-                
-            except Exception:
-                raise SyntaxError((f'The program is trying to read something that is not a valid molecule input ({filename}). ' +
-                            'If this looks like a keyword, it is probably faulted by a syntax error.'))
-
         self.rootname = filename.split('.')[0]
         self.filename = filename
         self.debug_logfunction = debug_logfunction