17.1. pysisyphus package

17.1.1. Subpackages

17.1.2. Submodules

17.1.3. pysisyphus.Geometry module

class pysisyphus.Geometry.Geometry(atoms, coords, fragments=None, coord_type='cart', coord_kwargs=None, isotopes=None, freeze_atoms=None, remove_com=False, remove_centroid=False, comment='', name='')[source]

Bases: object

__init__(atoms, coords, fragments=None, coord_type='cart', coord_kwargs=None, isotopes=None, freeze_atoms=None, remove_com=False, remove_centroid=False, comment='', name='')[source]

Object representing atoms in a coordinate system.

The Geometry represents atoms and their positions in coordinate system. By default cartesian coordinates are used, but internal coordinates are also possible.

Parameters:

  • atoms (iterable) -- Iterable of length N, containing element symbols.

  • coords (1d iterable) -- 1d iterable of length 3N, containing the cartesian coordinates of N atoms.

  • fragments (dict, optional) -- Dict with different keys denoting different fragments. The values contain lists of atom indices.

  • coord_type ({"cart", "redund"}, optional) -- Type of coordinate system to use. Right now cartesian (cart) and redundand (redund) are supported.

  • coord_kwargs (dict, optional) -- Dictionary containing additional arguments that get passed to the constructor of the internal coordinate class.

  • isotopes (iterable of pairs, optional) -- Iterable of pairs consisting of 0-based atom index and either an integer or a float. If an integer is given the closest isotope mass will be selected. Given a float, this float will be directly used as mass.

  • freeze_atoms (iterable of integers) -- Specifies which atoms should remain fixed at their initial positions.

  • remove_com (bool, optional) -- Move center of mass to the origin.

  • remove_centroid (bool, optional) -- Move centroid to the origin.

  • comment (str, optional) -- Comment string.

  • name (str, optional) -- Verbose name of the geometry, e.g. methanal or water. Used for printing

align_principal_axes()[source]

Align the principal axes to the cartesian axes.

https://math.stackexchange.com/questions/145023

property all_energies

Return energies of all states that were calculated.

This will also set self.energy, which may NOT be the ground state, but the state correspondig to the 'root' attribute of the calculator.

approximate_radius()[source]

Approximate molecule radius from the biggest atom distance along an axis.

as_ascii_art()[source]

ASCII-art representation of the Geometry.

Using code from gpaw. Requires an ase installation.

Return type:

str

as_ase_atoms(vacuum=None)[source]
as_g98_list()[source]

Returns data for fake Gaussian98 standard orientation output.

Returns:

g98_list -- List with one row per atom. Every row contains [center number, atomic number, atomic type (always 0 for now), X Y Z coordinates in Angstrom.

Return type:

list

as_xyz(comment='', atoms=None, cart_coords=None)[source]

Current geometry as a string in XYZ-format.

Parameters:

  • comment (str, optional) -- Will be written in the second line (comment line) of the XYZ-string.

  • cart_coords (np.array, 1d, shape (3 * atoms.size, )) -- Cartesians for dumping instead of self._coords.

Returns:

xyz_str -- Current geometry as string in XYZ-format.

Return type:

str

assert_cart_coords(coords)[source]
assert_compatibility(other)[source]

Assert that two Geometries can be substracted from each other.

Parameters:

other (Geometry) -- Geometry for comparison.

atom_indices()[source]

Dict with atom types as key and corresponding indices as values.

Returns:

inds_dict -- Unique atom types as keys, corresponding indices as values.

Return type:

dict

property atom_types
atom_xyz_iter()[source]
property atomic_numbers
property bond_sets
calc_double_ao_overlap(geom2)[source]
calc_energy()[source]

Force energy calculation at the current coordinates.

calc_energy_and_forces()[source]

Force energy and forces calculation at the current coordinates.

calc_relaxed_density(root, **prepare_kwargs)[source]

Calculate a relaxed excited state density via an ES gradient calculation.

The question is, if this method should set the wavefunction property at the current Geometry. On one hand, staying in pure python w/o numba the wavefunction sanity-check can become costly, even though it shouldn't be. On the other hand, setting the wavefunction would ensure consistency between the levels of theory used for density and wavefunction.

For now, calculating an ES density does not set a wavefunction on the Geometry, whereas requesting the relaxed density for the GS does.

TODO: add flag that allows setting the wavefunction (WF). Then, calculators should also include the WF in their results.

calc_wavefunction(**prepare_kwargs)[source]
property cart_coords
property cart_forces
property cart_gradient
property cart_hessian
center()[source]
property center_of_mass

Returns the center of mass.

Returns:

R -- Center of mass.

Return type:

np.array, shape(3, )

center_of_mass_at(coords3d)[source]

Returns the center of mass at given coords3d.

Parameters:

coords3d (np.array, shape(N, 3)) -- Cartesian coordiantes.

Returns:

R -- Center of mass.

Return type:

np.array, shape(3, )

property centroid

Geometric center of the Geometry.

Returns:

R -- Geometric center of the Geometry.

Return type:

np.array, shape(3, )

clear()[source]

Reset the object state.

property comment
coord_types = {'cart': None, 'cartesian': <class 'pysisyphus.intcoords.CartesianCoords.CartesianCoords'>, 'dlc': <class 'pysisyphus.intcoords.DLC.DLC'>, 'hdlc': <class 'pysisyphus.intcoords.DLC.HDLC'>, 'hredund': <class 'pysisyphus.intcoords.RedundantCoords.HybridRedundantCoords'>, 'mwcartesian': <class 'pysisyphus.intcoords.CartesianCoords.MWCartesianCoords'>, 'redund': <class 'pysisyphus.intcoords.RedundantCoords.RedundantCoords'>, 'tmtric': <class 'pysisyphus.intcoords.RedundantCoords.TMTRIC'>, 'tric': <class 'pysisyphus.intcoords.RedundantCoords.TRIC'>}
property coords

1d vector of atomic coordinates.

Returns:

coords -- 1d array holding the current coordinates.

Return type:

np.array

property coords3d

Coordinates in 3d.

Returns:

coords3d -- Coordinates of the Geometry as 2D array.

Return type:

np.array

property coords_by_type

Coordinates in 3d by atom type and their corresponding indices.

Returns:

  • cbt (dict) -- Dictionary with the unique atom types of the Geometry as keys. It's values are the 3d coordinates of the corresponding atom type.

  • inds (dict) -- Dictionary with the unique atom types of the Geometry as keys. It's values are the original indices of the 3d coordinates in the whole coords3d array.

copy(coord_type=None, coord_kwargs=None)[source]

Returns a new Geometry object with same atoms and coordinates.

Parameters:

  • coord_type (str) -- Desired coord_type, defaults to current coord_type.

  • coord_kwargs (dict, optional) -- Any desired coord_kwargs that will be passed to the RedundantCoords object.

Returns:

geom -- New Geometry object with the same atoms and coordinates.

Return type:

Geometry

copy_all(coord_type=None, coord_kwargs=None)[source]
property covalent_radii
del_atoms(inds, **kwargs)[source]
describe()[source]
dump_trj(fn, trj_cart_coords, **kwargs)[source]
dump_xyz(fn, cart_coords=None, **kwargs)[source]
eckart_projection(mw_hessian, return_P=False, mw_gradient=None, full=False)[source]
property energy

Energy of the current atomic configuration.

Returns:

energy -- Energy of the current atomic configuration.

Return type:

float

fd_coords3d_gen(step_size=0.001)[source]

Iterator returning 3d Cartesians for finite-differences.

property forces

Energy of the current atomic configuration.

Returns:

force -- 1d array containing the forces acting on the atoms. Negative of the gradient.

Return type:

np.array

get_energy_and_cart_forces_at(cart_coords)[source]
get_energy_and_cart_hessian_at(cart_coords)[source]
get_energy_and_forces_at(coords)[source]

Calculate forces and energies at the given coordinates.

The results are not saved in the Geometry object.

get_energy_at(coords)[source]
get_energy_at_cart_coords(cart_coords)[source]
get_fragments(regex)[source]
get_hessian_projector(cart_gradient=None, full=False)[source]
get_imag_frequencies(hessian=None, thresh=1e-06)[source]
get_normal_modes(cart_hessian=None, cart_gradient=None, proj_gradient=False, full=False)[source]

Normal mode wavenumbers, eigenvalues and Cartesian displacements Hessian.

get_restart_info()[source]
get_root_energy(root)[source]
get_sphere_radius(offset=4)[source]
get_subgeom(indices, coord_type='cart', sort=False, cart_coords=None)[source]

Return a Geometry containing a subset of the current Geometry.

Parameters:

  • indices (iterable of ints) -- Atomic indices that the define the subset of the current Geometry.

  • coord_type (str, ("cart", "redund"), optional) -- Coordinate system of the new Geometry.

  • cart_coords (default: None) -- Optional 1d array of Cartesian coordinates of shape (3*natoms, ).

Returns:

sub_geom -- Subset of the current Geometry.

Return type:

Geometry

get_subgeom_without(indices, **kwargs)[source]
get_temporary_coords(coords)[source]
get_thermoanalysis(energy=None, cart_hessian=None, T=298.15, p=101325, point_group='c1')[source]
get_trans_rot_projector(full=False)[source]
property gradient

Negative of the force.

Returns:

gradient -- 1d array containing the negative of the current forces.

Return type:

np.array

has_all_energies()[source]
property has_energy
property has_forces
has_hessian()[source]
property hessian

Matrix of second derivatives of the energy in respect to atomic displacements.

Returns:

hessian -- 2d array containing the second derivatives of the energy with respect to atomic/coordinate displacements depending on the type of coordiante system.

Return type:

np.array

property inertia_tensor
property is_analytical_2d
property is_linear
jmol(atoms=None, cart_coords=None, stdin=None, jmol_cmd='jmol')[source]

Show geometry in jmol.

TODO: read jmol command from .pysisyphusrc ?!

property layers
mass_weigh_hessian(hessian)[source]
property masses: ndarray
property masses_rep
property mm_inv

Inverted mass matrix.

Returns a diagonal matrix containing the inverted atomic masses.

property mm_sqrt_inv

Inverted square root of the mass matrix.

modes3d()[source]
property moving_atoms
moving_atoms_jmol()[source]
property mw_coords

Mass-weighted coordinates.

Returns:

mw_coords -- 1d array containing the mass-weighted cartesian coordiantes.

Return type:

np.array

property mw_gradient

Mass-weighted gradient.

Returns:

mw_gradient -- Returns the mass-weighted gradient.

Return type:

np.array

property mw_hessian

Mass-weighted hessian.

Returns:

mw_hessian -- 2d array containing the mass-weighted hessian M^(-1/2) H M^(-1/2).

Return type:

np.array

principal_axes_are_aligned()[source]

Check if the principal axes are aligned with the cartesian axes.

Returns:

aligned -- Wether the principal axes are aligned or not.

Return type:

bool

reparametrize(energy, forces)[source]
reset_coords(new_typed_prims=None)[source]
rmsd(geom, align=True)[source]
rotate(copy=False, rng=None)[source]
set_calculator(calculator, clear=True)[source]

Reset the object and set a calculator.

set_coord(ind, coord)[source]

Set a coordinate by index.

Parameters:

  • ind (int) -- Index in of the coordinate to set in the self.coords array.

  • coord (float) -- Coordinate value.

set_coords(coords, cartesian=False, update_constraints=False)[source]
set_h5_hessian(fn)[source]
set_restart_info(restart_info)[source]
set_results(results)[source]

Save the results from a dictionary.

Parameters:

results (dict) -- The keys in this dict will be set as attributes in the current object, with the corresponding item as value.

standard_orientation()[source]
property sum_formula
property td_1tdms

1-particle transition density matrices from TD-DFT/TDA.

Returns list of Xa, Ya, Xb and Yb in MO basis.

tmp_xyz_handle(atoms=None, cart_coords=None)[source]
property total_mass
unweight_mw_hessian(mw_hessian)[source]

Unweight a mass-weighted hessian.

Parameters:

mw_hessian (np.array) -- Mass-weighted hessian to be unweighted.

Returns:

hessian -- 2d array containing the hessian.

Return type:

np.array

property vdw_radii
vdw_volume(**kwargs)[source]
property wavefunction
without_hydrogens()[source]
zero_frozen_forces(cart_forces)[source]
pysisyphus.Geometry.normalize_atoms(atoms)[source]
Return type:

tuple[str]

17.1.4. pysisyphus.MOCoeffs module

class pysisyphus.MOCoeffs.MOCoeffs(Ca, ensa, occsa, Cb=None, ensb=None, occsb=None)[source]

Bases: object

Ca: ndarray
Cb: Optional[ndarray] = None
ensa: ndarray
ensb: Optional[ndarray] = None
property homoa: int | None
property homob: int | None
property lumoa
property lumob
property occa: int
property occb: int
occsa: ndarray
occsb: Optional[ndarray] = None
plot_mo_energies(below_homo=0.5, above_homo=0.5, show=False)[source]
property restricted: bool
swap_inplace(C, ens, occs, ind1, ind2, swap_energies=True, swap_occs=True)[source]

Swap a pair of MO coeffs and energies inplace.

swap_mos(alpha_pairs, beta_pairs=None, **kwargs)[source]
property unrestricted: bool
property virt_indsa
property virt_indsb
pysisyphus.MOCoeffs.filter_ens(ens, en_homo, below_homo, above_homo)[source]
Return type:

Tuple[ndarray, ndarray]

pysisyphus.MOCoeffs.occ_from_occs(occs)[source]

17.1.5. pysisyphus.TablePrinter module

class pysisyphus.TablePrinter.TablePrinter(header, col_fmts, width=12, sub_underline=True, mark='*', offset=8, logger=None, level=20)[source]

Bases: object

property nfields: int
print(*args, **kwargs)[source]
print_header(with_sep=True)[source]
print_row(args, marks=None)[source]
print_rows(all_args, marks=None, first_n=None)[source]
print_sep()[source]
pysisyphus.TablePrinter.center(string, width)[source]
pysisyphus.TablePrinter.parse_fstring(fstr)[source]
Return type:

dict

pysisyphus.TablePrinter.res_to_fstring(res)[source]

17.1.6. pysisyphus.color module

pysisyphus.color.bool_color(bool_, str_=None)[source]
pysisyphus.color.green(str_)[source]
pysisyphus.color.red(str_)[source]

17.1.7. pysisyphus.config module

pysisyphus.config.detect_paths()[source]
pysisyphus.config.get_cmd(section, key='cmd', use_defaults=True, silent=False)[source]
pysisyphus.config.parse_args(args)[source]
pysisyphus.config.run_detect_paths()[source]

17.1.8. pysisyphus.constants module

17.1.9. pysisyphus.elem_data module

pysisyphus.elem_data.atomic_numbers_for_atoms(atoms)[source]
pysisyphus.elem_data.get_tm_indices(atoms)[source]
pysisyphus.elem_data.masses_for_atoms(atoms)[source]
pysisyphus.elem_data.nuc_charges_for_atoms(atoms)[source]

17.1.10. pysisyphus.exceptions module

exception pysisyphus.exceptions.CalculationFailedException(msg='', path=None)[source]

Bases: Exception

exception pysisyphus.exceptions.DifferentAtomOrdering[source]

Bases: Exception

exception pysisyphus.exceptions.HEIIsFirstOrLastException[source]

Bases: Exception

exception pysisyphus.exceptions.RunAfterCalculationFailedException(msg='', err=None)[source]

Bases: Exception

17.1.11. pysisyphus.executors module

class pysisyphus.executors.CloudpickleProcessPoolExecutor(max_workers=None, mp_context=None, initializer=None, initargs=())[source]

Bases: ProcessPoolExecutor

ProcessPoolExecutor using cloudpickle.

From: https://stackoverflow.com/a/76008866

submit(fn, /, *args, **kwargs)[source]

Submits a callable to be executed with the given arguments.

Schedules the callable to be executed as fn(*args, **kwargs) and returns a Future instance representing the execution of the callable.

Returns:

A Future representing the given call.

class pysisyphus.executors.MaybeScheduler(use_cluster, n_workers=None, threads_per_worker=1)[source]

Bases: object

pysisyphus.executors.apply_cloudpickle(fn, /, *args, **kwargs)[source]

17.1.12. pysisyphus.filtertrj module

pysisyphus.filtertrj.get_unique_internals(geom)[source]
pysisyphus.filtertrj.parse_args(args)[source]
pysisyphus.filtertrj.parse_filter(raw_filter)[source]
pysisyphus.filtertrj.run()[source]

17.1.13. pysisyphus.finite_diffs module

pysisyphus.finite_diffs.finite_difference_gradient(coords, scalar_func, step_size=0.01)[source]

Stripped down version of finite_difference_hessian.

Both functions could probably be unified.

pysisyphus.finite_diffs.finite_difference_hessian(coords, grad_func, step_size=0.01, acc=2, callback=None)[source]

Numerical Hessian from central finite gradient differences.

Return type:

ndarray

See central differences in

https://en.wikipedia.org/wiki/Finite_difference_coefficient

for the different accuracies.

pysisyphus.finite_diffs.finite_difference_hessian_mp(atoms, coords, calc, step_size=0.01, acc=2, serial=False, prepare_kwargs=None)[source]

Finite-differences Hessian w/ multiprocessing support.

Return type:

ndarray

See central differences in

https://en.wikipedia.org/wiki/Finite_difference_coefficient

for the different accuracies.

pysisyphus.finite_diffs.grad_func(index, coords, factor, calc, atoms, prepare_kwargs)[source]
pysisyphus.finite_diffs.periodic_fd_2_8(x_ind, y, dx)[source]

2nd derivative for 8th-order accuracy from data on a periodic grid.

For more information see the docstring of 'periodic_finite_difference'.

pysisyphus.finite_diffs.periodic_finite_difference(x_ind, y, dx, degree, coeffs)[source]

Finite differences for data on a periodic grid. IMPORTANT: The grid data in y must be provided so that y[1] == y[-1]! If you initially evaluated y on a grid where x[0] and x[-1] are equal when periodicity is taken into account, e.g. np.sin(np.linspace(0, 2*np.pi)), then the last point must be excluded by passing only y[:-1]!

Parameters:

  • x_ind (int) -- Non-negative integer indexing the point on the grid, where the derivative is evaluated.

  • y (ndarray) -- Data array on a periodic evenely spaced grid.

  • dx (float) -- Grid spacing.

  • degree (int) -- Degree of the derivative. Positive integer >= 1.

  • coeffs (Sequence[float]) -- Sequence of floating point numbers containing Floating pi

17.1.14. pysisyphus.helpers module

class pysisyphus.helpers.FinalHessianResult(neg_eigvals, eigvals, nus, imag_fns, thermo)

Bases: tuple

eigvals

Alias for field number 1

imag_fns

Alias for field number 3

neg_eigvals

Alias for field number 0

nus

Alias for field number 2

thermo

Alias for field number 4

pysisyphus.helpers.align_coords(coords_list)[source]
pysisyphus.helpers.align_geoms(geoms)[source]
pysisyphus.helpers.check_for_end_sign(check_user=True, cwd='.', add_signs=None)[source]
pysisyphus.helpers.complete_fragments(atoms, fragments)[source]
pysisyphus.helpers.confirm_input(message)[source]
pysisyphus.helpers.do_final_hessian(geom, save_hessian=True, write_imag_modes=False, is_ts=False, prefix='', T=298.15, p=101325, ev_thresh=-1e-06, print_thermo=False, out_dir=None)[source]
pysisyphus.helpers.fit_rigid(geometry, vectors=None, vector_lists=None, hessian=None, align_factor=1.0)[source]
pysisyphus.helpers.geom_from_missing_ext(fn, **kwargs)[source]
pysisyphus.helpers.geom_from_xyz_file(xyz_fn, coord_type='cart', **coord_kwargs)[source]
pysisyphus.helpers.geom_loader(fn, coord_type='cart', iterable=False, **coord_kwargs)[source]

After introducing the pubchem functionality I don't like this function anymore :) Too complicated.

Return type:

Union[Geometry, tuple[Geometry]]

pysisyphus.helpers.geoms_from_trj(trj_fn, first=None, coord_type='cart', **coord_kwargs)[source]
pysisyphus.helpers.get_coords_diffs(coords, align=False, normalize=True)[source]
pysisyphus.helpers.get_fragment_xyzs(geom, fragments, with_geom=False, with_dummies=True)[source]

Create list of fragment xyz-strings.

Parameters:

  • geom (Geometry) -- Geometry object.

  • fragment -- List of fragments. Each fragment is described by a list of atom index integers.

  • with_geom (bool, default: False) -- Whether the xyz string of the full geometry is included at the first position.

  • with_dummies (bool, default: True) -- Whether atoms not belonging to the fragment are replaced by dummy atoms or just excluded. Using dummy atoms facilitates fragment recognition when viewing them.

Returns:

List of xyz-strings.

Return type:

xyzs

pysisyphus.helpers.get_geom_getter(ref_geom, calc_setter)[source]
pysisyphus.helpers.get_tangent_trj_str(atoms, coords, tangent, comment=None, points=10, displ=None)[source]
pysisyphus.helpers.imag_modes_from_geom(geom, freq_thresh=-10, points=10, displ=None)[source]
pysisyphus.helpers.index_array_from_overlaps(overlaps, axis=1)[source]

It is assumed that the overlaps between two points with indices i and j with (j > i) are computed and that i changes along the first axis (axis=0) and j changes along the second axis (axis=1).

So the first row of the overlap matrix (overlaps[0]) should contain the overlaps between state 0 at index i and all states at index j.

argmax along axis 1 returns the indices of the most overlapping states at index j with the states at index i, given by the item index in the indices array. E.g.:

[0 1 3 2] indicates a root flip in a system with four states when going from index i to index j. Root 2 at i became root 3 at j and vice versa.

pysisyphus.helpers.match_geoms(ref_geom, geom_to_match, hydrogen=False)[source]
See

[1] 10.1021/ci400534h [2] 10.1021/acs.jcim.6b00516

pysisyphus.helpers.norm_max_rms(arr)[source]
pysisyphus.helpers.np_print(func, precision=2, suppress=True, linewidth=120)[source]
pysisyphus.helpers.pick_image_inds(cart_coords, images)[source]

Pick approx. evenly distributed images from given Cartesian coordinates.

pysisyphus.helpers.print_barrier(ref_energy, comp_energy, ref_str, comp_str)[source]
pysisyphus.helpers.procrustes(geometry, align_factor=1.0)[source]
pysisyphus.helpers.shake_coords(coords, scale=0.1, seed=None)[source]
pysisyphus.helpers.simple_peaks(data)[source]
pysisyphus.helpers.slugify_worker(dask_worker)[source]

17.1.15. pysisyphus.helpers_pure module

class pysisyphus.helpers_pure.OrderedEnum(value)[source]

Bases: Enum

An enumeration.

pysisyphus.helpers_pure.approx_float(num, expected, abs_tol=1e-06, rel_tol=1e-12)[source]
Return type:

bool

pysisyphus.helpers_pure.argsort(iterable)[source]
pysisyphus.helpers_pure.cache_arrays(sources, dest)[source]
pysisyphus.helpers_pure.check_mem(mem, pal, avail_frac=0.85, logger=None)[source]
pysisyphus.helpers_pure.chunks(l, n)[source]

Yield successive n-sized chunks from l. https://stackoverflow.com/a/312464

pysisyphus.helpers_pure.describe(arr)[source]
pysisyphus.helpers_pure.eigval_to_wavenumber(ev)[source]
pysisyphus.helpers_pure.estimate(gen, elems)[source]
pysisyphus.helpers_pure.expand(to_expand)[source]
pysisyphus.helpers_pure.file_or_str(*args, method=False, mode='r', exact=False, add_exts=False)[source]
pysisyphus.helpers_pure.filter_fixture_store(test_name)[source]
pysisyphus.helpers_pure.find_closest_sequence(str_, comp_strs)[source]
Return type:

Tuple[str, float]

pysisyphus.helpers_pure.full_expand(to_expand)[source]
pysisyphus.helpers_pure.get_box(coords3d, offset=0.0)[source]
pysisyphus.helpers_pure.get_clock()[source]
pysisyphus.helpers_pure.get_cubic_crystal(l, n=2, atom='Na')[source]
pysisyphus.helpers_pure.get_input(data, prompt, lbl_func=None)[source]
pysisyphus.helpers_pure.get_molecular_radius(coords3d, min_offset=0.9452)[source]
pysisyphus.helpers_pure.get_random_path(stem='')[source]
pysisyphus.helpers_pure.get_ratio(str_, comp_str)[source]

See https://stackoverflow.com/a/17388505

Return type:

str

pysisyphus.helpers_pure.get_state_label(mult, state_ind, default='?')[source]
pysisyphus.helpers_pure.hash_args(*args, precision=4)[source]
pysisyphus.helpers_pure.hash_arr(arr, precision=4)[source]
pysisyphus.helpers_pure.highlight_text(text, width=80, level=0)[source]
pysisyphus.helpers_pure.increment_fn(org_fn, suffix=None)[source]

Append, or increase a suffixed counter on a given filename. If no counter is present it will be set to zero. Otherwise it is incremented by one.

>>> increment_fn("opt", "rebuilt")
'opt_rebuilt_000'
>>> increment_fn("opt")
'opt_000'
>>> increment_fn("opt_rebuilt_000", "rebuilt")
'opt_rebuilt_001'
Parameters:

  • org_fn (str) -- The original, unaltered filename.

  • suffix (Optional[str], default: None) -- Optional suffix to be append.

Returns:

Modified filename with optional suffix and incremented counter.

Return type:

incr_fn

pysisyphus.helpers_pure.interpolate_colors(values, c1, c2, num=32)[source]

Expects two RGB colors c1 and c2.

pysisyphus.helpers_pure.json_to_results(as_json)[source]
pysisyphus.helpers_pure.kill_dir(path)[source]

Innocent function remove a directory.

It must contain only files and no other directories. So this won't do too much damage hopefully.

pysisyphus.helpers_pure.log(logger, msg, level=10)[source]
pysisyphus.helpers_pure.merge_sets(fragments)[source]

Merge a list of iterables.

pysisyphus.helpers_pure.molecular_volume(coords3d, vdw_radii, n_trial=10000, offset=1.0)[source]

Monte-Carlo estimate of molecular volume using Van der Waals spheres. Cartesian coordinates and VdW-radii are expected in Bohr!

Return type:

Tuple[float, float, float]

pysisyphus.helpers_pure.recursive_extract(inp_dict, target_key, prev_keys=None)[source]

Recursively extract given key from a dict.

Can also handle dict of dicts, e.g., different calculation results from a MultiCalc in run.run_calculations.

Return type:

dict[tuple[str], Any]

pysisyphus.helpers_pure.recursive_update(d, u)[source]

Recursive update of d with keys/values from u.

From https://stackoverflow.com/questions/3232943

pysisyphus.helpers_pure.remove_duplicates(seq)[source]
pysisyphus.helpers_pure.render_sp_stats(descr_res, unit, unit2=None, conv2=1.0)[source]

Render DescribeResult from scipy.stats.describe as str.

Values are reported with unit '{unit}'. If provided, values are reported with a second unit and an appropriate conversion factor.

Return type:

str

pysisyphus.helpers_pure.report_frozen_atoms(geom)[source]
pysisyphus.helpers_pure.report_isotopes(geom, affect_str)[source]
pysisyphus.helpers_pure.results_to_json(results)[source]
pysisyphus.helpers_pure.rms(arr)[source]

Root mean square

Returns the root mean square of the given array.

Parameters:

arr (iterable of numbers)

Returns:

rms -- Root mean square of the given array.

Return type:

float

pysisyphus.helpers_pure.sort_by_central(set1, set2)[source]

Determines a common index in two sets and returns a length 3 tuple with the central index at the middle position and the two terminal indices as first and last indices.

pysisyphus.helpers_pure.standard_state_corr(T=298.15, p=101325, n=1)[source]

dG for change of standard state from gas to solution of 1 mol/l

pysisyphus.helpers_pure.timed(logger=None)[source]
pysisyphus.helpers_pure.to_sets(iterable)[source]
pysisyphus.helpers_pure.to_subscript_num(num)[source]
pysisyphus.helpers_pure.touch(fn)[source]

17.1.16. pysisyphus.hessian_proj module

class pysisyphus.hessian_proj.Orientation(coords3d, com, rot_mat, coords3d_org, masses)[source]

Bases: object

Orientation store, e.g., for a standard orientation.

After instantiation the object performs a quick consistency check by trying to backtransform the re-oriented coordinates.

Parameters:

  • coords3d (ndarray) -- 2d-array of shape (N, 3) holding re-oriented coordinates, e.g., in standard orientation.

  • com (ndarray) -- (Original) center-of-mass to restore original coordinates from coords3d.

  • rot_mat (ndarray) -- 2d-array of shape (3, 3) that was used to rotate the shifted original coordinates into the chosen orientation.

  • coords3d_org (ndarray) -- 2d-array of shape (N, 3) holding the original Cartesian coordinates.

  • masses (ndarray) -- 1d-arary of shape (N, ) holding atomic masses in amu.

com: ndarray
coords3d: ndarray
coords3d_org: ndarray
property inertia_tensor
masses: ndarray
rot_mat: ndarray
rotate_gradient(gradient)[source]
pysisyphus.hessian_proj.get_hessian_projector(cart_coords, masses, cart_gradient=None, full=False, max_grad_thresh=0.00045, rms_grad_thresh=0.0003, use_std_orient=True)[source]

Get matrix to project translation and rotation from the Hessian.

Parameters:

  • cart_coords (ndarray) -- 1d array of shape (3N, ) holding Cartesian coordinates.

  • masses (ndarray) -- 1d arary of shape (N, ) holding atomic masses.

  • cart_gradient (Optional[ndarray], default: None) -- Optional 1d array of shape (3N, ) containing a Cartesian gradient that will also be projected out of the Hessian.

  • full (bool, default: False) -- Boolean flag that controls the shape of the projector. If true, the projector will be of shape (3N, 3N), otherwise it will be of shape (3N - 6 (5), 3N - 6 (5)).

  • max_grad_thresh (float, default: 0.00045) -- Positive floating point number. Criterion used to determine if we are at a stationary point. If we are at a statioanry point, the gradient direction won't be included in the projector.

  • rms_grad_thresh (float, default: 0.0003) -- See max_grad_thresh.

  • use_std_orient (bool, default: True) -- Boolean flag that controls the use of a (temporary) standard orientation. If set to False linear molecules can lack a vibration.

pysisyphus.hessian_proj.get_projector(vecs)[source]

Vectors must be in rows.

# P = I - sum_i vec_i @ vec_i.T

pysisyphus.hessian_proj.get_standard_orientation(coords3d, masses)[source]
Return type:

Orientation

pysisyphus.hessian_proj.get_trans_rot_projector(cart_coords, masses, cart_gradient=None, full=False)[source]
pysisyphus.hessian_proj.get_trans_rot_vectors(cart_coords, masses, rot_thresh=1e-05)[source]

Vectors describing translation and rotation.

These vectors are used for the Eckart projection by constructing a projector from them.

See Martin J. Field - A Pratcial Introduction to the simulation of Molecular Systems, 2007, Cambridge University Press, Eq. (8.23), (8.24) and (8.26) for the actual projection.

See also https://chemistry.stackexchange.com/a/74923.

Parameters:

  • cart_coords (np.array, 1d, shape (3 * atoms.size, )) -- Atomic masses in amu.

  • masses (iterable, 1d, shape (atoms.size, )) -- Atomic masses in amu.

Returns:

ortho_vecs -- 2d array containing row vectors describing translations and rotations.

Return type:

np.array(6, 3*atoms.size)

pysisyphus.hessian_proj.get_unit_orientation(coords3d, masses)[source]
Return type:

Orientation

pysisyphus.hessian_proj.inertia_tensor(coords3d, masses)[source]

Inertita tensor.

x² xy xz |
(x y z)^T . (x y z) = | xy y² yz |
xz yz z² |

17.1.17. pysisyphus.init_logging module

pysisyphus.init_logging.get_fh_logger(name, log_fn)[source]

Initialize a logger with 'name', level DEBUG and a FileHandler.

pysisyphus.init_logging.init_logging(log_dir='./', scheduler=None)[source]

Prepare the logger in log_path. When called with scheduler loggers for every worker are prepared.

pysisyphus.init_logging.init_logging_base(dask_worker, log_path)[source]

Prepare individual loggers for one dask_worker.

17.1.18. pysisyphus.linalg module

pysisyphus.linalg.are_collinear(points, rad_thresh=1e-12)[source]

Determine linearity of points in R^N.

Linearity is checked by comparing dot products between successive point pairs. Coinciding points are NOT checked.

Return type:

bool

pysisyphus.linalg.cross3(a, b)[source]

10x as fast as np.cross for two 1d arrays of size 3.

pysisyphus.linalg.eigvec_grad(w, v, ind, mat_grad)[source]

Gradient of 'ind'-th eigenvector.

dv_i / dx_i = (w_i*I - mat)⁻¹ dmat/dx_i v_i

pysisyphus.linalg.fd_rmsd_hessian(coords3d, ref_coords3d, step_size=0.0001)[source]
pysisyphus.linalg.get_rot_mat(abc=None)[source]
pysisyphus.linalg.get_rot_mat_for_coords(coords3d_1, coords3d_2)[source]
pysisyphus.linalg.gram_schmidt(vecs, thresh=1e-08)[source]

For historical reasons, this operates on rows ...

pysisyphus.linalg.make_unit_vec(vec1, vec2)[source]

Return unit vector pointing from vec2 to vec1.

pysisyphus.linalg.matrix_power(mat, p, thresh=1e-12, strict=True)[source]
pysisyphus.linalg.multi_component_sym_mat(arr, dim)[source]
pysisyphus.linalg.norm3(a)[source]

5x as fas as np.linalg.norm for a 1d array of size 3.

pysisyphus.linalg.orthogonalize_against(mat, vecs, max_cycles=5, thresh=1e-10)[source]

Orthogonalize rows of 'mat' against rows in 'vecs'

Returns a (modified) copy of mat.

pysisyphus.linalg.perp_comp(vec, along)[source]

Return the perpendicular component of vec along along.

pysisyphus.linalg.pivoted_cholesky(A, tol=-1.0)[source]

Cholesky factorization a real symmetric positive semidefinite matrix. Cholesky factorization is carried out with full pivoting.

Adapated from PySCF.

P.T * A * P = L * L.T

Parameters:

  • A (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) -- Matrix to be factorized.

  • tol (float, default: -1.0) -- User defined tolerance, as outlined in the LAPACK docs.

Returns:

  • L -- Lower or upper triangular matrix.

  • piv -- Pivot vectors, starting at 0.

  • rank -- Rank of the factoirzed matrix.

pysisyphus.linalg.pivoted_cholesky2(A, tol=None, m_max=0)[source]

https://doi.org/10.1016/j.apnum.2011.10.001

pysisyphus.linalg.quaternion_to_rot_mat(q)[source]
pysisyphus.linalg.rmsd_grad(coords3d, ref_coords3d, offset=1e-09)[source]

RMSD and gradient between two sets of coordinates from quaternions.

The gradient is given w.r.t. the coordinates of 'coords3d'.

Python adaption of

ls_rmsd.f90

from the xtb repository of the Grimme group, which in turn implements

[1] https://doi.org/10.1002/jcc.20110

.

Parameters:

  • coords3d (ndarray[Any, dtype[float]]) -- Coordinate array of shape (N, 3) with N denoting the number of atoms.

  • ref_coords3d (ndarray[Any, dtype[float]]) -- Reference coordinates.

  • offset (float, default: 1e-09) -- Small floating-point number that is added to the RMSD, to avoid division by zero.

Return type:

Tuple[float, ndarray[Any, dtype[float]]]

Returns:

  • rmsd -- RMSD value.

  • rmsd_grad -- Gradient of the RMSD value w.r.t. to 'coords3d'.

pysisyphus.linalg.rot_quaternion(coords3d, ref_coords3d)[source]
pysisyphus.linalg.svd_inv(array, thresh, hermitian=False)[source]
pysisyphus.linalg.sym_mat_from_tril(arr, data)[source]
pysisyphus.linalg.sym_mat_from_triu(arr, data)[source]

17.1.19. pysisyphus.linalg_affine3 module

Affine transformations in 3d.

Based on code given by Emőd Kovács in

Rotation about an arbitrary axis and reflection through an arbitrary plane

pysisyphus.linalg_affine3.augment_matrix(mat, b=None)[source]

Augment 3x3 matrix to 4x4.

pysisyphus.linalg_affine3.augment_vector(vec)[source]
pysisyphus.linalg_affine3.augment_vectors(vecs)[source]
pysisyphus.linalg_affine3.householder_reflection_matrix(normal)[source]

Householder reflection matrix.

pysisyphus.linalg_affine3.inv_translation_matrix(vec)[source]

Inverse of augmented translation matrix.

pysisyphus.linalg_affine3.plane_normal(coords3d, thresh=1e-06)[source]

Normal vector of plane given by 3 points.

pysisyphus.linalg_affine3.reflect_coords(R, coords3d)[source]
pysisyphus.linalg_affine3.reflection_matrix(normal, point)[source]

Reflection through plane containing 'point' and normal vector 'normal'.

pysisyphus.linalg_affine3.rotation_matrix_for_rot_around_vec(vec, deg)[source]

Get rotation matrix for rotation of 'deg' degrees around vector 'vec'.

Parameters:

  • vec (ndarray) -- Array of shape (3, ) containing the rotation vector.

  • deg (float) -- Degrees controlling extent of rotation.

Returns:

2d array of shape (3, 3) containing the rotation matrix.

Return type:

R

pysisyphus.linalg_affine3.rotation_matrix_for_vec_align(vec1, vec2, thresh=1e-08)[source]

Returns rotation matrix that rotates vec1 onto vec2.

Code adapted from https://math.stackexchange.com/a/476311

(R @ vec1) and vec2 are parallel.

Parameters:

  • vec1 (ndarray) -- 3d vector.

  • vec2 (ndarray) -- 3d vector.

  • thresh (float, default: 1e-08) -- Positive floating point for detecting parallel vectors.

Returns:

3x3 rotation matrix that rotates vec1 onto vec2.

Return type:

R

pysisyphus.linalg_affine3.svd_plane_normal(coords3d)[source]

Normal vector of best-fit plane for coords3d.

pysisyphus.linalg_affine3.translation_matrix(vec)[source]

Augmented translation matrix.

17.1.20. pysisyphus.pack module

17.1.21. pysisyphus.peakdetect module

pysisyphus.peakdetect.peakdetect(y_axis, x_axis=None, lookahead=200, delta=0)[source]

Converted from/based on a MATLAB script at: http://billauer.co.il/peakdet.html

function for detecting local maxima and minima in a signal. Discovers peaks by searching for values which are surrounded by lower or larger values for maxima and minima respectively

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list and is used

in the return to specify the position of the peaks. If omitted an index of the y_axis is used. (default: None)

lookahead -- distance to look ahead from a peak candidate to determine if

it is the actual peak (default: 200) '(samples / period) / f' where '4 >= f >= 1.25' might be a good value

delta -- this specifies a minimum difference between a peak and

the following points, before a peak may be considered a peak. Useful to hinder the function from picking up false peaks towards to end of the signal. To work well delta should be set to delta >= RMSnoise * 5. (default: 0)

When omitted delta function causes a 20% decrease in speed. When used Correctly it can double the speed of the function

return: two lists [max_peaks, min_peaks] containing the positive and

negative peaks respectively. Each cell of the lists contains a tuple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*max_peaks)

pysisyphus.peakdetect.peakdetect_fft(y_axis, x_axis, pad_len=20)[source]

Performs a FFT calculation on the data and zero-pads the results to increase the time domain resolution after performing the inverse fft and send the data to the 'peakdetect' function for peak detection.

Omitting the x_axis is forbidden as it would make the resulting x_axis value silly if it was returned as the index 50.234 or similar.

Will find at least 1 less peak then the 'peakdetect_zero_crossing' function, but should result in a more precise value of the peak as resolution has been increased. Some peaks are lost in an attempt to minimize spectral leakage by calculating the fft between two zero crossings for n amount of signal periods.

The biggest time eater in this function is the ifft and thereafter it's the 'peakdetect' function which takes only half the time of the ifft. Speed improvements could include to check if 2**n points could be used for fft and ifft or change the 'peakdetect' to the 'peakdetect_zero_crossing', which is maybe 10 times faster than 'peakdetct'. The pro of 'peakdetect' is that it results in one less lost peak. It should also be noted that the time used by the ifft function can change greatly depending on the input.

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list and is used

in the return to specify the position of the peaks.

pad_len -- By how many times the time resolution should be

increased by, e.g. 1 doubles the resolution. The amount is rounded up to the nearest 2**n amount (default: 20)

return: two lists [max_peaks, min_peaks] containing the positive and

negative peaks respectively. Each cell of the lists contains a tuple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*max_peaks)

pysisyphus.peakdetect.peakdetect_parabola(y_axis, x_axis, points=31)[source]

Function for detecting local maxima and minima in a signal. Discovers peaks by fitting the model function: y = k (x - tau) ** 2 + m to the peaks. The amount of points used in the fitting is set by the points argument.

Omitting the x_axis is forbidden as it would make the resulting x_axis value silly, if it was returned as index 50.234 or similar.

will find the same amount of peaks as the 'peakdetect_zero_crossing' function, but might result in a more precise value of the peak.

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list and is used

in the return to specify the position of the peaks.

points -- How many points around the peak should be used during curve

fitting (default: 31)

return: two lists [max_peaks, min_peaks] containing the positive and

negative peaks respectively. Each cell of the lists contains a tuple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*max_peaks)

pysisyphus.peakdetect.peakdetect_sine(y_axis, x_axis, points=31, lock_frequency=False)[source]

Function for detecting local maxima and minima in a signal. Discovers peaks by fitting the model function: y = A * sin(2 * pi * f * (x - tau)) to the peaks. The amount of points used in the fitting is set by the points argument.

Omitting the x_axis is forbidden as it would make the resulting x_axis value silly if it was returned as index 50.234 or similar.

will find the same amount of peaks as the 'peakdetect_zero_crossing' function, but might result in a more precise value of the peak.

The function might have some problems if the sine wave has a non-negligible total angle i.e. a k*x component, as this messes with the internal offset calculation of the peaks, might be fixed by fitting a y = k * x + m function to the peaks for offset calculation.

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list and is used

in the return to specify the position of the peaks.

points -- How many points around the peak should be used during curve

fitting (default: 31)

lock_frequency -- Specifies if the frequency argument of the model

function should be locked to the value calculated from the raw peaks or if optimization process may tinker with it. (default: False)

return: two lists [max_peaks, min_peaks] containing the positive and

negative peaks respectively. Each cell of the lists contains a tuple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*max_peaks)

pysisyphus.peakdetect.peakdetect_sine_locked(y_axis, x_axis, points=31)[source]

Convenience function for calling the 'peakdetect_sine' function with the lock_frequency argument as True.

keyword arguments: y_axis -- A list containing the signal over which to find peaks x_axis -- A x-axis whose values correspond to the y_axis list and is used

in the return to specify the position of the peaks.

points -- How many points around the peak should be used during curve

fitting (default: 31)

return: see the function 'peakdetect_sine'

pysisyphus.peakdetect.peakdetect_spline(y_axis, x_axis, pad_len=20)[source]

Performs a b-spline interpolation on the data to increase resolution and send the data to the 'peakdetect_zero_crossing' function for peak detection.

Omitting the x_axis is forbidden as it would make the resulting x_axis value silly if it was returned as the index 50.234 or similar.

will find the same amount of peaks as the 'peakdetect_zero_crossing' function, but might result in a more precise value of the peak.

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list and is used

in the return to specify the position of the peaks. x-axis must be equally spaced.

pad_len -- By how many times the time resolution should be increased by,

e.g. 1 doubles the resolution. (default: 20)

return: two lists [max_peaks, min_peaks] containing the positive and

negative peaks respectively. Each cell of the lists contains a tuple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*max_peaks)

pysisyphus.peakdetect.peakdetect_zero_crossing(y_axis, x_axis=None, window=11)[source]

Function for detecting local maxima and minima in a signal. Discovers peaks by dividing the signal into bins and retrieving the maximum and minimum value of each the even and odd bins respectively. Division into bins is performed by smoothing the curve and finding the zero crossings.

Suitable for repeatable signals, where some noise is tolerated. Executes faster than 'peakdetect', although this function will break if the offset of the signal is too large. It should also be noted that the first and last peak will probably not be found, as this function only can find peaks between the first and last zero crossing.

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list

and is used in the return to specify the position of the peaks. If omitted an index of the y_axis is used. (default: None)

window -- the dimension of the smoothing window; should be an odd integer

(default: 11)

return: two lists [max_peaks, min_peaks] containing the positive and

negative peaks respectively. Each cell of the lists contains a tuple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*max_peaks)

pysisyphus.peakdetect.zero_crossings(y_axis, window_len=11, window_f='hanning', offset_corrected=False)[source]

Algorithm to find zero crossings. Smooths the curve and finds the zero-crossings by looking for a sign change.

keyword arguments: y_axis -- A list containing the signal over which to find zero-crossings

window_len -- the dimension of the smoothing window; should be an odd

integer (default: 11)

window_f -- the type of window from 'flat', 'hanning', 'hamming',

'bartlett', 'blackman' (default: 'hanning')

offset_corrected -- Used for recursive calling to remove offset when needed

return: the index for each zero-crossing

pysisyphus.peakdetect.zero_crossings_sine_fit(y_axis, x_axis, fit_window=None, smooth_window=11)[source]

Detects the zero crossings of a signal by fitting a sine model function around the zero crossings: y = A * sin(2 * pi * Hz * (x - tau)) + k * x + m Only tau (the zero crossing) is varied during fitting.

Offset and a linear drift of offset is accounted for by fitting a linear function the negative respective positive raw peaks of the wave-shape and the amplitude is calculated using data from the offset calculation i.e. the 'm' constant from the negative peaks is subtracted from the positive one to obtain amplitude.

Frequency is calculated using the mean time between raw peaks.

Algorithm seems to be sensitive to first guess e.g. a large smooth_window will give an error in the results.

keyword arguments: y_axis -- A list containing the signal over which to find peaks

x_axis -- A x-axis whose values correspond to the y_axis list

and is used in the return to specify the position of the peaks. If omitted an index of the y_axis is used. (default: None)

fit_window -- Number of points around the approximate zero crossing that

should be used when fitting the sine wave. Must be small enough that no other zero crossing will be seen. If set to none then the mean distance between zero crossings will be used (default: None)

smooth_window -- the dimension of the smoothing window; should be an odd

integer (default: 11)

return: A list containing the positions of all the zero crossings.

17.1.22. pysisyphus.plot module

pysisyphus.plot.CDD_PNG_FNS = 'cdd_png_fns'

Default to kJ mol⁻¹. DE_LABEL and get_en_conv will be overwritten when run() is executed. Both are still defined here, to make the functions from plot.py importable.

pysisyphus.plot.anim_cos(cart_coords, energies)[source]
pysisyphus.plot.get_en_conv()[source]
pysisyphus.plot.get_force_unit(coord_type)[source]
pysisyphus.plot.list_h5_groups(h5_fn)[source]
pysisyphus.plot.load_h5(h5_fn, h5_group, datasets=None, attrs=None)[source]
pysisyphus.plot.parse_args(args)[source]
pysisyphus.plot.plot_afir(h5_fn='afir.h5', h5_group='afir')[source]
pysisyphus.plot.plot_all_energies(h5)[source]
pysisyphus.plot.plot_calculations()[source]
pysisyphus.plot.plot_cos_energies(h5_fn='optimization.h5', h5_group='opt')[source]
pysisyphus.plot.plot_cos_forces(h5_fn='optimization.h5', h5_group='opt', last=15)[source]
pysisyphus.plot.plot_cycle(cart_coords, energies)[source]
pysisyphus.plot.plot_gau(gau_fns, num=50)[source]
pysisyphus.plot.plot_irc()[source]
pysisyphus.plot.plot_irc_h5(h5, title=None)[source]
pysisyphus.plot.plot_md(h5_group='run')[source]
pysisyphus.plot.plot_opt(h5_fn='optimization.h5', h5_group='opt')[source]
pysisyphus.plot.plot_overlaps(h5, thresh=0.1)[source]
pysisyphus.plot.plot_scan(dat_fn=None)[source]
pysisyphus.plot.plot_trj_energies(trj)[source]

Parse comments of .xyz/.trj as energies and plot.

pysisyphus.plot.render_cdds(h5)[source]
pysisyphus.plot.run()[source]
pysisyphus.plot.spline_plot_cycles(cart_coords, energies)[source]

17.1.23. pysisyphus.plot_ascii module

class pysisyphus.plot_ascii.Grid(i, j)[source]

Bases: object

put(c, i, j, depth=1000000000.0)[source]
pysisyphus.plot_ascii.plot(atoms)[source]

Ascii-art plot of the atoms.

Return type:

str

pysisyphus.plot_ascii.plot_wrapper(geom)[source]

ASCII representation of pysisyphus.Geometry object.

Thin wrapper around gpaw's outplot.plot() function.

Return type:

str

17.1.24. pysisyphus.run module

17.1.25. pysisyphus.socket_helper module

pysisyphus.socket_helper.get_fmts(cartesians)[source]
pysisyphus.socket_helper.recv_closure(sock, hdrlen, fmts, verbose=False)[source]
pysisyphus.socket_helper.send_closure(sock, hdrlen, fmts, verbose=False)[source]

17.1.26. pysisyphus.testing module

class pysisyphus.testing.DummyMark(available)[source]

Bases: object

pysisyphus.testing.available(calculator, **kwargs)[source]
pysisyphus.testing.module_available(calculator)[source]
pysisyphus.testing.using(calculator, set_pytest_mark=True)[source]

Calling disabling set_pytest_mark avoids a runtime dependency on pytest.

17.1.27. pysisyphus.thermo module

pysisyphus.thermo.get_thermoanalysis_from_hess_h5(h5_fn, T=298.15, p=101325, point_group='c1', return_geom=False, kind='qrrho', scale_factor=1.0)[source]
pysisyphus.thermo.print_thermoanalysis(thermo, geom=None, is_ts=False, unit='joule', level=0, title=None)[source]

Print thermochemical analysis.

17.1.28. pysisyphus.timing module

class pysisyphus.timing.RuntimeEstimation(mean_est, median_est, nremain)[source]

Bases: object

mean_est: float
median_est: float
nremain: int
render_mean()[source]
render_median()[source]
pysisyphus.timing.estimate_runtime(durations, ncalcs, pal=1)[source]
Return type:

RuntimeEstimation

pysisyphus.timing.render(dur)[source]
Return type:

str

17.1.29. pysisyphus.trj module

17.1.30. pysisyphus.typing module

17.1.31. pysisyphus.version module

17.1.32. pysisyphus.xyzloader module

pysisyphus.xyzloader.coords_to_trj(trj_fn, atoms, coords_list, comments=None)[source]
pysisyphus.xyzloader.make_trj_str(atoms, coords_list, comments=None)[source]
pysisyphus.xyzloader.make_trj_str_from_geoms(geoms, comments=None, energy_comments=False)[source]
pysisyphus.xyzloader.make_xyz_str(atoms, coords, comment='')[source]

Expects coordinates in Angstrom!

pysisyphus.xyzloader.make_xyz_str_au(atoms, coords3d, comment='')[source]

Excpects coordinates in atomic units/Bohr!

pysisyphus.xyzloader.parse_trj_file(trj_fn, with_comments=False)[source]
pysisyphus.xyzloader.parse_trj_str(trj_str, with_comments=False)[source]
pysisyphus.xyzloader.parse_xyz_file(xyz_fn, with_comment=False)[source]
pysisyphus.xyzloader.parse_xyz_str(xyz_str, with_comment)[source]

Parse a xyz string.

17.1. Paramters

xyz_strstr

The contents of a .xyz file.

with_commentbool

Return comment line if True.

returns:

  • atoms (list) -- List of length N (N = number of atoms) holding the element symbols.

  • coords (np.array) -- An array of shape (N, 3) holding the xyz coordinates.

  • comment_line (str, optional) -- Comment line if with_comment argument was True.

pysisyphus.xyzloader.split_xyz_str(xyz_str)[source]

Example:

xyz:

1

X -1.2 1.4 0.0 1

X 2.0 4.0 0.0

pysisyphus.xyzloader.write_geoms_to_trj(geoms, fn, comments=None)[source]

17.1.33. pysisyphus.yaml_mods module

pysisyphus.yaml_mods.get_constructor(unit)[source]
pysisyphus.yaml_mods.get_loader(units=['Eh', 'kJpermol', 'kcalpermol', 'eV', 'fs', 'ps', 'ns', 'a0', 'angstrom', 'nm', 'deg'])[source]

17.1.34. Module contents