17.1.1.2. pysisyphus.calculators package

17.1.1.2.1. Submodules

17.1.1.2.2. pysisyphus.calculators.AFIR module

class pysisyphus.calculators.AFIR.AFIR(calculator, fragment_indices, gamma, rho=1, p=6, ignore_hydrogen=False, zero_hydrogen=True, complete_fragments=True, dump=True, h5_fn='afir.h5', h5_group_name='afir', **kwargs)

Bases: Calculator

__init__(calculator, fragment_indices, gamma, rho=1, p=6, ignore_hydrogen=False, zero_hydrogen=True, complete_fragments=True, dump=True, h5_fn='afir.h5', h5_group_name='afir', **kwargs)

Artifical Force Induced Reaction calculator.

Currently, there are no automated drivers to run large-scale AFIR calculations with many different initial orientations and/or increasing collision energy parameter γ. Nontheless, selected AFIR calculations can be carried out by hand. After convergence, artificial potential & forces, as well as real energies and forces can be plotted with 'pysisplot --afir'. The highest energy point along the AFIR path can then be selected for a subsequent TS-optimization, e.g. via 'pysistrj --get [index] optimzation.trj'.

Future versions of pysisyphus may provide drivers for more automatted AFIR calculations.

Parameters:

• calculator (Calculator) -- Actual QC calculator that provides energies and its derivatives, that are modified by the AFIR calculator, e.g., ORCA or Psi4.

• fragment_indices (List[List[int]]) -- List of lists of integers, specifying the separate fragments. If the indices in theses lists don't comprise all atoms in the molecule, the reamining indices will be added as a separate fragment. If a AFIR calculation is carried out with 2 fragments and 'complete_fragments' is True (see below) it is enough to specify only the indices of one fragment, e.g., for a system of 10 atoms 'fragment_indices=[[0,1,2,3]]' is enough. The second system will be set up automatically with indices [4,5,6,7,8,9].

• gamma (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]) -- Collision energy parameter γ in au. For 2 fragments it can be a single integer, while for > 2 fragments a list of gammas must be given, specifying the pair-wise collision energy parameters. For 3 fragments 3 gammas must be given [γ_01, γ_02, γ_12], for 4 fragments 6 gammas would be required [γ_01, γ_02, γ_03, γ_12, γ_13, γ_23] and so on.

• rho (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]], default: 1) -- Direction of the artificial force, either 1 or -1. The same comments as for gamma apply. For 2 fragments a single integer is enough, for > 2 fragments a list of rhos must be given (see above). For rho=1 fragments are pushed together, for rho=-1 fragments are pulled apart.

• p (int, default: 6) -- Exponent p used in the calculation of the weight function ω. Defaults to 6 and probably does not have to be changed.

• ignore_hydrogen (bool, default: False) -- Whether hydrogens are ignored in the calculation of the artificial force. All weights between atom pairs containing hydrogen will be set to 0.

• zero_hydrogen (bool, default: True) -- Whether to use 0.0 as covalent radius for hydrogen in the weight function. Compared to 'ignore_hydrogen', which results in zero weights for all atom pairs involving hydrogen, 'zero_hydrogen' may be non-zero, depending on the covalent radius of the second atom in the pair.

• complete_fragments (bool, default: True) -- Whether an incomplete specification in 'fragment_indices' is automatically completed.

• dump (bool, default: True) -- Whether an HDF5 file is created.

• h5_fn (str, default: 'afir.h5') -- Filename of the HDF5 file used for dumping.

• h5_group_name (str, default: 'afir') -- HDF5 group name used for dumping.

• **kwargs -- Keyword arguments passed to the Calculator baseclass.

afir_fd_hessian_wrapper(coords3d, afir_grad_func)

property charge

dump_h5(atoms, coords, results)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

init_h5_group(atoms, max_cycles=None)

log_fragments()

property mult

set_atoms_and_funcs(atoms, coords)

Initially atoms was also an argument to the constructor of AFIR. I removed it so creation becomes easier. The first time a calculation is requested with a proper atom set everything is set up (cov. radii, afir function and corresponding gradient). Afterwards there is only a check if atoms != None and it is expected that all functions are properly set.

fragment_indices can also be incomplete w.r.t. to the number of atoms. If the sum of the specified fragment atoms is less than the number of atoms present then all remaining unspecified atoms will be gathered in one fragment.

write_fragment_geoms(atoms, coords)

exception pysisyphus.calculators.AFIR.CovRadiiSumZero

Bases: Exception

pysisyphus.calculators.AFIR.afir_closure(fragment_indices, cov_radii, gamma, rho=1, p=6, prefactor=1.0, logger=None)

rho=1 pushes fragments together, rho=-1 pulls fragments apart.

pysisyphus.calculators.AFIR.get_data_model(atoms, max_cycles)

17.1.1.2.3. pysisyphus.calculators.AnaPot module

class pysisyphus.calculators.AnaPot.AnaPot(**kwargs)

Bases: AnaPotBase

17.1.1.2.4. pysisyphus.calculators.AnaPot2 module

class pysisyphus.calculators.AnaPot2.AnaPot2

Bases: AnaPotBase

We can't use sympify as it replaces 1/tan by cot and this isn't supported by numpy when we call lambdify.

class pysisyphus.calculators.AnaPot2.AnaPot2_

Bases: Calculator

get_energy(atoms, coords)

Meant to be extended.

17.1.1.2.5. pysisyphus.calculators.AnaPot3 module

class pysisyphus.calculators.AnaPot3.AnaPot3

Bases: AnaPotBase

17.1.1.2.6. pysisyphus.calculators.AnaPot4 module

class pysisyphus.calculators.AnaPot4.AnaPot4

Bases: AnaPotBase

17.1.1.2.7. pysisyphus.calculators.AnaPotBase module

class pysisyphus.calculators.AnaPotBase.AnaPotBase(V_str, scale=1.0, xlim=(-1, 1), ylim=(-1, 1), levels=None, use_sympify=True, minima=None, saddles=None, **kwargs)

Bases: Calculator

anim_coords(coords, interval=50, show=False, title_func=None)

anim_opt(opt, energy_profile=False, colorbar=False, figsize=(8, 6), show=False)

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

classmethod get_geom(coords, atoms=('X',), V_str=None, calc_kwargs=None, geom_kwargs=None)

get_geoms_from_stored_coords(coords_list, i=None, calc_kwargs=None, geom_kwargs=None)

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_minima(i=None, calc_kwargs=None, geom_kwargs=None)

get_path(num, minima_inds=None)

get_saddles(i=None, calc_kwargs=None, geom_kwargs=None)

plot(levels=None, show=False, **figkwargs)

plot3d(levels=None, show=False, zlim=None, vmin=None, vmax=None, resolution=100, rcount=50, ccount=50, nan_above=None, init_view=None, colorbar=False, **figkwargs)

plot_coords(xs, ys, enum=True, show=False, title=None)

plot_eigenvalue_structure(grid=50, levels=None, show=False)

plot_geoms(geoms, **kwargs)

plot_irc(irc, *args, **kwargs)

plot_opt(opt, *args, **kwargs)

statistics()

17.1.1.2.8. pysisyphus.calculators.AnaPotCBM module

class pysisyphus.calculators.AnaPotCBM.AnaPotCBM

Bases: AnaPotBase

17.1.1.2.9. pysisyphus.calculators.AtomAtomTransTorque module

class pysisyphus.calculators.AtomAtomTransTorque.AtomAtomTransTorque(geom, frags, A_mats, kappa=2.0)

Bases: object

__init__(geom, frags, A_mats, kappa=2.0)

Atom-atom translational and torque forces.

See A.5. [1], Eq. (A6).

get_forces(atoms, coords)

17.1.1.2.10. pysisyphus.calculators.Calculator module

class pysisyphus.calculators.Calculator.Calculator(calc_number=0, charge=0, mult=1, base_name='calculator', pal=1, mem=1000, keep_kind='all', check_mem=True, retry_calc=0, last_calc_cycle=None, clean_after=True, out_dir='qm_calcs', force_num_hess=False, num_hess_kwargs=None)

Bases: object

__init__(calc_number=0, charge=0, mult=1, base_name='calculator', pal=1, mem=1000, keep_kind='all', check_mem=True, retry_calc=0, last_calc_cycle=None, clean_after=True, out_dir='qm_calcs', force_num_hess=False, num_hess_kwargs=None)

Base-class of all calculators.

Meant to be extended.

Parameters:

• calc_number (int, default=0) -- Identifier of the Calculator. Used in distinguishing it from other Calculators, e.g. in ChainOfStates calculations. Also used in the creation of filenames.

• charge (int, default=0) -- Molecular charge.

• mult (int, default=1) -- Molecular multiplicity (1 = singlet, 2 = doublet, ...)

• base_name (str, default=calculator) -- Generated filenames will start with this string.

• pal (int, default=1) -- Positive integer that gives the number of physical cores to use on 1 node.

• mem (int, default=1000) -- Mememory per core in MB. The total amount of memory is given as mem*pal.

• check_mem (bool, default=True) -- Whether to adjust the requested memory if too much is requested.

• retry_calc (int, default=0) -- Number of additional retries when calculation failed.

• last_calc_cycle (int) -- Internal variable used in restarts.

• clean_after (bool) -- Delete temporary directory were calculations were executed after a calculation.

• out_dir (str) -- Path that is prepended to generated filenames.

• force_hess_kwargs (bool, default False) -- Force numerical Hessians.

• num_hess_kwargs (dict) -- Keyword arguments for finite difference Hessian calculation.

apply_keep_kind()

apply_set_plans(kept_fns, set_plans=None)

build_set_plans(_set_plans=None)

clean(path)

Delete the temporary directory.

Parameters:

path (Path) -- Directory to delete.

conf_key = None

force_num_hessian()

Always calculate numerical Hessians.

classmethod geom_from_fn(fn, **kwargs)

get_cmd(key='cmd')

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_num_hessian(atoms, coords, **prepare_kwargs)

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_restart_info()

Return a dict containing chkfiles.

Returns:

restart_info -- Dictionary holding the calculator state. Used for restoring calculaters in restarted calculations.

Return type:

dict

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

keep(path)

Backup calculation results.

Parameters:

path (Path) -- Temporary directory of the calculation.

Returns:

kept_fns -- Dictonary holding the filenames that were backed up. The keys correspond to the type of file.

Return type:

dict

load_wavefunction_from_file(fn, **kwargs)

log(message='')

Write a log message.

Wraps the logger variable.

Parameters:

message (str) -- Message to be logged.

make_fn(name, counter=None, return_str=False)

Make a full filename.

Return a full filename including the calculator name and the current counter given a suffix.

Parameters:

• name (str) -- Suffix of the filename.

• counter (int, optional) -- If not given use the current calc_counter.

• return_str (int, optional) -- Return a string instead of a Path when True.

Returns:

fn -- Filename.

Return type:

str

property name

popen(cmd, cwd=None)

prepare(inp)

Prepare a temporary directory and write input.

Similar to prepare_path, but the input is also written into the prepared directory.

17.1.1.2. Paramters

inpstr

Input to be written into the file self.inp_fn in the prepared directory.

returns:

path: Path

Prepared directory.

prepare_coords(atoms, coords)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type)

Meant to be extended.

prepare_path(use_in_run=False)

Get a temporary directory handle.

Create a temporary directory that can later be used in a calculation.

Parameters:

use_in_run (bool, option) -- Sets the internal variable self.path_already_prepared that is later read by self.run(). No new temporary directory will be created in self.run().

Returns:

path: Path

Prepared directory.

prepare_pattern(raw_pat)

Prepare globs.

Transforms an entry of self.to_keep into a glob and a key suitable for the use in self.keep().

Parameters:

raw_pat (str) -- Entry of self.to_keep

Returns:

• pattern (str) -- Glob that can be used in Path.glob()

• multi (bool) -- Flag if glob may match multiple files.

• key (str) -- A key to be used in the kept_fns dict.

prepare_turbo_coords(atoms, coords)

Get a Turbomole coords string.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- String holding coordinates in Turbomole coords format.

Return type:

str

prepare_xyz_string(atoms, coords)

Returns a xyz string in Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

xyz_str -- Coordinates in .xyz format.

Return type:

string

print_capabilities()

print_out_fn(path)

Print calculation output.

Prints the output of a calculator after a calculation.

Parameters:

path (Path) -- Temporary directory of the calculation.

restore_org_hessian()

Restore original 'get_hessian' method, which may also fallback to numerical Hessians, if not implemented.

run(inp, calc, add_args=None, env=None, shell=False, hold=False, keep=True, cmd=None, inc_counter=True, run_after=True, parser_kwargs=None, symlink=True)

Run a calculation.

The bread-and-butter method to actually run an external quantum chemistry code.

Parameters:

• inp (str) -- Input for the external program that is written to the temp-dir.

• calc (str, hashable) -- Key (and more or less type of calculation) to select the right parsing function from self.parser_funcs.

• add_args (iterable, optional) -- Additional arguments that will be appended to the program call.

• env (Environment, optional) -- A potentially modified environment for the subprocess call.

• shell (bool, optional) -- Use a shell to execute the program call. Need for Turbomole were we chain program calls like dscf; escf.

• hold (bool, optional) -- Wether to remove the temporary directory after the calculation.

• keep (bool, optional) -- Wether to backup files as specified in self.to_keep(). Usually you want this.

• cmd (str or iterable, optional) -- Overwrites self.base_cmd.

• inc_counter (bool, optional) -- Wether to increment the counter after a calculation.

Returns:

results -- Dictionary holding all applicable results of the calculations like the energy, a forces vector and/or excited state energies from TDDFT.

Return type:

dict

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

set_restart_info(restart_info)

Sets restart information (chkfiles etc.) on the calculator.

Parameters:

restart_info (dict) -- Dictionary holding the calculator state. Used for restoring calculaters in restarted calculations.

verify_chkfiles(chkfiles)

Checks if given chkfiles exist and return them as Paths

Parameters:

chkfiles (dict) -- Dictionary holding the chkfiles. The keys correspond to the attribute names, the values are strs holding the (potentially full) filename (path).

Returns:

paths -- Dictionary of Paths.

Return type:

dict

class pysisyphus.calculators.Calculator.HessKind(value)

Bases: Enum

An enumeration.

NUMERICAL = 2

ORG = 1

class pysisyphus.calculators.Calculator.KeepKind(value)

Bases: Enum

An enumeration.

ALL = 1

LATEST = 2

NONE = 3

class pysisyphus.calculators.Calculator.SetPlan(key, name=None, condition=<function SetPlan.<lambda>>, fail=None)

Bases: object

condition()

fail: Optional[Callable] = None

key: str

name: Optional[str] = None

17.1.1.2.11. pysisyphus.calculators.CerjanMiller module

class pysisyphus.calculators.CerjanMiller.CerjanMiller(a=1, b=1, c=1)

Bases: AnaPotBase

17.1.1.2.12. pysisyphus.calculators.Composite module

class pysisyphus.calculators.Composite.Composite(final, keys_calcs=None, calcs=None, remove_translation=False, **kwargs)

Bases: Calculator

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_final_energy(energies)

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

run_calculation(atoms, coords, **prepare_kwargs)

17.1.1.2.13. pysisyphus.calculators.ConicalIntersection module

class pysisyphus.calculators.ConicalIntersection.CIQuantities(energy1, gradient1, energy2, gradient2, energy_diff, gradient_diff, gradient_mean, P, x, y, energy, forces, hessian=None)

Bases: object

P: ndarray

energy: float

energy1: float

energy2: float

energy_diff: float

forces: ndarray

gradient1: ndarray

gradient2: ndarray

gradient_diff: ndarray

gradient_mean: ndarray

hessian: Optional[ndarray] = None

savez(fn)

x: ndarray

y: ndarray

class pysisyphus.calculators.ConicalIntersection.ConicalIntersection(calculator1, calculator2, **kwargs)

Bases: Calculator

Calculator for conical intersection optimization.

Based on [1].

get_ci_quantities(atoms, coords, **prepare_kwargs)

Relavent quantities including branching plane and projector P.

get_energy(atoms, coords, **prepare_kwargs)

Energy of calculator 1.

get_forces(atoms, coords, **prepare_kwargs)

Projected gradient for CI optimization.

get_hessian(atoms, coords, **prepare_kwargs)

Projected Hessian.

pysisyphus.calculators.ConicalIntersection.get_P(x, y)

Projector to project out components in branching plane.

pysisyphus.calculators.ConicalIntersection.update_y(x, x_prev, y_prev)

Update approximate coupling derivative vector y.

17.1.1.2.14. pysisyphus.calculators.DFTBp module

class pysisyphus.calculators.DFTBp.DFTBp(parameter, *args, slakos=None, **kwargs)

Bases: OverlapCalculator

conf_key = 'dftbp'

get_all_energies(atoms, coords, **prepare_kwargs)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

static get_excited_state_str(track, root, nroots, forces=False)

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

static get_gen_str(atoms, coords)

hubbard_derivs = {'3ob': {'Br': -0.0573, 'C': -0.1492, 'Ca': -0.034, 'Cl': -0.0697, 'F': -0.1623, 'H': -0.1857, 'I': -0.0433, 'K': -0.0339, 'Mg': -0.02, 'N': -0.1535, 'Na': -0.0454, 'O': -0.1575, 'P': -0.14, 'S': -0.11, 'Zn': -0.03}}

max_ang_moms = {'3ob': {'Br': 'd', 'C': 'p', 'Ca': 'p', 'Cl': 'd', 'F': 'p', 'H': 's', 'I': 'd', 'K': 'p', 'Mg': 'p', 'N': 'p', 'Na': 'p', 'O': 'p', 'P': 'd', 'S': 'd', 'Zn': 'd'}, 'mio-ext': {'C': 'p', 'H': 's', 'N': 'p', 'O': 'p'}}

parse_all_energies(out_fn=None, exc_dat=None)

parse_energy(path)

static parse_exc_dat(text)

parse_forces(path)

parse_total_energy(text)

prepare_input(atoms, coords, calc_type)

Meant to be extended.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

run_calculation(atoms, coords, **prepare_kwargs)

store_and_track(results, func, atoms, coords, **prepare_kwargs)

pysisyphus.calculators.DFTBp.parse_mo(eigvec)

pysisyphus.calculators.DFTBp.parse_xplusy(text)

17.1.1.2.15. pysisyphus.calculators.Dalton module

class pysisyphus.calculators.Dalton.Dalton(basis, method='hf', **kwargs)

Bases: Calculator

compute(mol, prop)

conf_key = 'dalton'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

prepare_input(atoms, coords)

Meant to be extended.

17.1.1.2.16. pysisyphus.calculators.Dimer module

class pysisyphus.calculators.Dimer.Dimer(calculator, *args, N_raw=None, length=0.0189, rotation_max_cycles=15, rotation_method='fourier', rotation_thresh=0.0001, rotation_tol=1, rotation_max_element=0.001, rotation_interpolate=True, rotation_disable=False, rotation_disable_pos_curv=True, rotation_remove_trans=True, trans_force_f_perp=True, bonds=None, N_hessian=None, bias_rotation=False, bias_translation=False, bias_gaussian_dot=0.1, seed=None, write_orientations=True, forward_hessian=True, **kwargs)

Bases: Calculator

property C

Shortcut for the curvature.

property N

add_gaussian(atoms, center, N, height=0.1, std=0.0529, max_cycles=50, dot_ref=None)

property can_bias_f0

property can_bias_f1

property coords0

property coords1

curvature(f1, f2, N)

Curvature of the mode represented by the dimer.

direct_rotation(optimizer, prev_step)

do_dimer_rotations(rotation_thresh=None)

property energy0

property f0

property f1

property f1_bias

property f2

Never calculated explicitly, but estimated from f0 and f1.

fourier_rotation(optimizer, prev_step)

get_N_raw_from_hessian(h5_fn, root=0)

get_forces(atoms, coords)

Meant to be extended.

get_gaussian_energies(coords, sum_=True)

get_gaussian_forces(coords, sum_=True)

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

remove_translation(displacement)

property rot_force

rotate_coords1(rad, theta)

Rotate dimer and produce new coords1.

set_N_raw(coords)

property should_bias_f0

May lead to calculation of f0 and/or f1 if present!

property should_bias_f1

May lead to calculation of f0 and/or f1 if present!

update_orientation(coords)

class pysisyphus.calculators.Dimer.Gaussian(height, center, std, N)

Bases: object

energy(R, height=None)

forces(R, height=None)

exception pysisyphus.calculators.Dimer.RotationConverged

Bases: Exception

17.1.1.2.17. pysisyphus.calculators.Dummy module

class pysisyphus.calculators.Dummy.Dummy(calc_number=0, charge=0, mult=1, base_name='calculator', pal=1, mem=1000, keep_kind='all', check_mem=True, retry_calc=0, last_calc_cycle=None, clean_after=True, out_dir='qm_calcs', force_num_hess=False, num_hess_kwargs=None)

Bases: Calculator

get_energy(*args, **kwargs)

Meant to be extended.

get_forces(*args, **kwargs)

Meant to be extended.

get_hessian(*args, **kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

raise_exception()

run_calculation(*args, **kwargs)

17.1.1.2.18. pysisyphus.calculators.EGO module

class pysisyphus.calculators.EGO.EGO(calculator, ref_geom, max_force=0.175, **kwargs)

Bases: Calculator

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_mods(atoms, coords)

property ref_hessian

property s

17.1.1.2.19. pysisyphus.calculators.EnergyMin module

class pysisyphus.calculators.EnergyMin.EnergyMin(calculator1, calculator2, mix=False, alpha=0.02, sigma=3.5, min_energy_diff=0.0, check_after=0, **kwargs)

Bases: Calculator

__init__(calculator1, calculator2, mix=False, alpha=0.02, sigma=3.5, min_energy_diff=0.0, check_after=0, **kwargs)

Use energy and derivatives of the calculator with lower energy.

This calculators carries out two calculations with different settings and returns the results of the lower energy one. This can be used to consider flips between a singlet and a triplet PES etc.

Parameters:

• calculator1 (Calculator) -- Wrapped QC calculator that provides energies and its derivatives.

• calculator2 (Calculator) -- Wrapped QC calculator that provides energies and its derivatives.

• mix (bool, default: False) -- Enable mixing of both forces, according to the approach outlined in [2]. Can be used to optimize guesses for MECPs. Pass

• alpha (float, default: 0.02) -- Smoothing parameter in Hartree. See [2] for a discussion.

• sigma (float, default: 3.5) -- Unitless gap size parameter. The final gap becomes smaller for bigga sigmas. Has to be adapted for each case. See [2] for a discussion (p. 407 right column and p. 408 left column.)

• min_energy_diff (float, default: 0.0) -- Energy difference in Hartree. When set to a value != 0 and the energy difference between both calculators drops below this value, execution of both calculations is diabled for 'check_after' cycles. In these cycles the calculator choice remains fixed. After 'check_after' cycles, both energies will be calculated and it is checked, if the previous calculator choice remains valid. In conjunction with 'check_after' both arguments can be used to save computational ressources.

• check_after (int, default: 0) -- Amount of cycles in which the calculator choice remains fixed.

• **kwargs -- Keyword arguments passed to the Calculator baseclass.

do_calculations(name, atoms, coords, **prepare_kwargs)

get_chkfiles()

Return type:

dict

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

set_chkfiles(chkfiles)

17.1.1.2.20. pysisyphus.calculators.ExternalPotential module

class pysisyphus.calculators.ExternalPotential.ExternalPotential(calculator=None, potentials=None, geom=None, **kwargs)

Bases: Calculator

available_potentials = {'d3': <class 'pysisyphus.calculators.DFTD3.DFTD3'>, 'harmonic_sphere': <class 'pysisyphus.calculators.ExternalPotential.HarmonicSphere'>, 'logfermi': <class 'pysisyphus.calculators.ExternalPotential.LogFermi'>, 'restraint': <class 'pysisyphus.calculators.ExternalPotential.Restraint'>, 'rmsd': <class 'pysisyphus.calculators.ExternalPotential.RMSD'>}

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_potential_energy(coords)

get_potential_forces(coords)

class pysisyphus.calculators.ExternalPotential.HarmonicSphere(k, radius, origin=(0.0, 0.0, 0.0), geom=None)

Bases: object

calc(coords3d, gradient=False)

instant_pressure(coords3d)

property surface_area

In Bohr**2

class pysisyphus.calculators.ExternalPotential.LogFermi(beta, radius, T=300, origin=(0.0, 0.0, 0.0), geom=None)

Bases: object

__init__(beta, radius, T=300, origin=(0.0, 0.0, 0.0), geom=None)

As described in the XTB docs.

https://xtb-docs.readthedocs.io/en/latest/xcontrol.html#confining-in-a-cavity

calc(coords3d, gradient=False)

class pysisyphus.calculators.ExternalPotential.RMSD(geom, k, beta=0.5, atom_indices=None)

Bases: object

__init__(geom, k, beta=0.5, atom_indices=None)

Restrain based on RMSD with a reference geometry.

As described in https://doi.org/10.1021/acs.jctc.0c01306, Eq. (5).

Parameters:

• geom (Geometry) -- Reference geometry for RMSD calculation.

• k (float) -- Gaussian height in units of energy. Should be a negative number if the system under study should stay close to the reference geometry (pulling k). A positive Gaussian height k results in forces that push the system under study away from the reference geometry (pushing k).

• b -- Gaussian width in inverse units of lengths.

• atom_indices (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]], None], default: None) -- Optional, numpy array or iterable of integer atom indices. Restricts the RMSD calculation to these atoms. If omitted, all atoms are used.

calc(coords3d, gradient=False)

class pysisyphus.calculators.ExternalPotential.Restraint(restraints, geom=None)

Bases: object

calc(coords3d, gradient=False)

static calc_prim_restraint(prim, coords3d, force_const, ref_val)

17.1.1.2.21. pysisyphus.calculators.FakeASE module

class pysisyphus.calculators.FakeASE.FakeASE(calc)

Bases: object

get_atoms_coords(atoms)

get_forces(atoms=None)

get_potential_energy(atoms=None)

17.1.1.2.22. pysisyphus.calculators.FourWellAnaPot module

class pysisyphus.calculators.FourWellAnaPot.FourWellAnaPot

Bases: AnaPotBase

17.1.1.2.23. pysisyphus.calculators.FreeEndNEBPot module

class pysisyphus.calculators.FreeEndNEBPot.FreeEndNEBPot

Bases: AnaPotBase

__init__()

Analyitcal potential as described in [1] Appendix A

17.1.1.2.24. pysisyphus.calculators.Gaussian09 module

class pysisyphus.calculators.Gaussian09.Gaussian09(*args, **kwargs)

Bases: Gaussian16

conf_key = 'gaussian09'

17.1.1.2.25. pysisyphus.calculators.Gaussian16 module

class pysisyphus.calculators.Gaussian16.Gaussian16(route, gbs='', gen='', keep_chk=False, wavefunction_dump=True, stable='', fchk=None, iop9_40=3, **kwargs)

Bases: OverlapCalculator

conf_key = 'gaussian16'

get_all_energies(atoms, coords, **prepare_kwargs)

get_chkfiles()

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

make_exc_str()

make_fchk(path)

make_gbs_str()

parse_635r_dump(dump_path, roots, nmos)

parse_all_energies(fchk=None)

parse_charges(path=None)

parse_double_mol(path, out_fn=None)

parse_energy(path)

static parse_fchk(fchk_path, keys)

parse_force(path)

parse_hessian(path)

parse_keyword(text)

parse_log(*args, **kwargs)

parse_stable(path)

parse_tddft(path)

prepare_input(atoms, coords, calc_type, did_stable=False, point_charges=None)

Meant to be extended.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

reuse_data(path)

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

run_calculation(atoms, coords, **prepare_kwargs)

run_double_mol_calculation(atoms, coords1, coords2)

run_rwfdump(path, rwf_index, chk_path=None)

run_stable(atoms, coords, **prepare_kwargs)

set_chkfiles(chkfiles)

store_and_track(results, func, atoms, coords, **prepare_kwargs)

pysisyphus.calculators.Gaussian16.get_nmos(text)

pysisyphus.calculators.Gaussian16.noparse(path)

pysisyphus.calculators.Gaussian16.to_ind_and_spin(lbl)

17.1.1.2.26. pysisyphus.calculators.HardSphere module

class pysisyphus.calculators.HardSphere.HardSphere(geom, frags, kappa=1.0, permutations=False, frag_radii=None, radii_offset=0.9452)

Bases: object

__init__(geom, frags, kappa=1.0, permutations=False, frag_radii=None, radii_offset=0.9452)

Intra-Image Inter-Molecular Hard-Sphere force.

See A.2. in [1], Eq. (A1).

get_forces(atoms, coords, kappa=None)

class pysisyphus.calculators.HardSphere.PWHardSphere(geom, frags, sub_frags, kappa=1.0)

Bases: object

__init__(geom, frags, sub_frags, kappa=1.0)

Inter-Molecular pairwise Hard-Sphere forces between atoms.

Hardsphere forces are only applied between certain atoms of given fragments, but the whole fragment is moved. Can be used to remove atom inter-molecular atom clashes.

get_forces(atoms, coords, kappa=None)

17.1.1.2.27. pysisyphus.calculators.IDPPCalculator module

class pysisyphus.calculators.IDPPCalculator.IDPPCalculator(target)

Bases: Calculator

get_forces(atoms, coords)

Meant to be extended.

17.1.1.2.28. pysisyphus.calculators.IPIClient module

pysisyphus.calculators.IPIClient.calc_ipi_client(addr, atoms, calc, queue=None, **kwargs)

pysisyphus.calculators.IPIClient.ipi_client(addr, atoms, energy_getter, forces_getter, hessian_getter=None, hdrlen=12)

17.1.1.2.29. pysisyphus.calculators.IPIServer module

class pysisyphus.calculators.IPIServer.IPIServer(*args, address=None, host=None, port=None, unlink=True, hdrlen=12, max_retries=0, verbose=False, **kwargs)

Bases: Calculator

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

listen_for(atoms, coords, kind='forces')

listen_for_client_atom_num(atom_num)

listen_for_energy()

listen_for_forces(atom_num)

listen_for_hessian(atom_num)

listen_kinds = ('coords', 'energy', 'forces', 'hessian')

reset_client_connection()

retried_listen_for(atoms, coords)

unlink(address)

17.1.1.2.30. pysisyphus.calculators.LEPSBase module

class pysisyphus.calculators.LEPSBase.LEPSBase(pot_type='leps')

Bases: AnaPotBase

17.1.1.2.31. pysisyphus.calculators.LEPSExpr module

class pysisyphus.calculators.LEPSExpr.LEPSExpr

Bases: object

G(a, b)

Gaussian function.

Gdimer(x, y, A, x0, y0, sx, sy)

J(d, alpha, r0, r)

Quantum mechanical exchange interaction.

Q(d, alpha, r0, r)

Coulomb interactions.

V_LEPS(x=None, y=None, abc=None)

Equation (A.1) in [1]. Mimics reaction involving three atoms confined to motion along a line.

V_dimer()

III. Results Section A in [3]. Two additional saddle points from two added gaussians.

V_harmonic()

Equation (A.2) in [1]. A and C are fixed, only B can move. A condensed phase environment is represented by adding a harmonic oscillator degree of freedom.

V_tot()

Equation (A.3) in [1]. Additional saddle point.

__init__()

Generates sympy expression for various LEPS potentials.

get_dimer()

get_expr(pot_type='leps')

get_harmonic()

get_leps()

get_tot()

17.1.1.2.32. pysisyphus.calculators.LennardJones module

class pysisyphus.calculators.LennardJones.LennardJones(sigma=1.8897261251, epsilon=1, rc=None)

Bases: Calculator

calculate(coords3d)

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

17.1.1.2.33. pysisyphus.calculators.MOPAC module

class pysisyphus.calculators.MOPAC.MOPAC(method='PM7', **kwargs)

Bases: Calculator

http://openmopac.net/manual/

CALC_TYPES = {'energy': '1SCF', 'gradient': '1SCF GRADIENTS', 'hessian': 'DFORCE FORCE LET'}

METHODS = ['am1', 'pm3', 'pm6', 'pm6-dh2', 'pm6-d3', 'pm6-dh+', 'pm6-dh2', 'pm6-dh2x', 'pm6-d3h4', 'pm6-d3h4x', 'pm7', 'pm7-ts']

MULT_STRS = {1: 'SINGLET', 2: 'DOUBLET', 3: 'TRIPLET', 4: 'QUARTET', 5: 'QUINTET', 6: 'SEXTET', 7: 'SEPTET', 8: 'OCTET'}

base_cmd

Do only SCF AUX: Creates a checkpoint file NOREO: Dont reorient geometry

Type:

1SCF

conf_key = 'mopac'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

parse_energy(path)

static parse_energy_from_aux(inp, *args, **kwargs)

parse_grad(path)

parse_hessian(path)

static parse_hessian_from_aux(inp, *args, **kwargs)

prepare_coords(atoms, coords, opt=False)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type, opt=False)

Meant to be extended.

read_aux(path)

run_calculation(atoms, coords, **prepare_kwargs)

17.1.1.2.34. pysisyphus.calculators.MullerBrownSympyPot module

class pysisyphus.calculators.MullerBrownSympyPot.MullerBrownPot

Bases: AnaPotBase

17.1.1.2.35. pysisyphus.calculators.MultiCalc module

class pysisyphus.calculators.MultiCalc.MultiCalc(calcs, **kwargs)

Bases: Calculator

run_calculation(atoms, coords, **prepare_kwargs)

pysisyphus.calculators.MultiCalc.calcs_from_dict(calc_dict, base_name, calc_number, charge, mult, pal, mem)

17.1.1.2.36. pysisyphus.calculators.OBabel module

class pysisyphus.calculators.OBabel.OBabel(ff='gaff', mol=None, **kwargs)

Bases: Calculator

conv_dict = {'kcal/mol': 627.5094740630558, 'kj/mol': 2625.4996394798254}

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

setup(atoms, coords)

17.1.1.2.37. pysisyphus.calculators.ONIOMv2 module

class pysisyphus.calculators.ONIOMv2.LayerCalc(models, total_size, parent_layer_calc=None)

Bases: object

property charge

do_parent(with_parent)

static energy_from_results(model_energies, parent_energy=None)

get_energy(atoms, coords, with_parent=True)

get_forces(atoms, coords, with_parent=True)

get_hessian(atoms, coords, with_parent=True)

property mult

run_calculations(atoms, coords, method)

class pysisyphus.calculators.ONIOMv2.Link(ind, parent_ind, atom, g)

Bases: tuple

atom

Alias for field number 2

g

Alias for field number 3

ind

Alias for field number 0

parent_ind

Alias for field number 1

class pysisyphus.calculators.ONIOMv2.Model(name, calc_level, calc, parent_name, parent_calc_level, parent_calc, atom_inds, parent_atom_inds, use_link_atoms=True)

Bases: object

as_calculator(cap=False)

as_geom(all_atoms, all_coords)

capped_atoms_coords(all_atoms, all_coords)

create_bond_vec_getters(atoms)

create_links(atoms, coords, debug=False)

get_energy(atoms, coords, point_charges=None, parent_correction=True, cap=True)

get_forces(atoms, coords, point_charges=None, parent_correction=True, cap=True)

get_hessian(atoms, coords, point_charges=None, parent_correction=True, cap=True)

get_jacobian()

get_sparse_jacobian()

log(message='')

parse_charges()

class pysisyphus.calculators.ONIOMv2.ModelDummyCalc(model, cap=False)

Bases: object

get_energy(atoms, coords)

get_forces(atoms, coords)

class pysisyphus.calculators.ONIOMv2.ONIOM(calcs, models, geom, layers=None, embedding='', real_key='real', use_link_atoms=True, *args, **kwargs)

Bases: Calculator

__init__(calcs, models, geom, layers=None, embedding='', real_key='real', use_link_atoms=True, *args, **kwargs)

layer: list of models

len(layer) == 1: normal ONIOM, len(layer) >= 1: multicenter ONIOM.

model:

(sub)set of all atoms that resides in a certain layer and has a certain calculator.

atom_inds_in_layer(index, exclude_inner=False)

Returns list of atom indices in layer at index.

Atoms that also appear in inner layer can be excluded on request.

Parameters:

• index (int) -- pasd

• exclude_inner (bool, default=False, optional) -- Whether to exclude atom indices that also appear in inner layers.

Returns:

atom_indices -- List containing the atom indices in the selected layer.

Return type:

list

calc_layer(atoms, coords, index, parent_correction=True)

property charge

embeddings = {'': '', 'electronic': 'Electronic embedding', 'electronic_rc': 'Electronic embedding with redistributed charges', 'electronic_rcd': 'Electronic embedding with redistributed charges and dipoles'}

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_layer_calc(layer_ind)

property model_iter

property mult

run_calculation(atoms, coords)

run_calculations(atoms, coords, method)

pysisyphus.calculators.ONIOMv2.atom_inds_to_cart_inds(atom_inds)

pysisyphus.calculators.ONIOMv2.cap_fragment(atoms, coords, fragment, link_atom='H', g=None)

pysisyphus.calculators.ONIOMv2.get_embedding_charges(embedding, layer, parent_layer, coords3d)

pysisyphus.calculators.ONIOMv2.get_g_value(atom, parent_atom, link_atom)

17.1.1.2.38. pysisyphus.calculators.ORCA module

class pysisyphus.calculators.ORCA.ORCA(keywords, blocks='', gbw=None, do_stable=False, numfreq=False, json_dump=None, wavefunction_dump=True, **kwargs)

Bases: OverlapCalculator

__init__(keywords, blocks='', gbw=None, do_stable=False, numfreq=False, json_dump=None, wavefunction_dump=True, **kwargs)

ORCA calculator.

Wrapper for creating ORCA input files for energy, gradient and Hessian calculations. The PAL and memory inputs must not be given in the keywords and/or blocks, as they are handled by the 'pal' and 'memory' arguments.

Parameters:

• keywords (str) -- Keyword line, as normally given in ORCA, excluding the leading "!".

• blocks (str, optional) -- ORCA block input(s), e.g. for TD-DFT calculations (%tddft ... end). As the blocks start with a leading "%", wrapping the input in quotes ("") is required, otherwise the parsing will fail.

• gbw (str, optional) -- Path to an input gbw file, which will be used as initial guess for the first calculation. Will be overriden later, with the path to the gbw file of a previous calculation.

• do_stable (bool, optional) -- Run stability analysis until a stable wavefunction is obtained, before every calculation.

• numfreq (bool, optional) -- Use numerical frequencies instead of analytical ones.

• json_dump (bool, optional, deprecated) -- Use 'wavefunction_dump' instead.

• wavefunction_dump (bool, optional) -- Whether to dump the wavefunction to BSON via orca_2json. The BSON can become very large in calculations comprising many basis functions.

check_termination(*args, **kwargs)

clean_tmp(path)

conf_key = 'orca'

get_all_energies(atoms, coords, **prepare_kwargs)

get_block_str()

get_chkfiles()

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_moinp_str(gbw)

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_stable_wavefunction(atoms, coords)

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

parse_all_energies(text=None, triplets=None)

parse_all_energies_from_path(path)

static parse_atoms_coords(inp, *args, **kwargs)

static parse_cis(cis)

Simple wrapper of external function.

Currently, only returns Xα and Yα.

parse_energy(path)

parse_engrad(path)

static parse_engrad_info(inp, *args, **kwargs)

static parse_gbw(gbw_fn)

static parse_hess_file(inp, *args, **kwargs)

parse_hessian(path)

parse_mo_numbers(out_fn)

parse_stable(path)

prepare_input(atoms, coords, calc_type, point_charges=None, do_stable=False)

Meant to be extended.

prepare_overlap_data(path, triplets=None)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

reattach(last_calc_cycle)

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

run_calculation(atoms, coords, **prepare_kwargs)

Basically some kind of dummy method that can be called to execute ORCA with the stored cmd of this calculator.

set_chkfiles(chkfiles)

set_mo_coeffs(mo_coeffs=None, gbw=None)

static set_mo_coeffs_in_gbw(in_gbw_fn, out_gbw_fn, mo_coeffs)

See self.parse_gbw.

store_and_track(results, func, atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.ORCA.ORCAGroundStateContext(calc)

Bases: GroundStateContext

pysisyphus.calculators.ORCA.geom_from_orca_hess(fn)

pysisyphus.calculators.ORCA.get_exc_ens_fosc(wf_fn, cis_fn, log_fn)

pysisyphus.calculators.ORCA.get_name(text)

Return string that comes before first character & offset.

pysisyphus.calculators.ORCA.make_sym_mat(table_block)

pysisyphus.calculators.ORCA.parse_orca_cis(cis_fn, restricted_same_ab=False, triplets_only=True)

Read binary CI vector file from ORCA.

Loosly based on TheoDORE 1.7.1, Authors: S. Mai, F. Plasser https://sourceforge.net/p/theodore-qc

With restricted_same_ab the alpha part will be copied over to the beta-part in restricted calculations. Otherwise the beta-part (Xb, Yb) will just be zeros in restricted calculations.

pysisyphus.calculators.ORCA.parse_orca_gbw(gbw_fn)

Adapted from https://orcaforum.kofo.mpg.de/viewtopic.php?f=8&t=3299

The first 5 long int values represent pointers into the file:

Pointer @+0: Internal ORCA data structures Pointer @+8: Geometry Pointer @+16: BasisSet Pointer @+24: Orbitals Pointer @+32: ECP data

pysisyphus.calculators.ORCA.parse_orca_gbw_new(gbw_fn)

Adapted from https://orcaforum.kofo.mpg.de/viewtopic.php?f=8&t=3299

The first 5 long int values represent pointers into the file:

Pointer @+0: Internal ORCA data structures Pointer @+8: Geometry Pointer @+16: BasisSet Pointer @+24: Orbitals Pointer @+32: ECP data

Return type:

MOCoeffs

pysisyphus.calculators.ORCA.save_orca_pc_file(point_charges, pc_fn, hardness=None)

pysisyphus.calculators.ORCA.update_gbw(gbw_in, gbw_out, alpha_mo_coeffs=None, beta_mo_coeffs=None, alpha_energies=None, alpha_occs=None, beta_energies=None, beta_occs=None)

MOs are expected to be in columns.

17.1.1.2.39. pysisyphus.calculators.ORCA5 module

class pysisyphus.calculators.ORCA5.ORCA5(keywords, blocks='', gbw=None, do_stable=False, numfreq=False, json_dump=None, wavefunction_dump=True, **kwargs)

Bases: ORCA

conf_key = 'orca5'

17.1.1.2.40. pysisyphus.calculators.OpenMM module

class pysisyphus.calculators.OpenMM.OpenMM(topology, params, **kwargs)

Bases: Calculator

get_charges()

get_dipole_moment(coords3d, reference=None, masses=None)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

report_charges()

Total charge of the system.

Adapted from modeller.py _addIons() in OpenMM.

17.1.1.2.41. pysisyphus.calculators.OpenMolcas module

class pysisyphus.calculators.OpenMolcas.OpenMolcas(basis, inporb, rasscf=None, gateway=None, mcpdft=None, rassi=None, nprocs=1, track=True, omp_var='OMP_NUM_THREADS', **kwargs)

Bases: Calculator

build_gateway_str()

build_mcpdft_str()

build_rasscf_str()

build_rassi_str()

build_str_from_dict(dct)

conf_key = 'openmolcas'

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_pal_env()

get_root()

parse_energies(text)

parse_energy(path)

parse_gradient(path)

parse_rassi_track(path)

prepare_coords(atoms, coords)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type)

Meant to be extended.

reattach(last_calc_cycle)

run_calculation(atoms, coords, calc_type='energy')

17.1.1.2.42. pysisyphus.calculators.OverlapCalculator module

class pysisyphus.calculators.OverlapCalculator.GroundStateContext(calc)

Bases: object

class pysisyphus.calculators.OverlapCalculator.NTOs(ntos, lambdas)

Bases: tuple

lambdas

Alias for field number 1

ntos

Alias for field number 0

class pysisyphus.calculators.OverlapCalculator.OverlapCalculator(*args, root=None, nroots=None, track=False, ovlp_type='tden', double_mol=False, ovlp_with='previous', adapt_args=(0.5, 0.3, 0.6), cdds=None, orient='', dump_fn='overlap_data.h5', h5_dump=False, conf_thresh=0.001, mos_ref='cur', mos_renorm=True, min_cost=False, **kwargs)

Bases: Calculator

H5_MAP = {'Ca': 'Ca_list', 'Cb': 'Cb_list', 'Xa': 'Xa_list', 'Xb': 'Xb_list', 'Ya': 'Ya_list', 'Yb': 'Yb_list', 'all_energies': 'all_energies_list', 'coords': 'coords_list', 'ref_roots': 'reference_roots', 'roots': 'roots_list'}

OVLP_TYPE_VERBOSE = {'nto': 'natural transition orbital overlap', 'nto_org': 'original natural transition orbital overlap', 'tden': 'transition density matrix overlap', 'top': 'transition orbital pair overlap', 'wf': 'wavefunction overlap'}

VALID_CDDS = (None, 'calc', 'render')

VALID_KEYS = ['wf', 'tden', 'nto', 'nto_org', 'top']

VALID_XY = ('X', 'X+Y', 'X-Y')

calc_cdd_cube(root, cycle=-1)

clear_stored_calculations()

conf_thresh

self.dyn_roots = int(dyn_roots) if self.dyn_roots != 0:

self.dyn_roots = 0 self.log("dyn_roots = 0 is hardcoded right now")

property data_model

dump_overlap_data()

static from_overlap_data(h5_fn, set_wfow=False)

get_ci_coeffs_for(ind)

get_h5_group()

get_indices(indices=None)

A new root is determined by selecting the overlap matrix row corresponding to the reference root and checking for the root with the highest overlap (at the current geometry).

The overlap matrix is usually formed by a double loop like:

overlap_matrix = np.empty((ref_states, cur_states)) for i, ref_state in enumerate(ref_states):

for j, cur_state in enumerate(cur_states):

overlap_matrix[i, j] = make_overlap(ref_state, cur_state)

So the reference states run along the rows. Thats why the ref_state index comes first in the 'indices' tuple.

static get_mo_norms(C, S_AO)

get_orbital_matrices(indices=None, S_AO=None)

Return MO coefficents and AO overlaps for the given indices.

If not provided, a AO overlap matrix is constructed from one of the MO coefficient matrices (controlled by self.mos_ref). Also, if requested one of the two MO coefficient matrices is re-normalized.

get_ref_mos(C_ref, C_cur)

static get_sao_from_mo_coeffs(C)

Recover AO overlaps from given MO coefficients.

For MOs in the columns of mo_coeffs:

S_AO = C⁻¹^T C⁻¹ S_AO C = C⁻¹^T (S_AO C)^T = C⁻¹ C^T S_AO^T = C⁻¹ C^T S_AO C = I

get_tden_overlaps(indices=None, S_AO=None)

get_top_differences(indices=None, S_AO=None)

Transition orbital projection.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

render_cdd_cube()

static renorm_mos(C, S_AO)

store_overlap_data(atoms, coords, path=None, overlap_data=None)

property stored_calculations

track_root(ovlp_type=None)

Check if a root flip occured occured compared to the previous cycle by calculating the overlap matrix wrt. a reference cycle.

pysisyphus.calculators.OverlapCalculator.args_from_calc(calc)

pysisyphus.calculators.OverlapCalculator.get_data_model(exc_state_num, occ_a, virt_a, occ_b, virt_b, ovlp_type, atoms, max_cycles)

pysisyphus.calculators.OverlapCalculator.get_ovlp_mat(Ca1, Cb1, Xa1, Ya1, Xb1, Yb1, Ca2, Cb2, Xa2, Ya2, Xb2, Yb2, S_AO, ovlp_type)

pysisyphus.calculators.OverlapCalculator.get_tden_overlaps(Ca1, Cb1, Xa1, Ya1, Xb1, Yb1, Ca2, Cb2, Xa2, Ya2, Xb2, Yb2, S_AO)

pysisyphus.calculators.OverlapCalculator.get_top_differences(Ca1, Cb1, Xa1, Ya1, Xb1, Yb1, Ca2, Cb2, Xa2, Ya2, Xb2, Yb2, S_AO)

Transition orbital projection.

pysisyphus.calculators.OverlapCalculator.root2_from_ovlp_mat_and_root1(ovlp_mat, root1, min_cost=True)

pysisyphus.calculators.OverlapCalculator.track_root(Ca1, Cb1, Xa1, Ya1, Xb1, Yb1, Ca2, Cb2, Xa2, Ya2, Xb2, Yb2, S_AO, ovlp_type, root1, min_cost=True)

pysisyphus.calculators.OverlapCalculator.track_root_between_ovlp_cals(calc1, calc2, **kwargs)

17.1.1.2.43. pysisyphus.calculators.Psi4 module

class pysisyphus.calculators.Psi4.Psi4(method, basis, to_set=None, to_import=None, pcm='iefpcm', solvent=None, write_fchk=False, **kwargs)

Bases: Calculator

conf_key = 'psi4'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_fchk_str()

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

parse_energy(path)

parse_grad(path)

parse_hessian(path)

prepare_input(atoms, coords, calc_type)

Meant to be extended.

run_calculation(atoms, coords, **prepare_kwargs)

17.1.1.2.44. pysisyphus.calculators.PyPsi4 module

class pysisyphus.calculators.PyPsi4.PyPsi4(method, basis, **kwargs)

Bases: Calculator

get_forces(atoms, coords)

Meant to be extended.

17.1.1.2.45. pysisyphus.calculators.PySCF module

17.1.1.2.46. pysisyphus.calculators.PyXTB module

class pysisyphus.calculators.PyXTB.PyXTB(*args, gfn=2, acc=None, verbosity=0, keep_calculator=False, **kwargs)

Bases: Calculator

get_calculator(atoms, coords)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

17.1.1.2.47. pysisyphus.calculators.QCEngine module

17.1.1.2.48. pysisyphus.calculators.Rastrigin module

class pysisyphus.calculators.Rastrigin.Rastrigin

Bases: AnaPotBase

http://www.sfu.ca/~ssurjano/rastr.html

17.1.1.2.49. pysisyphus.calculators.Remote module

class pysisyphus.calculators.Remote.Remote(remote_calc, host, prefix='', **kwargs)

Bases: Calculator

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

parse_results()

run_calculation(atoms, coords, run_func='get_energy')

17.1.1.2.50. pysisyphus.calculators.Rosenbrock module

class pysisyphus.calculators.Rosenbrock.Rosenbrock

Bases: AnaPotBase

17.1.1.2.51. pysisyphus.calculators.SocketCalc module

class pysisyphus.calculators.SocketCalc.SocketCalc(*args, host='localhost', port=8080, **kwargs)

Bases: Calculator

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

listen_for(atoms, coords, request)

valid_requests = ('energy', 'forces', 'hessian')

17.1.1.2.52. pysisyphus.calculators.TIP3P module

class pysisyphus.calculators.TIP3P.TIP3P(rc=9.44863062728914)

Bases: Calculator

Transferable Intermolecular Potential 3 Point

aHOH = 104.52

calculate(coords3d)

charges

coulomb_energy = (multiple of elem. charge * multiple of elem. charge)

/ (distance in bohr) * 1 / (4 * pi * vacuum permittivity)

coulomb_prefactor converts everything to atomic units and it is ... drum roll ... 1. from scipy.constants import value as pcval self.coulomb_prefactor = (1 / (4 * np.pi) * pcval("elementary charge")**2

/ pcval("Hartree energy") / pcval("Bohr radius") / pcval("vacuum electric permittivity")

)

coulomb(coords3d)

epsilon = 0.0002423919586315716

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

qH = 0.417

qO = -0.834

rOH = 1.8088458464917874

sigma = 5.953790025507198

17.1.1.2.53. pysisyphus.calculators.TransTorque module

class pysisyphus.calculators.TransTorque.TransTorque(frags, iter_frags, a_mats, b_mats, weight_func=None, skip=True, kappa=1.0, b_coords3d=None, do_trans=True)

Bases: object

__init__(frags, iter_frags, a_mats, b_mats, weight_func=None, skip=True, kappa=1.0, b_coords3d=None, do_trans=True)

Translational and torque forces. See A.4. [1], Eqs. (A3) - (A5).

get_forces(atoms, coords, kappa=None)

get_forces_naive(atoms, coords, kappa=None)

set_N_invs()

pysisyphus.calculators.TransTorque.get_trans_torque_forces(mfrag, a_coords3d, b_coords3d, a_mats, b_mats, m, frags, N_inv, weight_func=None, skip=True, kappa=1, do_trans=True)

17.1.1.2.54. pysisyphus.calculators.Turbomole module

class pysisyphus.calculators.Turbomole.ExSpectrumRoot(root, sym, exc_energy, osc_vel, osc_len)

Bases: object

exc_energy: float

osc_len: float

osc_vel: float

root: int

sym: str

class pysisyphus.calculators.Turbomole.Turbomole(control_path=None, numfreq=False, simple_input=None, double_mol_path=None, cosmo_kwargs=None, wavefunction_dump=True, **kwargs)

Bases: OverlapCalculator

append_control(to_append, log_msg='', **kwargs)

conf_key = 'turbomole'

get_all_energies(atoms, coords, **prepare_kwargs)

get_chkfiles()

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, cmd=None, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_pal_env()

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_ricc2_root(text)

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

static make_molden(path)

parse_all_energies()

parse_cc2_vectors(ccre)

parse_ci_coeffs()

parse_double_mol(path)

Parse a double molecule overlap matrix from Turbomole output to be used with WFOWrapper.

parse_energy(path)

parse_force(path)

parse_gs_energy()

Several places are possible: $subenergy from control file total energy from turbomole.out Final MP2 energy from turbomole.out with ADC(2) Final CC2 energy from turbomole.out with CC(2)

parse_hessian(path, fn=None)

parse_mos()

static parse_td_vectors(text)

For TDA calculations only the X vector is present in the ciss_a/etc. file. In TDDFT calculations there are twise as much items compared with TDA. The first half corresponds to (X+Y) and the second half to (X-Y). X can be calculated as X = ((X+Y)+(X-Y))/2. Y is then given as Y = (X+Y)-X. The normalization can then by checked as

np.concatenate((X, Y)).dot(np.concatenate((X, -Y)))

and should be 1.

static parse_tddft_tden(inp, *args, **kwargs)

prepare_input(atoms, coords, calc_type, point_charges=None)

To rectify this we have to construct the basecmd dynamically and construct it ad hoc. We could set a RI flag in the beginning and select the correct scf binary here from it. Then we select the following binary on demand, e.g. aoforce or rdgrad or egrad etc.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

prepare_point_charges(point_charges)

$point_charges <x> <y> <z> <q>

prepare_td(text)

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

run_calculation(atoms, coords, **prepare_kwargs)

run_double_mol_calculation(atoms, coords1, coords2)

set_chkfiles(chkfiles)

set_occ_and_mo_nums(text)

store_and_track(results, func, atoms, coords, **prepare_kwargs)

sub_control(pattern, repl, log_msg='', **kwargs)

class pysisyphus.calculators.Turbomole.TurbomoleGroundStateContext(calc)

Bases: GroundStateContext

pysisyphus.calculators.Turbomole.control_from_simple_input(simple_inp, charge, mult, cosmo_kwargs=None)

Create control file from 'simple input'.

See examples/opt/26_turbomole_simple_input/ for an example.

pysisyphus.calculators.Turbomole.get_cosmo_data_groups(atoms, epsilon, rsolv=None, refind=None, dcosmo_rs=None)

pysisyphus.calculators.Turbomole.get_density_matrices_for_root(log_fn, vec_fn, root, rlx_vec_fn=None, Ca=None, Cb=None)

pysisyphus.calculators.Turbomole.index_strs_for_atoms(atoms)

pysisyphus.calculators.Turbomole.parse_frozen_nmos(text)

Determine number of occ. & and virt. orbitals used in ES calculations.

Return type:

tuple[list[tuple[int, int], tuple[int, int]], bool]

pysisyphus.calculators.Turbomole.render_data_groups(raw_data_groups)

17.1.1.2.55. pysisyphus.calculators.WFOWrapper module

class pysisyphus.calculators.WFOWrapper.WFOWrapper(occ_mo_num, virt_mo_num, conf_thresh=0.001, calc_number=0, out_dir='./', wfow_mem=8000, ncore=0, debug=False)

Bases: object

ci_coeffs_above_thresh(ci_coeffs, thresh=None)

property conf_thresh

fake_turbo_mos(mo_coeffs)

Create a mos file suitable for TURBOMOLE input. All MO eigenvalues are set to 0.0. There is also a little deviation in the formatting (see turbo_fmt()) but it works ...

generate_all_dets(occ_set1, virt_set1, occ_set2, virt_set2)

Generate all possible single excitation determinant strings from union(occ_mos) to union(virt_mos).

get_from_to_sets(ci_coeffs)

get_gs_line(ci_coeffs_with_gs)

log(message)

logger = <Logger wfoverlap (DEBUG)>

make_det_string(inds)

Return spin adapted strings.

make_dets_header(cic, dets_list)

make_full_dets_list(all_inds, det_strings, ci_coeffs)

matrix_types = {'ortho': 'Orthonormalized overlap matrix', 'ovlp': 'Overlap matrix', 'renorm': 'Renormalized overlap matrix'}

parse_wfoverlap_out(text, type_='ortho')

Returns overlap matrix.

set_from_nested_list(nested)

wf_overlap(cycle1, cycle2, ao_ovlp=None)

17.1.1.2.56. pysisyphus.calculators.WFOWrapper2 module

class pysisyphus.calculators.WFOWrapper2.WFOWrapper2(overlap_data, calc_number=0, conf_thresh=0.0001, out_dir='./')

Bases: object

all_overlaps()

ci_coeffs_above_thresh(ci_coeffs, thresh=1e-05)

static fake_turbo_mos(mo_coeffs)

Create a mos file suitable for TURBOMOLE input. All MO eigenvalues are set to 0.0. There is also a little deviation in the formatting (see turbo_fmt()) but it works ...

generate_all_dets(occ_set1, virt_set1, occ_set2, virt_set2)

Generate all possible single excitation determinant strings from union(occ_mos) to union(virt_mos).

get_iteration(ind)

property last_two_coords

log(message)

logger = <Logger wfoverlap (DEBUG)>

make_det_string(inds)

Return spin adapted strings.

make_dets_header(cic, dets_list)

make_full_dets_list(all_inds, det_strings, ci_coeffs)

matrix_types = {'ortho': 'Orthonormalized overlap matrix', 'ovlp': 'Overlap matrix', 'renorm': 'Renormalized overlap matrix'}

parse_wfoverlap_out(text, type_='ortho')

Returns overlap matrix.

set_data()

set_from_nested_list(nested)

wf_overlap(ind1=-2, ind2=-1, ao_ovlp=None)

17.1.1.2.57. pysisyphus.calculators.XTB module

class pysisyphus.calculators.XTB.OptResult(opt_geom, opt_log)

Bases: tuple

opt_geom

Alias for field number 0

opt_log

Alias for field number 1

class pysisyphus.calculators.XTB.XTB(gbsa='', alpb='', gfn=2, acc=1.0, etemp=None, retry_etemp=None, restart=False, topo=None, topo_update=None, quiet=False, wavefunction_dump=False, **kwargs)

Bases: Calculator

__init__(gbsa='', alpb='', gfn=2, acc=1.0, etemp=None, retry_etemp=None, restart=False, topo=None, topo_update=None, quiet=False, wavefunction_dump=False, **kwargs)

XTB calculator.

Wrapper for running energy, gradient and Hessian calculations by XTB.

Parameters:

• gbsa (str, optional) -- Solvent for GBSA calculation, by default no solvent model is used.

• alpb (str, optional) -- Solvent for ALPB calculation, by default no solvent model is used.

• gfn (int or str, must be (0, 1, 2, or "ff")) -- Hamiltonian for the XTB calculation (GFN0, GFN1, GFN2, or GFNFF).

• acc (float, optional) -- Accuracy control of the calculation, the lower the tighter several numerical thresholds are chosen.

• topo (str, optional) -- Path the a GFNFF-topolgy file. As setting up the topology may take some time for sizable systems, it may be desired to reuse the file.

• topo_update (int) -- Integer controlling the update interval of the GFNFF topology update. If supplied, the topolgy will be recreated every N-th calculation.

• mem (int) -- Mememory per core in MB.

• quiet (bool, optional) -- Suppress creation of log files.

• wavefunction_dump (bool) -- Whether to dump a molden file.

static check_termination(inp, *args, **kwargs)

conf_key = 'xtb'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_mdrestart_str(coords, velocities)

coords and velocities have to given in au!

get_pal_env()

get_retry_args()

get_stored_wavefunction(**kwargs)

parse_charges(fn=None)

parse_charges_from_json(fn=None)

parse_energy(path)

parse_gradient(path)

parse_hessian(path)

parse_md(path)

parse_opt(path, keep_log=False)

parse_topo(path)

prepare_add_args(xcontrol=None)

prepare_coords(atoms, coords)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type, point_charges=None)

Meant to be extended.

reattach(last_calc_cycle)

run_calculation(atoms, coords, **prepare_kwargs)

run_md(atoms, coords, t, dt, velocities=None, dump=1)

Expecting t and dt in fs, even though xtb wants t in ps!

run_opt(atoms, coords, keep=True, keep_log=False)

run_topo(atoms, coords)

write_mdrestart(path, mdrestart_str)

17.1.1.2.58. pysisyphus.calculators.parser module

pysisyphus.calculators.parser.make_float_class(**kwargs)

pysisyphus.calculators.parser.parse_turbo_ccre0_ascii(text)

pysisyphus.calculators.parser.parse_turbo_exstates(text)

Parse excitation energies (first blocks) from an exstates file.

pysisyphus.calculators.parser.parse_turbo_exstates_re(text)

pysisyphus.calculators.parser.parse_turbo_gradient(path)

pysisyphus.calculators.parser.parse_turbo_mos(text)

pysisyphus.calculators.parser.to_float(s, loc, toks)

17.1.1.2.59. Module contents

class pysisyphus.calculators.AFIR(calculator, fragment_indices, gamma, rho=1, p=6, ignore_hydrogen=False, zero_hydrogen=True, complete_fragments=True, dump=True, h5_fn='afir.h5', h5_group_name='afir', **kwargs)

Bases: Calculator

__init__(calculator, fragment_indices, gamma, rho=1, p=6, ignore_hydrogen=False, zero_hydrogen=True, complete_fragments=True, dump=True, h5_fn='afir.h5', h5_group_name='afir', **kwargs)

Artifical Force Induced Reaction calculator.

Currently, there are no automated drivers to run large-scale AFIR calculations with many different initial orientations and/or increasing collision energy parameter γ. Nontheless, selected AFIR calculations can be carried out by hand. After convergence, artificial potential & forces, as well as real energies and forces can be plotted with 'pysisplot --afir'. The highest energy point along the AFIR path can then be selected for a subsequent TS-optimization, e.g. via 'pysistrj --get [index] optimzation.trj'.

Future versions of pysisyphus may provide drivers for more automatted AFIR calculations.

Parameters:

• calculator (Calculator) -- Actual QC calculator that provides energies and its derivatives, that are modified by the AFIR calculator, e.g., ORCA or Psi4.

• fragment_indices (List[List[int]]) -- List of lists of integers, specifying the separate fragments. If the indices in theses lists don't comprise all atoms in the molecule, the reamining indices will be added as a separate fragment. If a AFIR calculation is carried out with 2 fragments and 'complete_fragments' is True (see below) it is enough to specify only the indices of one fragment, e.g., for a system of 10 atoms 'fragment_indices=[[0,1,2,3]]' is enough. The second system will be set up automatically with indices [4,5,6,7,8,9].

• gamma (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]) -- Collision energy parameter γ in au. For 2 fragments it can be a single integer, while for > 2 fragments a list of gammas must be given, specifying the pair-wise collision energy parameters. For 3 fragments 3 gammas must be given [γ_01, γ_02, γ_12], for 4 fragments 6 gammas would be required [γ_01, γ_02, γ_03, γ_12, γ_13, γ_23] and so on.

• rho (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]], default: 1) -- Direction of the artificial force, either 1 or -1. The same comments as for gamma apply. For 2 fragments a single integer is enough, for > 2 fragments a list of rhos must be given (see above). For rho=1 fragments are pushed together, for rho=-1 fragments are pulled apart.

• p (int, default: 6) -- Exponent p used in the calculation of the weight function ω. Defaults to 6 and probably does not have to be changed.

• ignore_hydrogen (bool, default: False) -- Whether hydrogens are ignored in the calculation of the artificial force. All weights between atom pairs containing hydrogen will be set to 0.

• zero_hydrogen (bool, default: True) -- Whether to use 0.0 as covalent radius for hydrogen in the weight function. Compared to 'ignore_hydrogen', which results in zero weights for all atom pairs involving hydrogen, 'zero_hydrogen' may be non-zero, depending on the covalent radius of the second atom in the pair.

• complete_fragments (bool, default: True) -- Whether an incomplete specification in 'fragment_indices' is automatically completed.

• dump (bool, default: True) -- Whether an HDF5 file is created.

• h5_fn (str, default: 'afir.h5') -- Filename of the HDF5 file used for dumping.

• h5_group_name (str, default: 'afir') -- HDF5 group name used for dumping.

• **kwargs -- Keyword arguments passed to the Calculator baseclass.

afir_fd_hessian_wrapper(coords3d, afir_grad_func)

property charge

dump_h5(atoms, coords, results)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

init_h5_group(atoms, max_cycles=None)

log_fragments()

property mult

set_atoms_and_funcs(atoms, coords)

Initially atoms was also an argument to the constructor of AFIR. I removed it so creation becomes easier. The first time a calculation is requested with a proper atom set everything is set up (cov. radii, afir function and corresponding gradient). Afterwards there is only a check if atoms != None and it is expected that all functions are properly set.

fragment_indices can also be incomplete w.r.t. to the number of atoms. If the sum of the specified fragment atoms is less than the number of atoms present then all remaining unspecified atoms will be gathered in one fragment.

write_fragment_geoms(atoms, coords)

class pysisyphus.calculators.AtomAtomTransTorque(geom, frags, A_mats, kappa=2.0)

Bases: object

__init__(geom, frags, A_mats, kappa=2.0)

Atom-atom translational and torque forces.

See A.5. [1], Eq. (A6).

get_forces(atoms, coords)

class pysisyphus.calculators.Composite(final, keys_calcs=None, calcs=None, remove_translation=False, **kwargs)

Bases: Calculator

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_final_energy(energies)

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

run_calculation(atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.ConicalIntersection(calculator1, calculator2, **kwargs)

Bases: Calculator

Calculator for conical intersection optimization.

Based on [1].

get_ci_quantities(atoms, coords, **prepare_kwargs)

Relavent quantities including branching plane and projector P.

get_energy(atoms, coords, **prepare_kwargs)

Energy of calculator 1.

get_forces(atoms, coords, **prepare_kwargs)

Projected gradient for CI optimization.

get_hessian(atoms, coords, **prepare_kwargs)

Projected Hessian.

class pysisyphus.calculators.DFTBp(parameter, *args, slakos=None, **kwargs)

Bases: OverlapCalculator

conf_key = 'dftbp'

get_all_energies(atoms, coords, **prepare_kwargs)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

static get_excited_state_str(track, root, nroots, forces=False)

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

static get_gen_str(atoms, coords)

hubbard_derivs = {'3ob': {'Br': -0.0573, 'C': -0.1492, 'Ca': -0.034, 'Cl': -0.0697, 'F': -0.1623, 'H': -0.1857, 'I': -0.0433, 'K': -0.0339, 'Mg': -0.02, 'N': -0.1535, 'Na': -0.0454, 'O': -0.1575, 'P': -0.14, 'S': -0.11, 'Zn': -0.03}}

max_ang_moms = {'3ob': {'Br': 'd', 'C': 'p', 'Ca': 'p', 'Cl': 'd', 'F': 'p', 'H': 's', 'I': 'd', 'K': 'p', 'Mg': 'p', 'N': 'p', 'Na': 'p', 'O': 'p', 'P': 'd', 'S': 'd', 'Zn': 'd'}, 'mio-ext': {'C': 'p', 'H': 's', 'N': 'p', 'O': 'p'}}

parse_all_energies(out_fn=None, exc_dat=None)

parse_energy(path)

static parse_exc_dat(text)

parse_forces(path)

parse_total_energy(text)

prepare_input(atoms, coords, calc_type)

Meant to be extended.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

run_calculation(atoms, coords, **prepare_kwargs)

store_and_track(results, func, atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.DFTD4(method=None, damp_params=None, model_params=None, **kwargs)

Bases: Calculator

get_dispersion(atoms, coords, grad)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_model(atoms, coords)

class pysisyphus.calculators.Dimer(calculator, *args, N_raw=None, length=0.0189, rotation_max_cycles=15, rotation_method='fourier', rotation_thresh=0.0001, rotation_tol=1, rotation_max_element=0.001, rotation_interpolate=True, rotation_disable=False, rotation_disable_pos_curv=True, rotation_remove_trans=True, trans_force_f_perp=True, bonds=None, N_hessian=None, bias_rotation=False, bias_translation=False, bias_gaussian_dot=0.1, seed=None, write_orientations=True, forward_hessian=True, **kwargs)

Bases: Calculator

property C

Shortcut for the curvature.

property N

add_gaussian(atoms, center, N, height=0.1, std=0.0529, max_cycles=50, dot_ref=None)

property can_bias_f0

property can_bias_f1

property coords0

property coords1

curvature(f1, f2, N)

Curvature of the mode represented by the dimer.

direct_rotation(optimizer, prev_step)

do_dimer_rotations(rotation_thresh=None)

property energy0

property f0

property f1

property f1_bias

property f2

Never calculated explicitly, but estimated from f0 and f1.

fourier_rotation(optimizer, prev_step)

get_N_raw_from_hessian(h5_fn, root=0)

get_forces(atoms, coords)

Meant to be extended.

get_gaussian_energies(coords, sum_=True)

get_gaussian_forces(coords, sum_=True)

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

remove_translation(displacement)

property rot_force

rotate_coords1(rad, theta)

Rotate dimer and produce new coords1.

set_N_raw(coords)

property should_bias_f0

May lead to calculation of f0 and/or f1 if present!

property should_bias_f1

May lead to calculation of f0 and/or f1 if present!

update_orientation(coords)

class pysisyphus.calculators.Dummy(calc_number=0, charge=0, mult=1, base_name='calculator', pal=1, mem=1000, keep_kind='all', check_mem=True, retry_calc=0, last_calc_cycle=None, clean_after=True, out_dir='qm_calcs', force_num_hess=False, num_hess_kwargs=None)

Bases: Calculator

get_energy(*args, **kwargs)

Meant to be extended.

get_forces(*args, **kwargs)

Meant to be extended.

get_hessian(*args, **kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

raise_exception()

run_calculation(*args, **kwargs)

class pysisyphus.calculators.EGO(calculator, ref_geom, max_force=0.175, **kwargs)

Bases: Calculator

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_mods(atoms, coords)

property ref_hessian

property s

class pysisyphus.calculators.EnergyMin(calculator1, calculator2, mix=False, alpha=0.02, sigma=3.5, min_energy_diff=0.0, check_after=0, **kwargs)

Bases: Calculator

__init__(calculator1, calculator2, mix=False, alpha=0.02, sigma=3.5, min_energy_diff=0.0, check_after=0, **kwargs)

Use energy and derivatives of the calculator with lower energy.

This calculators carries out two calculations with different settings and returns the results of the lower energy one. This can be used to consider flips between a singlet and a triplet PES etc.

Parameters:

• calculator1 (Calculator) -- Wrapped QC calculator that provides energies and its derivatives.

• calculator2 (Calculator) -- Wrapped QC calculator that provides energies and its derivatives.

• mix (bool, default: False) -- Enable mixing of both forces, according to the approach outlined in [2]. Can be used to optimize guesses for MECPs. Pass

• alpha (float, default: 0.02) -- Smoothing parameter in Hartree. See [2] for a discussion.

• sigma (float, default: 3.5) -- Unitless gap size parameter. The final gap becomes smaller for bigga sigmas. Has to be adapted for each case. See [2] for a discussion (p. 407 right column and p. 408 left column.)

• min_energy_diff (float, default: 0.0) -- Energy difference in Hartree. When set to a value != 0 and the energy difference between both calculators drops below this value, execution of both calculations is diabled for 'check_after' cycles. In these cycles the calculator choice remains fixed. After 'check_after' cycles, both energies will be calculated and it is checked, if the previous calculator choice remains valid. In conjunction with 'check_after' both arguments can be used to save computational ressources.

• check_after (int, default: 0) -- Amount of cycles in which the calculator choice remains fixed.

• **kwargs -- Keyword arguments passed to the Calculator baseclass.

do_calculations(name, atoms, coords, **prepare_kwargs)

get_chkfiles()

Return type:

dict

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

set_chkfiles(chkfiles)

class pysisyphus.calculators.ExternalPotential(calculator=None, potentials=None, geom=None, **kwargs)

Bases: Calculator

available_potentials = {'d3': <class 'pysisyphus.calculators.DFTD3.DFTD3'>, 'harmonic_sphere': <class 'pysisyphus.calculators.ExternalPotential.HarmonicSphere'>, 'logfermi': <class 'pysisyphus.calculators.ExternalPotential.LogFermi'>, 'restraint': <class 'pysisyphus.calculators.ExternalPotential.Restraint'>, 'rmsd': <class 'pysisyphus.calculators.ExternalPotential.RMSD'>}

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_potential_energy(coords)

get_potential_forces(coords)

class pysisyphus.calculators.FakeASE(calc)

Bases: object

get_atoms_coords(atoms)

get_forces(atoms=None)

get_potential_energy(atoms=None)

class pysisyphus.calculators.Gaussian09(*args, **kwargs)

Bases: Gaussian16

conf_key = 'gaussian09'

class pysisyphus.calculators.Gaussian16(route, gbs='', gen='', keep_chk=False, wavefunction_dump=True, stable='', fchk=None, iop9_40=3, **kwargs)

Bases: OverlapCalculator

conf_key = 'gaussian16'

get_all_energies(atoms, coords, **prepare_kwargs)

get_chkfiles()

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

make_exc_str()

make_fchk(path)

make_gbs_str()

parse_635r_dump(dump_path, roots, nmos)

parse_all_energies(fchk=None)

parse_charges(path=None)

parse_double_mol(path, out_fn=None)

parse_energy(path)

static parse_fchk(fchk_path, keys)

parse_force(path)

parse_hessian(path)

parse_keyword(text)

parse_log(*args, **kwargs)

parse_stable(path)

parse_tddft(path)

prepare_input(atoms, coords, calc_type, did_stable=False, point_charges=None)

Meant to be extended.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

reuse_data(path)

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

run_calculation(atoms, coords, **prepare_kwargs)

run_double_mol_calculation(atoms, coords1, coords2)

run_rwfdump(path, rwf_index, chk_path=None)

run_stable(atoms, coords, **prepare_kwargs)

set_chkfiles(chkfiles)

store_and_track(results, func, atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.HardSphere(geom, frags, kappa=1.0, permutations=False, frag_radii=None, radii_offset=0.9452)

Bases: object

__init__(geom, frags, kappa=1.0, permutations=False, frag_radii=None, radii_offset=0.9452)

Intra-Image Inter-Molecular Hard-Sphere force.

See A.2. in [1], Eq. (A1).

get_forces(atoms, coords, kappa=None)

class pysisyphus.calculators.IPIServer(*args, address=None, host=None, port=None, unlink=True, hdrlen=12, max_retries=0, verbose=False, **kwargs)

Bases: Calculator

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

listen_for(atoms, coords, kind='forces')

listen_for_client_atom_num(atom_num)

listen_for_energy()

listen_for_forces(atom_num)

listen_for_hessian(atom_num)

listen_kinds = ('coords', 'energy', 'forces', 'hessian')

reset_client_connection()

retried_listen_for(atoms, coords)

unlink(address)

class pysisyphus.calculators.LennardJones(sigma=1.8897261251, epsilon=1, rc=None)

Bases: Calculator

calculate(coords3d)

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

class pysisyphus.calculators.MOPAC(method='PM7', **kwargs)

Bases: Calculator

http://openmopac.net/manual/

CALC_TYPES = {'energy': '1SCF', 'gradient': '1SCF GRADIENTS', 'hessian': 'DFORCE FORCE LET'}

METHODS = ['am1', 'pm3', 'pm6', 'pm6-dh2', 'pm6-d3', 'pm6-dh+', 'pm6-dh2', 'pm6-dh2x', 'pm6-d3h4', 'pm6-d3h4x', 'pm7', 'pm7-ts']

MULT_STRS = {1: 'SINGLET', 2: 'DOUBLET', 3: 'TRIPLET', 4: 'QUARTET', 5: 'QUINTET', 6: 'SEXTET', 7: 'SEPTET', 8: 'OCTET'}

base_cmd

Do only SCF AUX: Creates a checkpoint file NOREO: Dont reorient geometry

Type:

1SCF

conf_key = 'mopac'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

parse_energy(path)

static parse_energy_from_aux(inp, *args, **kwargs)

parse_grad(path)

parse_hessian(path)

static parse_hessian_from_aux(inp, *args, **kwargs)

prepare_coords(atoms, coords, opt=False)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type, opt=False)

Meant to be extended.

read_aux(path)

run_calculation(atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.MultiCalc(calcs, **kwargs)

Bases: Calculator

run_calculation(atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.OBabel(ff='gaff', mol=None, **kwargs)

Bases: Calculator

conv_dict = {'kcal/mol': 627.5094740630558, 'kj/mol': 2625.4996394798254}

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

setup(atoms, coords)

class pysisyphus.calculators.ONIOM(calcs, models, geom, layers=None, embedding='', real_key='real', use_link_atoms=True, *args, **kwargs)

Bases: Calculator

__init__(calcs, models, geom, layers=None, embedding='', real_key='real', use_link_atoms=True, *args, **kwargs)

layer: list of models

len(layer) == 1: normal ONIOM, len(layer) >= 1: multicenter ONIOM.

model:

(sub)set of all atoms that resides in a certain layer and has a certain calculator.

atom_inds_in_layer(index, exclude_inner=False)

Returns list of atom indices in layer at index.

Atoms that also appear in inner layer can be excluded on request.

Parameters:

• index (int) -- pasd

• exclude_inner (bool, default=False, optional) -- Whether to exclude atom indices that also appear in inner layers.

Returns:

atom_indices -- List containing the atom indices in the selected layer.

Return type:

list

calc_layer(atoms, coords, index, parent_correction=True)

property charge

embeddings = {'': '', 'electronic': 'Electronic embedding', 'electronic_rc': 'Electronic embedding with redistributed charges', 'electronic_rcd': 'Electronic embedding with redistributed charges and dipoles'}

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_hessian(atoms, coords)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_layer_calc(layer_ind)

property model_iter

property mult

run_calculation(atoms, coords)

run_calculations(atoms, coords, method)

class pysisyphus.calculators.ORCA(keywords, blocks='', gbw=None, do_stable=False, numfreq=False, json_dump=None, wavefunction_dump=True, **kwargs)

Bases: OverlapCalculator

__init__(keywords, blocks='', gbw=None, do_stable=False, numfreq=False, json_dump=None, wavefunction_dump=True, **kwargs)

ORCA calculator.

Wrapper for creating ORCA input files for energy, gradient and Hessian calculations. The PAL and memory inputs must not be given in the keywords and/or blocks, as they are handled by the 'pal' and 'memory' arguments.

Parameters:

• keywords (str) -- Keyword line, as normally given in ORCA, excluding the leading "!".

• blocks (str, optional) -- ORCA block input(s), e.g. for TD-DFT calculations (%tddft ... end). As the blocks start with a leading "%", wrapping the input in quotes ("") is required, otherwise the parsing will fail.

• gbw (str, optional) -- Path to an input gbw file, which will be used as initial guess for the first calculation. Will be overriden later, with the path to the gbw file of a previous calculation.

• do_stable (bool, optional) -- Run stability analysis until a stable wavefunction is obtained, before every calculation.

• numfreq (bool, optional) -- Use numerical frequencies instead of analytical ones.

• json_dump (bool, optional, deprecated) -- Use 'wavefunction_dump' instead.

• wavefunction_dump (bool, optional) -- Whether to dump the wavefunction to BSON via orca_2json. The BSON can become very large in calculations comprising many basis functions.

check_termination(*args, **kwargs)

clean_tmp(path)

conf_key = 'orca'

get_all_energies(atoms, coords, **prepare_kwargs)

get_block_str()

get_chkfiles()

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_moinp_str(gbw)

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_stable_wavefunction(atoms, coords)

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

parse_all_energies(text=None, triplets=None)

parse_all_energies_from_path(path)

static parse_atoms_coords(inp, *args, **kwargs)

static parse_cis(cis)

Simple wrapper of external function.

Currently, only returns Xα and Yα.

parse_energy(path)

parse_engrad(path)

static parse_engrad_info(inp, *args, **kwargs)

static parse_gbw(gbw_fn)

static parse_hess_file(inp, *args, **kwargs)

parse_hessian(path)

parse_mo_numbers(out_fn)

parse_stable(path)

prepare_input(atoms, coords, calc_type, point_charges=None, do_stable=False)

Meant to be extended.

prepare_overlap_data(path, triplets=None)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

reattach(last_calc_cycle)

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

run_calculation(atoms, coords, **prepare_kwargs)

Basically some kind of dummy method that can be called to execute ORCA with the stored cmd of this calculator.

set_chkfiles(chkfiles)

set_mo_coeffs(mo_coeffs=None, gbw=None)

static set_mo_coeffs_in_gbw(in_gbw_fn, out_gbw_fn, mo_coeffs)

See self.parse_gbw.

store_and_track(results, func, atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.ORCA5(keywords, blocks='', gbw=None, do_stable=False, numfreq=False, json_dump=None, wavefunction_dump=True, **kwargs)

Bases: ORCA

conf_key = 'orca5'

class pysisyphus.calculators.OpenMolcas(basis, inporb, rasscf=None, gateway=None, mcpdft=None, rassi=None, nprocs=1, track=True, omp_var='OMP_NUM_THREADS', **kwargs)

Bases: Calculator

build_gateway_str()

build_mcpdft_str()

build_rasscf_str()

build_rassi_str()

build_str_from_dict(dct)

conf_key = 'openmolcas'

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

get_pal_env()

get_root()

parse_energies(text)

parse_energy(path)

parse_gradient(path)

parse_rassi_track(path)

prepare_coords(atoms, coords)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type)

Meant to be extended.

reattach(last_calc_cycle)

run_calculation(atoms, coords, calc_type='energy')

class pysisyphus.calculators.Psi4(method, basis, to_set=None, to_import=None, pcm='iefpcm', solvent=None, write_fchk=False, **kwargs)

Bases: Calculator

conf_key = 'psi4'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_fchk_str()

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

parse_energy(path)

parse_grad(path)

parse_hessian(path)

prepare_input(atoms, coords, calc_type)

Meant to be extended.

run_calculation(atoms, coords, **prepare_kwargs)

class pysisyphus.calculators.PyPsi4(method, basis, **kwargs)

Bases: Calculator

get_forces(atoms, coords)

Meant to be extended.

class pysisyphus.calculators.PyXTB(*args, gfn=2, acc=None, verbosity=0, keep_calculator=False, **kwargs)

Bases: Calculator

get_calculator(atoms, coords)

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

class pysisyphus.calculators.Remote(remote_calc, host, prefix='', **kwargs)

Bases: Calculator

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

parse_results()

run_calculation(atoms, coords, run_func='get_energy')

class pysisyphus.calculators.RobinDayClass2(en_barr, en_above_barr, en_above_gs_min, sep, ref_coords=None, flip_epos=False, **kwargs)

Bases: Calculator

1D model of Robin-Day Class II mixed-valence system with 2 states.

4500 +------------------------------------------------+

|

|

4000 | |

|

|

3500 |** **|

* * |

** ** |

3000 | * * |

| **** **** |

| **** **** |

2500 | | **** |

| | |

| | |

2000 | | | |

| | |

en_above_gs_min en_above_barr |

1500 | | | |

|* |<-----sep/2---->| | |* | | *|

1000 | * | ** *|

* | * | * * |

* | ** | ** * |

500 | * | ** en_barr ** * |

* | * | * * |

* | * | * * |

0 +------------------------------------------------+ -0.3 -0.2 -0.1 0 0.1 0.2 0.3

Parameters:

• en_barr (float) -- Barrier height in the GS at x = 0.0

• en_above_barr (float) -- Energy difference between potential value in the ES at x = 0.0 and the barrier height.

• en_above_gs_min (float) -- Energy in the ES above the GS minimum.

• ref_coords (Optional[ndarray], default: None) -- Reference coordinates that will be substracted from the provided coordinates when get_energy() is called. This allows this calculator to be used with an actual Geometry.

• flip -- Whether the logistic function mimicing the electron-position along the curve is mirrored at the line passing through the midpoint.

Returns:

Pysisyphus calculator. Atom argument is ignored and only the FIRST item of the provided coordinates is utilized as argument to the analytical potentials.

Return type:

calculator

get_energy(atoms, coords)

Meant to be extended.

class pysisyphus.calculators.TIP3P(rc=9.44863062728914)

Bases: Calculator

Transferable Intermolecular Potential 3 Point

aHOH = 104.52

calculate(coords3d)

charges

coulomb_energy = (multiple of elem. charge * multiple of elem. charge)

/ (distance in bohr) * 1 / (4 * pi * vacuum permittivity)

coulomb_prefactor converts everything to atomic units and it is ... drum roll ... 1. from scipy.constants import value as pcval self.coulomb_prefactor = (1 / (4 * np.pi) * pcval("elementary charge")**2

/ pcval("Hartree energy") / pcval("Bohr radius") / pcval("vacuum electric permittivity")

)

coulomb(coords3d)

epsilon = 0.0002423919586315716

get_energy(atoms, coords)

Meant to be extended.

get_forces(atoms, coords)

Meant to be extended.

qH = 0.417

qO = -0.834

rOH = 1.8088458464917874

sigma = 5.953790025507198

class pysisyphus.calculators.TransTorque(frags, iter_frags, a_mats, b_mats, weight_func=None, skip=True, kappa=1.0, b_coords3d=None, do_trans=True)

Bases: object

__init__(frags, iter_frags, a_mats, b_mats, weight_func=None, skip=True, kappa=1.0, b_coords3d=None, do_trans=True)

Translational and torque forces. See A.4. [1], Eqs. (A3) - (A5).

get_forces(atoms, coords, kappa=None)

get_forces_naive(atoms, coords, kappa=None)

set_N_invs()

class pysisyphus.calculators.Turbomole(control_path=None, numfreq=False, simple_input=None, double_mol_path=None, cosmo_kwargs=None, wavefunction_dump=True, **kwargs)

Bases: OverlapCalculator

append_control(to_append, log_msg='', **kwargs)

conf_key = 'turbomole'

get_all_energies(atoms, coords, **prepare_kwargs)

get_chkfiles()

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, cmd=None, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_pal_env()

get_relaxed_density(atoms, coords, root, **prepare_kwargs)

Meant to be extended.

get_ricc2_root(text)

get_stored_wavefunction(**kwargs)

get_wavefunction(atoms, coords, **prepare_kwargs)

Meant to be extended.

static make_molden(path)

parse_all_energies()

parse_cc2_vectors(ccre)

parse_ci_coeffs()

parse_double_mol(path)

Parse a double molecule overlap matrix from Turbomole output to be used with WFOWrapper.

parse_energy(path)

parse_force(path)

parse_gs_energy()

Several places are possible: $subenergy from control file total energy from turbomole.out Final MP2 energy from turbomole.out with ADC(2) Final CC2 energy from turbomole.out with CC(2)

parse_hessian(path, fn=None)

parse_mos()

static parse_td_vectors(text)

For TDA calculations only the X vector is present in the ciss_a/etc. file. In TDDFT calculations there are twise as much items compared with TDA. The first half corresponds to (X+Y) and the second half to (X-Y). X can be calculated as X = ((X+Y)+(X-Y))/2. Y is then given as Y = (X+Y)-X. The normalization can then by checked as

np.concatenate((X, Y)).dot(np.concatenate((X, -Y)))

and should be 1.

static parse_tddft_tden(inp, *args, **kwargs)

prepare_input(atoms, coords, calc_type, point_charges=None)

To rectify this we have to construct the basecmd dynamically and construct it ad hoc. We could set a RI flag in the beginning and select the correct scf binary here from it. Then we select the following binary on demand, e.g. aoforce or rdgrad or egrad etc.

prepare_overlap_data(path)

This method has to implement the calculator specific parsing of MO-coefficients, CI-coefficients and energies. Should return a filename pointing to TURBOMOLE like mos, a MO coefficient array and a CI coefficient array.

prepare_point_charges(point_charges)

$point_charges <x> <y> <z> <q>

prepare_td(text)

run_after(path)

Meant to be extended.

This method is called after a calculation was done, but before entering self.keep() and self.clean(). Can be used to call tools like formchk or ricctools.

run_calculation(atoms, coords, **prepare_kwargs)

run_double_mol_calculation(atoms, coords1, coords2)

set_chkfiles(chkfiles)

set_occ_and_mo_nums(text)

store_and_track(results, func, atoms, coords, **prepare_kwargs)

sub_control(pattern, repl, log_msg='', **kwargs)

class pysisyphus.calculators.XTB(gbsa='', alpb='', gfn=2, acc=1.0, etemp=None, retry_etemp=None, restart=False, topo=None, topo_update=None, quiet=False, wavefunction_dump=False, **kwargs)

Bases: Calculator

__init__(gbsa='', alpb='', gfn=2, acc=1.0, etemp=None, retry_etemp=None, restart=False, topo=None, topo_update=None, quiet=False, wavefunction_dump=False, **kwargs)

XTB calculator.

Wrapper for running energy, gradient and Hessian calculations by XTB.

Parameters:

• gbsa (str, optional) -- Solvent for GBSA calculation, by default no solvent model is used.

• alpb (str, optional) -- Solvent for ALPB calculation, by default no solvent model is used.

• gfn (int or str, must be (0, 1, 2, or "ff")) -- Hamiltonian for the XTB calculation (GFN0, GFN1, GFN2, or GFNFF).

• acc (float, optional) -- Accuracy control of the calculation, the lower the tighter several numerical thresholds are chosen.

• topo (str, optional) -- Path the a GFNFF-topolgy file. As setting up the topology may take some time for sizable systems, it may be desired to reuse the file.

• topo_update (int) -- Integer controlling the update interval of the GFNFF topology update. If supplied, the topolgy will be recreated every N-th calculation.

• mem (int) -- Mememory per core in MB.

• quiet (bool, optional) -- Suppress creation of log files.

• wavefunction_dump (bool) -- Whether to dump a molden file.

static check_termination(inp, *args, **kwargs)

conf_key = 'xtb'

get_energy(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_forces(atoms, coords, **prepare_kwargs)

Meant to be extended.

get_hessian(atoms, coords, **prepare_kwargs)

Get Hessian matrix. Fall back to numerical Hessian, if not overriden.

Preferrably, this method should provide an analytical Hessian.

get_mdrestart_str(coords, velocities)

coords and velocities have to given in au!

get_pal_env()

get_retry_args()

get_stored_wavefunction(**kwargs)

parse_charges(fn=None)

parse_charges_from_json(fn=None)

parse_energy(path)

parse_gradient(path)

parse_hessian(path)

parse_md(path)

parse_opt(path, keep_log=False)

parse_topo(path)

prepare_add_args(xcontrol=None)

prepare_coords(atoms, coords)

Get 3d coords in Angstrom.

Reshape internal 1d coords to 3d and convert to Angstrom.

Parameters:

• atoms (iterable) -- Atom descriptors (element symbols).

• coords (np.array, 1d) -- 1D-array holding coordinates in Bohr.

Returns:

coords -- 3D-array holding coordinates in Angstrom.

Return type:

np.array, 3d

prepare_input(atoms, coords, calc_type, point_charges=None)

Meant to be extended.

reattach(last_calc_cycle)

run_calculation(atoms, coords, **prepare_kwargs)

run_md(atoms, coords, t, dt, velocities=None, dump=1)

Expecting t and dt in fs, even though xtb wants t in ps!

run_opt(atoms, coords, keep=True, keep_log=False)

run_topo(atoms, coords)

write_mdrestart(path, mdrestart_str)