Source code for scm.plams.interfaces.adfsuite.quickjobs

import numpy as np

from scm.plams.core.functions import config, delete_job, finish, init
from scm.plams.core.settings import Settings
from scm.plams.interfaces.adfsuite.ams import AMSJob
from scm.plams.interfaces.adfsuite.amsworker import AMSWorker
from scm.plams.mol.molecule import Molecule

__all__ = ["preoptimize", "refine_density", "refine_lattice"]


[docs]def preoptimize( molecule: Molecule, model: str = "UFF", settings: Settings = None, nproc: int = 1, maxiterations: int = 100 ): """ Returns an optimized Molecule (or list of optimized molecules) molecule: Molecule or list of Molecules Molecule to optimize model: str Shorthand for some model, e.g. 'UFF' settings: Settings Custom engine settings (overrides ``model``) nproc: int Number of processes maxiterations: int Maximum number of iterations for the geometry optimization. """ my_settings = _get_quick_settings(model, settings, nproc) single_molecule = isinstance(molecule, Molecule) input_molecules = [molecule] if single_molecule else molecule output_molecules = [] with AMSWorker(my_settings) as worker: for i, mol in enumerate(input_molecules): results = worker.GeometryOptimization( name=f"preoptimization_{i}", molecule=mol, maxiterations=maxiterations, pretendconverged=True ) output_molecules.append(results.get_main_molecule()) if single_molecule: return output_molecules[0] else: return output_molecules
[docs]def refine_density( molecule: Molecule, density: float, step_size=50, model: str = "UFF", settings: Settings = None, nproc: int = 1, maxiterations: int = 100, ): """ Performs a series of geometry optimizations with densities approaching ``density``. This can be useful if you want to compress a system to a given density, but cannot just use apply_strain() (because apply_strain() also scales the bond lengths). This function can be useful if for example packmol does not succeed to pack molecules with the desired density. Packmol can then generate a structure with a lower density, and this function can be used to increase the density to the desired value. Returns: a Molecule with the requested density. molecule: Molecule The molecule must have a 3D lattice density: float Target density in kg/m^3 (1000x the density in g/cm^3) step_size: float Step size for the density (in kg/m^3). Set step_size to a large number to only use 1 step. model: str e.g. 'UFF' settings: Settings Engine settings (overrides ``model``) maxiterations: int maximum number of iterations for the geometry optimization. """ assert len(molecule.lattice) == 3 tolerance = 1e-3 my_settings = _get_quick_settings(model, settings, nproc) current_density = molecule.get_density() # kg/m^3 output_molecule = molecule.copy() counter = 0 with AMSWorker(my_settings) as worker: while current_density < density - tolerance or current_density > density + tolerance: counter += 1 if current_density < density - step_size: new_density = current_density + step_size elif current_density > density + step_size: new_density = current_density - step_size else: new_density = density output_molecule.set_density(new_density) results = worker.GeometryOptimization( name=f"preoptimization_{counter}", molecule=output_molecule, maxiterations=maxiterations, pretendconverged=True, ) output_molecule = results.get_main_molecule() current_density = output_molecule.get_density() # kg/m^3 return output_molecule
[docs]def refine_lattice( molecule: Molecule, lattice, n_points=None, max_strain=0.15, model: str = "UFF", settings: Settings = None, nproc: int = 1, maxiterations: int = 10, ): """ Returns a ``Molecule`` for which the lattice of the ``molecule`` is transformed to ``lattice``, by performing short geometry optimizations (each for at most ``maxiterations``) on gradually distorted lattices (linearly interpolating from the original lattice to the new lattice using ``n_points`` points). This can be useful for transforming an orthorhombic box of a liquid into a non-orthorhombic box of a liquid, where the gradual transformation of the lattice ensures that the molecules do not become too distorted. If init() has been called before calling this function, the job will be run in the current PLAMS working directory and will be deleted when the job finishes. Returns: a Molecule with the requested lattice. If the refinement fails, ``None`` is returned. molecule: Molecule The initial molecule lattice: list of list of float List with 1, 2, or 3 elements. Each element is a list of float with 3 elements each. For example, ``lattice=[[10, 0, 0],[-5, 5, 0],[0, 0, 12]]``. n_points: None or int >=2 Number of points used for the linear interpolation. If None, n_points will be chosen such that the maximum strain for any step is at most ``max_strain`` compared to the original lattice vector lengths. max_strain: float Only if ``n_points=None``, use this value to determine the maximum allowed strain from one step to the next (as a fraction of the length of the original lattice vectors). model: str e.g. 'UFF' settings: Settings Engine settings (overrides ``model``) nproc: int Number of processes used by the job maxiterations: int maximum number of iterations for the geometry optimizations. """ assert len(lattice) == len( molecule.lattice ), f"Different number of lattice vectors: len(molecule.lattice) = {len(molecule.lattice)}, len(lattice) = {len(lattice)}" assert all(len(x) == 3 for x in lattice), f"Lattice vectors must have three components. Lattice: {lattice}" assert all(len(x) == 3 for x in molecule.lattice), f"Lattice vectors must have three components. Lattice: {lattice}" assert ( len(lattice) >= 1 and len(lattice) <= 3 ), f"{len(lattice)} lattice vectors given but must be between 1 and 3. Lattice: {lattice}" def lattice2str(latt): return "\n".join(" ".join(str(j) for j in i) for i in latt) if n_points is None: lat1 = np.array(molecule.lattice) lat2 = np.array(lattice) strain = np.linalg.norm(lat2, axis=1) / np.linalg.norm(lat1, axis=1) n_points = np.ceil(np.max(np.abs(strain - 1) / max_strain)) n_points = int(max(n_points, 2)) assert n_points >= 2, f"Expected n_points >=2, but received {n_points}" called_plams_init = _ensure_init() s = _get_quick_settings(model, settings, nproc) s.input.ams.task = "PESScan" s.input.ams.PESScan.ScanCoordinate.FromLattice._1 = lattice2str(molecule.lattice) s.input.ams.PESScan.ScanCoordinate.ToLattice._1 = lattice2str(lattice) s.input.ams.PESScan.ScanCoordinate.NPoints = n_points s.input.ams.GeometryOptimization.MaxIterations = maxiterations s.input.ams.GeometryOptimization.PretendConverged = "Yes" job = AMSJob(settings=s, molecule=molecule, name="refine_density") job.run() final_molecule = None if job.ok(): results = job.results.get_pesscan_results(molecules=True) final_molecule = results["Molecules"][-1] delete_job(job) if called_plams_init: finish() return final_molecule
def _ensure_init(): if config.init: called_plams_init = False else: s = Settings() s.erase_workdir = True s.log.stdout = 0 init(config_settings=s) called_plams_init = True return called_plams_init def model_to_settings(model: str): """ Returns Settings """ settings = Settings() model = model.lower() if model == "uff": settings.input.ForceField.Type = "UFF" elif model == "gaff": settings.input.ForceField.Type = "GAFF" settings.input.ForceField.AnteChamberIntegration = "Yes" elif model == "gfnff": settings.input.GFNFF elif model == "ani-2x" or model == "ani2x": settings.input.MLPotential.Model = "ANI-2x" elif model == "gfn1xtb" or model == "gfn1-xtb": settings.input.DFTB.Model = "GFN1-xTB" elif model == "m3gnet-up-2022" or model == "m3gnetup2022": settings.input.MLPotential.Model = "M3GNet-UP-2022" else: raise ValueError("Unknown model: {}".format(model)) return settings def _get_quick_settings(model, settings, nproc): if settings is None: my_settings = model_to_settings(model) else: my_settings = settings.copy() if nproc: my_settings.runscript.nproc = nproc return my_settings