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_and_forces()[source]

Force a calculation of the current energy and forces.

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_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)[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.

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
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()[source]
reset_coords(new_typed_prims=None)[source]
rmsd(geom)[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.TableFormatter module

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

print(*args, **kwargs)[source]
print_header(with_sep=True)[source]
print_row(args, marks=None)[source]
print_sep()[source]
pysisyphus.TablePrinter.center(string, width)[source]
pysisyphus.TablePrinter.parse_fstring(fstr)[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.get_tm_indices(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.HEIIsFirstOrLastException[source]

Bases: Exception

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

Bases: Exception

17.1.11. 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.12. 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.13. 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.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.14. 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.15. 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]
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.16. pysisyphus.pack module

pysisyphus.pack.as_pdb(fn)[source]
pysisyphus.pack.parse_args(args)[source]
pysisyphus.pack.print_info(title, geom)[source]
pysisyphus.pack.run()[source]
pysisyphus.pack.sphere_radius_from_volume(volume)[source]
pysisyphus.pack.volume_for_density(molecule_num, mol_mass, density)[source]

17.1.17. 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.18. 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_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(h5_fn='scan.h5')[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.19. pysisyphus.run module

class pysisyphus.run.RunResult(preopt_first_geom, preopt_last_geom, cos, cos_opt, ts_geom, ts_opt, end_geoms, irc, irc_geom, mdp_result, opt_geom, opt, calced_geoms, calced_results, stocastic, calc_getter, scan_geoms, scan_vals, scan_energies, perf_results)

Bases: tuple

calc_getter

Alias for field number 15

calced_geoms

Alias for field number 12

calced_results

Alias for field number 13

cos

Alias for field number 2

cos_opt

Alias for field number 3

end_geoms

Alias for field number 6

irc

Alias for field number 7

irc_geom

Alias for field number 8

mdp_result

Alias for field number 9

opt

Alias for field number 11

opt_geom

Alias for field number 10

perf_results

Alias for field number 19

preopt_first_geom

Alias for field number 0

preopt_last_geom

Alias for field number 1

scan_energies

Alias for field number 18

scan_geoms

Alias for field number 16

scan_vals

Alias for field number 17

stocastic

Alias for field number 14

ts_geom

Alias for field number 4

ts_opt

Alias for field number 5

pysisyphus.run.check_asserts(results, run_dict)[source]
pysisyphus.run.copy_yaml_and_geometries(run_dict, yaml_fn, dest_and_add_cp, new_yaml_fn=None)[source]
pysisyphus.run.do_clean(force=False)[source]

Deletes files from previous runs in the cwd. A similar function could be used to store everything ...

pysisyphus.run.do_rmsds(xyz, geoms, end_fns, end_geoms, preopt_map=None, similar_thresh=0.25)[source]
pysisyphus.run.get_calc_closure(base_name, calc_key, calc_kwargs, iter_dict=None, index=None)[source]
pysisyphus.run.get_defaults(conf_dict, T_default=298.15, p_default=101325)[source]
pysisyphus.run.get_last_calc_cycle()[source]
pysisyphus.run.load_run_dict(yaml_fn)[source]
pysisyphus.run.main(run_dict, restart=False, yaml_dir='./', scheduler=None)[source]
pysisyphus.run.parse_args(args)[source]
pysisyphus.run.print_bibtex()[source]
pysisyphus.run.print_header()[source]

Generated from https://asciiartgen.now.sh/?s=pysisyphus&style=colossal

pysisyphus.run.run()[source]
pysisyphus.run.run_calculations(geoms, calc_getter, scheduler=None, assert_track=False, run_func=None, one_calculator=False)[source]

Run calculations for all given geometries.

Sometimes one just wants to run a series of calculations for list of geometries, w/o any optimization or IRC integration etc. This function will be executed when the YAML inputs lacks any opt/tsopt/irc/... section.

Parameters:
  • geoms (list[Geometry]) -- List of geometries. Depending on the values of the other arguments all geometries must be/don't have to be compatible (same atom order). When only one calculator is utilized all geometries must be compatible.

  • calc_getter (Callable) -- Function that returns a new calculator.

  • scheduler (Union[str, LocalCluster, None], default: None) -- Optional; address or distributed.LocalCluster that is utilized to carry out all calculations in parallel.

  • assert_track (bool, default: False) -- Whether it is asserted that ES tracking is enabled for all calculators. I seem to have addes this flag > 5 years ago and today I can't tell you why I did this.

  • run_func (Optional[str], default: None) -- By default 'run_calculation()' will be called for the calculator, but with run_func another method name can be specified, e.g., 'get_hessian'.

  • one_calculator (bool, default: False) -- Defaults to false. When enabled all calculations will be carried out using the same calculator object. All geometries must be compatible (same atoms and same atom order) and parallel calculations are not possible. This is a useful option for excited state calculations along a path, e.g., from a COS calculation, as all ES data will be dumped in one 'overlap_data.h5' file.

Return type:

tuple[list[Geometry], list[dict]]

Returns:

  • geoms -- List of geometries that were used for the calculations.

  • all_resuls -- List of calculation results from the different calculations.

pysisyphus.run.run_endopt(irc, endopt_key, endopt_kwargs, calc_getter)[source]
pysisyphus.run.run_from_dict(run_dict, cwd=None, set_defaults=True, yaml_fn=None, cp=None, scheduler=None, clean=False, fclean=False, version=False, restart=False)[source]
pysisyphus.run.run_irc(geom, irc_key, irc_kwargs, calc_getter)[source]
pysisyphus.run.run_md(geom, calc_getter, md_kwargs)[source]
pysisyphus.run.run_mdp(geom, calc_getter, mdp_kwargs)[source]
pysisyphus.run.run_preopt(first_geom, last_geom, calc_getter, preopt_key, preopt_kwargs)[source]
pysisyphus.run.run_scan(geom, calc_getter, scan_kwargs, callback=None)[source]
pysisyphus.run.run_stocastic(stoc)[source]
pysisyphus.run.run_tsopt_from_cos(cos, tsopt_key, tsopt_kwargs, calc_getter=None, ovlp_thresh=0.4, coordinate_union='bonds')[source]
pysisyphus.run.setup_run_dict(run_dict)[source]

17.1.20. 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.21. 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.22. pysisyphus.thermo module

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

Print thermochemical analysis.

17.1.23. pysisyphus.trj module

exception pysisyphus.trj.GotNoGeometryException[source]

Bases: Exception

pysisyphus.trj.align(geoms)[source]

Align all geometries onto the first using partical procrustes.

pysisyphus.trj.align_coords3d_onto_vec(coords3d, ind1, ind2, ref_vec)[source]

Get rotated coords, so vec between ind1 and in2 is parallel to ref_vec.

Can be used to rotate given coordinates in a way, to make a selected bond (distance) vector parallel to a selected axis.

Return type:

ndarray

pysisyphus.trj.append(geoms)[source]
pysisyphus.trj.center(geoms)[source]
pysisyphus.trj.centerm(geoms)[source]
pysisyphus.trj.dump_geoms(geoms, fn_base, trj_infix='', dump_trj=True, dump_xyz=True, dump_pdb=False, ang=False)[source]
pysisyphus.trj.every(geoms, every_nth)[source]
pysisyphus.trj.frag_sort(geoms)[source]
pysisyphus.trj.get(geoms, index)[source]
pysisyphus.trj.get_geoms(xyz_fns, coord_type='cart', geom_kwargs=None, union=False, same_prims=True, quiet=False, interpol_kwargs=None)[source]

Returns a list of Geometry objects in the given coordinate system and interpolates if necessary.

pysisyphus.trj.get_interactively(geoms)[source]
pysisyphus.trj.hardsphere_merge(geoms)[source]
pysisyphus.trj.match(ref_geom, geom_to_match)[source]
pysisyphus.trj.origin(geoms)[source]
pysisyphus.trj.parse_args(args)[source]
pysisyphus.trj.print_internal_vals(geoms, typed_prim)[source]
pysisyphus.trj.print_internals(geoms, filter_atoms=None, add_prims='')[source]
pysisyphus.trj.read_geoms(xyz_fns, coord_type='cart', geom_kwargs=None)[source]
pysisyphus.trj.run()[source]
pysisyphus.trj.sample(geoms, samplen)[source]
pysisyphus.trj.shake(geoms, scale=0.1, seed=None)[source]
pysisyphus.trj.spline_redistribute(geoms)[source]
pysisyphus.trj.standard_orientation(geoms)[source]
pysisyphus.trj.standardize_geoms(geoms, coord_type, geom_kwargs, same_prims=True, union=False)[source]
pysisyphus.trj.translate(geoms, trans)[source]

17.1.24. pysisyphus.version module

17.1.25. 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]
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.26. 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.27. Module contents