Welcome to Open Anharmonic!¶

Open Anharmonic - Usage & Examples¶

This will tell about how to actually use the package, with a focus on interactive usage.

Contents

>>> opan.const.atom_num['CU']
29

>>> opan.const.atom_sym[96]
'CM'

>>> from opan.const import PHYS
>>> PHYS.ANG_PER_BOHR
0.52917721067
>>> PHYS.LIGHT_SPEED                # Atomic units
137.036

>>> from opan.const import UNITS
>>> from opan.const import EnumUnitsRotConst as EURC
>>> UNITS.rot_const[EURC.INV_INERTIA]
'1/(amu*B^2)'
>>> UNITS.rot_const[EURC.ANGFREQ_SECS]
'1/s'

>>> opan.const.EnumDispDirection.NO_DISP
'NO_DISP'

>>> type(opan.const.EnumDispDirection.NO_DISP)
<class 'str'>

>>> from opan.utils.inertia import rot_consts
>>> from opan.const import EnumUnitsRotConst as EURC
>>> rot_consts(some_geom, some_masses, 'INV_INERTIA')       # Works fine
array(...)
>>> rot_consts(some_geom, some_masses, EURC.INV_INERTIA)     # Also works
array(...)

>>> 'NO_DISP' in opan.const.EnumDispDirection
True
>>> [e for e in sorted(opan.const.EnumDispDirection)]
['NEGATIVE', 'NO_DISP', 'POSITIVE']

>>> x = opan.xyz.OpanXYZ(path='error.rst')
Traceback (most recent call last):
...
XYZError: (XYZFILE) No valid geometry found: XYZ file: error.rst

>>> 'XYZFILE' in XYZError
True
>>> [tc for tc in sorted(XYZError)]
['DIHED', 'NONPRL', 'OVERWRITE', 'XYZFILE']

>>> raise XYZError(XYZError.OVERWRITE, "Spurious overwrite", "Console")
Traceback (most recent call last):
...
XYZError: (OVERWRITE) Spurious overwrite: Console

Open Anharmonic - Theory¶

This will introduce the various calculations for which theory is provided here.

Contents:

opan.const¶

Defines objects bearing assorted constants for Open Anharmonic.

opan.error¶

Defines custom errors for Open Anharmonic

Error classes are subclassed from Exception via an abstract superclass, OpanError, which defines several common features:

• Storage of a ‘typecode’ and a ‘source’ string along with the error message to allow passing of more fine-grained information to the exception stack
• Implementation of the EnumIterMeta metaclass on OpanError, enabling typecode validity checking with in
• Re-implementation of __str__() to enhance the usefulness of stack messages when one of these errors is raised

OpanError Subclasses

AnharmError – Raised as a result of OpanVPT2 actions

GradError – Raised during parsing of or calculations using gradient data

HessError – Raised during parsing of or calculations using Hessian data

InertiaError – Raised by opan.utils.inertia submodule functions

OutputError – Raised during parsing of or calculations using output data

RepoError – Raised by HDF5 repository interactions

SymmError – Raised by opan.utils.symm submodule functions

VectorError – Raised by opan.utils.vector submodule functions

XYZError – Raised during parsing of or calculations using XYZ data

API

exception opan.error.AnharmError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to OpanVPT2 actions.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

REPO = 'REPO'¶

OpanAnharmRepo conflict – no repo bound when assignment attempted, or attempt made to bind new repo when one already bound

STATUS = 'STATUS'¶

OpanVPT2 internal variables in inappropriate state for the requested operation

exception opan.error.GradError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to parsing of or calculation from gradient data.

Not all typecodes may be relevant for all software packages.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

BADATOM = 'BADATOM'¶

Missing or invalid atom symbols; SHOULD only be used by SuperOpanGrad

BADGEOM = 'BADGEOM'¶

Missing or invalid geometry data; SHOULD only be used by SuperOpanGrad

BADGRAD = 'BADGRAD'¶

Missing or invalid gradient data; SHOULD only be used by SuperOpanGrad

ENERGY = 'ENERGY'¶

Energy value not found

GEOMBLOCK = 'GEOMBLOCK'¶

Malformed or missing geometry block

GRADBLOCK = 'GRADBLOCK'¶

Malformed or missing gradient block

NUMATS = 'NUMATS'¶

Invalid number-of-atoms specification, or specification not found

OVERWRITE = 'OVERWRITE'¶

Object already initialized (overwrite not supported)

exception opan.error.HessError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to parsing of or calculation from Hessian data.

Not all typecodes may be relevant for all software packages.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

AT_BLOCK = 'AT_BLOCK'¶

Malformed or missing atom/geometry specification block

BADATOM = 'BADATOM'¶

Missing or invalid atom symbols; SHOULD only be used by SuperOpanHess

BADGEOM = 'BADGEOM'¶

Missing or invalid geometry data; SHOULD only be used by SuperOpanHess

BADHESS = 'BADHESS'¶

Missing or invalid Hessian data; SHOULD only be used by SuperOpanHess

DIPDER_BLOCK = 'DIPDER_BLOCK'¶

Malformed dipole derivatives block

EIGVAL_BLOCK = 'EIGVAL_BLOCK'¶

Malformed mass-weighted-Hessian eigenvalues block

EIGVEC_BLOCK = 'EIGVEC_BLOCK'¶

Malformed mass-weighted-Hessian eigenvectors block

ENERGY = 'ENERGY'¶

Malformed or missing energy value

FREQ_BLOCK = 'FREQ_BLOCK'¶

Malformed or missing frequencies block

HESS_BLOCK = 'HESS_BLOCK'¶

Malformed or missing Hessian block

IR_BLOCK = 'IR_BLOCK'¶

Malformed IR spectrum block

JOB_BLOCK = 'JOB_BLOCK'¶

Malformed job list block

MODES_BLOCK = 'MODES_BLOCK'¶

Malformed or missing normal modes block

OVERWRITE = 'OVERWRITE'¶

Object already initialized (overwrite not supported)

POLDER_BLOCK = 'POLDER_BLOCK'¶

Malformed polarizability derivatives block

RAMAN_BLOCK = 'RAMAN_BLOCK'¶

Malformed Raman spectrum block

TEMP = 'TEMP'¶

Malformed or missing temperature value

exception opan.error.InertiaError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to opan.utils.inertia submodule functions.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

BAD_GEOM = 'BAD_GEOM'¶

A geometry being parsed was unsuitable for a particular type of calculation/manipulation

NEG_MOMENT = 'NEG_MOMENT'¶

A negative principal inertial moment was computed

TOP_TYPE = 'TOP_TYPE'¶

No valid molecular top type was identified

exception opan.error.OpanError(tc, msg, src)¶

Bases: Exception

Base class for custom errors defined for Open Anharmonic

OpanError is an abstract superclass of any custom errors defined under the Open Anharmonic umbrella. It defines all common methods shared among the various subtype error classes, such that the only contents that must be declared by a subclass are str class variables with contents identical to their names. These are recognized by the __iter__() defined in opan.const.EnumIterMeta as being the set of valid typecodes.

Parameters:	tc – str – String representation of typecode to be associated with the OpanError subclass instance. Must be a validly constructed typecode defined for the relevant subclass. msg – str – Explanation of the nature of the error being reported src – str – Further detail of the code/file source of the error behavior, if relevant
Raises:	NotImplementedError – Upon attempt to instantiate abstract OpanError base class KeyError – Upon instantiation with an invalid typecode

msg¶

str – Explanation of the nature of the error being reported

src¶

str – Further detail of the code source of the error behavior

subclass_name¶

str – String representation of the OpanError subclass name

tc¶

str – String typecode associated with the instance

__str__()¶

String representation of an OpanError subclass instance.

Implemented primarily so that the error stack handling of the Python interpreter will provide useful information to the user.

Return value is constructed as:

(typecode string) Error message: Error source

Returns:	retstr – str – String representation of the instance.

exception opan.error.OutputError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to parsing of or calculation from output data.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

(none yet)

exception opan.error.RepoError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to HDF5 repository interactions.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

DATA = 'DATA'¶

Problem with a dataset in linked HDF5 File

GROUP = 'GROUP'¶

Problem with a group in linked HDF5 File

STATUS = 'STATUS'¶

HDF5 repo in improper status for requested operation

exception opan.error.SymmError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to opan.utils.symm submodule functions.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

NOTFOUND = 'NOTFOUND'¶

Symmetry element expected but not found

exception opan.error.VectorError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to opan.utils.vector submodule functions.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

NONPRL = 'NONPRL'¶

Insufficient non-parallel character in some manner of calculation

ORTHONORM = 'ORTHONORM'¶

Vectors which should have been orthonormal were determined not to be

exception opan.error.XYZError(tc, msg, src)¶

Bases: opan.error.OpanError

Error relating to parsing of or calculation using XYZ data.

See the OpanError documentation for more information on attributes, methods, etc.

Typecodes

DIHED = 'DIHED'¶

Dihedral angle calculation requested for a set of atoms containing an insufficiently nonlinear trio of atoms

NONPRL = 'NONPRL'¶

Insufficient non-parallel character in some manner of calculation

OVERWRITE = 'OVERWRITE'¶

Object already initialized (overwrite not supported)

XYZFILE = 'XYZFILE'¶

Inconsistent geometry in an OpenBabel XYZ file

• ORCA – .xyz or .trj

opan.grad¶

Module implementing imports of gradient data from external computations.

The abstract superclass SuperOpanGrad defines a common initializer and common method(s) that for use by subclasses importing gradient data from external computational packages.

Implemented Subclasses

OrcaEngrad – Imports ‘.engrad’ files from ORCA

Requirements

• The import for each external software package SHOULD have its own subclass.

• Each subclass MUST implement a _load(self, **kwargs) instance method as the entry point for import of gradient data.

• The gradient data MUST be stored:

  • In the instance member self.gradient
  • As a one-dimensional np.array
  • With dtype descended from np.float
  • In units of Hartrees per Bohr \(\left(\frac{\mathrm{E_h}}{\mathrm B}\right)\)
  • With elements ordered as:
  \[\begin{split}\left[ \begin{array}{cccccccc} \frac{\partial E}{\partial x_1} & \frac{\partial E}{\partial y_1} & \frac{\partial E}{\partial z_1} & \frac{\partial E}{\partial x_2} & \frac{\partial E}{\partial y_2} & \dots & \frac{\partial E}{\partial y_N} & \frac{\partial E}{\partial z_N} \\ \end{array} \right]\end{split}\]

• The geometry data MUST be stored:

  • In the instance member self.geom
  • As a one-dimensional np.array
  • With dtype descended from np.float
  • In units of Bohrs \(\left(\mathrm B\right)\)
  • With elements ordered as:
  \[\begin{split}\left[ \begin{array}{cccccccc} x_1 & y_1 & z_1 & x_2 & y_2 & \dots & y_N & z_N \\ \end{array} \right]\end{split}\]

• The atoms list MUST be stored:

  • In the instance member self.atom_syms
  • As a list of str, with each atom specified by an all-caps atomic symbol (opan.const.atom_sym may be helpful)

• Subclasses MAY define an unlimited number of methods, class variables, and/or instance variables of unrestricted type, in addition to those defined above.

Superclass

class opan.grad.SuperOpanGrad(**kwargs)¶

Abstract superclass of gradient import classes.

Performs the following actions:

1. Ensures that the abstract superclass is not being instantiated, but instead a subclass.
2. Calls the _load() method on the subclass, passing all kwargs through unmodified.
3. Typechecks the self.gradient, self.geom, and self.atom_syms required members for existence, proper data type, and properly matched lengths.

The checks performed in step 3 are primarily for design-time member- and type-enforcement during development of subclasses for newly implemented external software packages, rather than run-time data checking. It is RECOMMENDED to include robust data validity checking inside each subclass, rather than relying on these tests.

Methods

check_geom(coords, atoms[, tol])¶

Check for consistency of gradient geometry with input coords/atoms.

The cartesian coordinates associated with a gradient object are considered consistent with the input coords if each component matches to within tol. If coords or atoms vectors are passed that are of different length than those stored in the instance, a False value is returned, rather than an exception raised.

Parameters:	coords – length-3N np.float_ – Vector of stacked ‘lab-frame’ Cartesian coordinates atoms – length-N str or int – Vector of atom symbols or atomic numbers tol – float, optional Tolerance for acceptable deviation of each passed geometry coordinate from that in the instance to still be considered matching. Default value is DEF.GRAD_COORD_MATCH_TOL

See opan.utils.check_geom for details on return values and exceptions raised.

Subclasses

class opan.grad.OrcaEngrad(path='...')¶

Container for gradient data generated by ORCA.

Initialize by passing the path to the file to be loaded as the path keyword argument.

Key information contained includes the gradient, the energy, the number of atoms, the geometry, and the atom IDs. For ORCA, the precision of the geometry is inferior to that in an XYZ file.

Methods

_load(**kwargs)¶

Initialize OrcaEngrad object from .engrad file

Searches indicated file for energy, geometry, gradient, and number of atoms and stores in the corresponding instance variables.

Parameters:	path – str – Complete path to the .engrad file to be read.
Raises:	GradError Typecode OVERWRITE – If OrcaEngrad instance has already been instantiated. Various typecodes – If indicated gradient file is malformed in some fashion IOError – If the indicated file does not exist or cannot be read

Class Variables

class Pat¶

re.compile() patterns for data parsing.

atblock¶

Captures the entire block of atom ID & geometry data.

atline¶

Extracts single lines from the atom ID / geometry block.

energy¶

Captures the electronic energy.

gradblock¶

Captures the gradient data block.

numats¶

Retrieves the stand-along ‘number of atoms’ field.

Instance Variables

OrcaEngrad.atom_syms¶

length-N list of str – Uppercased atomic symbols for the atoms in the system.

OrcaEngrad.energy¶

float – Single-point energy for the geometry.

OrcaEngrad.geom¶

length-3N np.float_ – Vector of the atom coordinates in \(\mathrm B\).

OrcaEngrad.gradient¶

length-3N np.float_ – Vector of the Cartesian gradient in \(\frac{\mathrm{E_h}}{\mathrm B}\).

OrcaEngrad.in_str¶

str – Complete text of the ENGRAD file read in to generate the OrcaEngrad instance.

OrcaEngrad.num_ats¶

int – Number of atoms in the geometry (‘N’)

opan.hess¶

Module implementing imports of Hessian data from external computations.

The abstract superclass SuperOpanHess defines a common initializer and common method(s) for use by subclasses importing Hessian data from external computational packages.

Implemented Subclasses

OrcaHess – Imports ‘.hess’ files from ORCA

Requirements

• The import for each external software package SHOULD have its own subclass.

• Each subclass MUST implement a _load(**kwargs) method as the entry point for import of Hessian data.

• The Hessian data MUST be stored:

  • In the instance member self.hess
  • As a two-dimensional np.array
  • With dtype descended from np.float
  • In units of Hartrees per Bohr-squared \(\left(\frac{\mathrm{E_h}}{\mathrm B^2}\right)\)
  • With elements arranged as:
  \[\begin{split}\left[ \begin{array}{ccccccc} \frac{\partial^2 E}{\partial x_1^2} & \frac{\partial^2 E}{\partial x_1\partial y_1} & \frac{\partial^2 E}{\partial x_1\partial z_1} & \frac{\partial^2 E}{\partial x_1\partial x_2} & \dots & \frac{\partial^2 E}{\partial x_1\partial y_N} & \frac{\partial^2 E}{\partial x_1\partial z_N} \\ \frac{\partial^2 E}{\partial y_1\partial x_1} & \frac{\partial^2 E}{\partial y_1^2} & \frac{\partial^2 E}{\partial y_1\partial z_1} & \frac{\partial^2 E}{\partial y_1\partial x_2} & \dots & \frac{\partial^2 E}{\partial y_1\partial y_N} & \frac{\partial^2 E}{\partial y_1\partial z_N} \\ \frac{\partial^2 E}{\partial z_1\partial x_1} & \frac{\partial^2 E}{\partial z_1\partial y_1} & \frac{\partial^2 E}{\partial z_1^2} & \frac{\partial^2 E}{\partial z_1\partial x_2} & \dots & \frac{\partial^2 E}{\partial z_1\partial y_N} & \frac{\partial^2 E}{\partial z_1\partial z_N} \\ \frac{\partial^2 E}{\partial x_2\partial x_1} & \frac{\partial^2 E}{\partial x_2\partial y_1} & \frac{\partial^2 E}{\partial x_2\partial z_1} & \frac{\partial^2 E}{\partial x_2^2} & \dots & \frac{\partial^2 E}{\partial x_2\partial y_N} & \frac{\partial^2 E}{\partial x_2\partial z_N} \\ \vdots & \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\ \frac{\partial^2 E}{\partial y_N\partial x_1} & \frac{\partial^2 E}{\partial y_N\partial y_1} & \frac{\partial^2 E}{\partial y_N\partial z_1} & \frac{\partial^2 E}{\partial y_N\partial x_2} & \dots & \frac{\partial^2 E}{\partial y_N^2} & \frac{\partial^2 E}{\partial y_N\partial z_N} \\ \frac{\partial^2 E}{\partial z_N\partial x_1} & \frac{\partial^2 E}{\partial z_N\partial y_1} & \frac{\partial^2 E}{\partial z_N\partial z_1} & \frac{\partial^2 E}{\partial z_N\partial x_2} & \dots & \frac{\partial^2 E}{\partial z_N\partial y_N} & \frac{\partial^2 E}{\partial z_N^2} \\ \end{array} \right]\end{split}\]

  Note

  The Hessian is elsewhere assumed to be symmetric (real-Hermitian), and thus MUST be returned as such here. Symmetric character is NOT explicitly checked, however!

• The geometry data MUST be stored:

  • In the instance member self.geom
  • As a one-dimensional np.array
  • With dtype descended from np.float
  • In units of Bohrs \(\left(\mathrm B\right)\)
  • With elements ordered as:
  \[\begin{split}\left[ \begin{array}{cccccccc} x_1 & y_1 & z_1 & x_2 & y_2 & \dots & y_N & z_N \\ \end{array} \right]\end{split}\]

• The atoms list MUST be stored:

  • In the instance member self.atom_syms
  • As a list of str, with each atom specified by an all-caps atomic symbol (opan.const.atom_sym may be helpful)

• Subclasses MAY define an unlimited number of methods, class variables, and/or instance variables in addition to those defined above, of unrestricted type.

Superclass

class opan.hess.SuperOpanHess(**kwargs)¶

Abstract superclass of Hessian import classes.

Performs the following actions:

1. Ensures that the abstract superclass is not being instantiated, but instead a subclass.
2. Calls the _load() method on the subclass, passing all kwargs through unmodified.
3. Typechecks the self.hess, self.geom, and self.atom_syms required members for existence, proper data type, and properly matched lengths/dimensions.

The checks performed in step 3 are primarily for design-time member and type enforcement during development of subclasses for new external software packages, rather than run-time data checking. It is RECOMMENDED to include robust data validity checking inside each subclass, rather than relying on these tests.

Methods

check_geom(coords, atoms[, tol])¶

Check for consistency of Hessian geometry with input coords/atoms.

The cartesian coordinates associated with a Hessian object are considered consistent with the input coords and atoms if each component matches to within tol and all atoms are identical. If coords or atoms vectors are passed that are of different length than those stored in the instance, a False value is returned, rather than an exception raised.

Parameters:	coords – length-3N np.float_ – Vector of stacked ‘lab-frame’ Cartesian coordinates atoms – length-N str or int – Vector of atom symbols or atomic numbers tol – float, optional – Tolerance for acceptable deviation of each passed geometry coordinate from that in the instance to still be considered matching. Default value is DEF.HESS_COORD_MATCH_TOL

See opan.utils.check_geom for details on return values and exceptions raised.

Subclasses

class opan.hess.OrcaHess(path='...')¶

Container for HESS data generated by ORCA.

Initialize by passing the path to the file to be loaded as the path keyword argument.

Information contained includes the Hessian matrix, the number of atoms, the atomic symbols, the atomic weights, and the geometry, as reported in the .hess file. See ‘Instance Variables’ below for a full list. For variables marked “required”, a HessError is raised if the block is not found, whereas for variables marked “optional” a None value is stored. For either type, if the data is malformed or invalid in some fashion, a HessError is raised with an appropriate typecode.

Zero frequencies corresponding to translation/rotation are not excised from the frequencies list, normal modes, IR spectrum, Raman spectrum, etc.

The precision of the geometry is less than that reported in an .xyz file, and thus should not be used for generation of subsequent computations.

Output units:

• Hessian : Hartrees per Bohr-squared \(\left(\frac{\mathrm{E_h}}{\mathrm{B}^2}\right)\)
• Frequencies : Wavenumbers \(\left(\frac{\mathrm{cyc}}{\mathrm{cm}}\right)\)
• IR intensities (\(T^2\) values) : \(\frac{\mathrm{km}}{\mathrm{mol}}\)
• Raman activities : \(\frac{\mathring{\mathrm{A}}^4}{\mathrm u}\)
• Dipole derivatives : (???)
• Polarizability derivatives : (???)
• Eigenvalues of the mass-weighted Hessian : \(\frac{\mathrm{E_h}}{\mathrm{u\,B^2}}\)
• Eigenvectors of the mass-weighted Hessian : (dimensionless)

Methods

_load(**kwargs)¶

Initialize OrcaHess Hessian object from .hess file

Searches indicated file for data blocks within the .hess file. The geometry, Hessian block, frequencies, and normal modes must be present and will be retrieved; other blocks will be imported if present, or ignored if absent (stored as None in the resulting object). If malformed/inaccurate data is found in any block that is present, some flavor of HessError will be raised.

Parameters:	path – str – kwargs parameter specifying complete path to the .hess file to be read.
Raises:	HessError – (various typecodes) If indicated Hessian file is malformed in some fashion. KeyError – If invalid atomic symbol appears in .hess file. IOError – If the indicated file does not exist or cannot be read.

Class Variables

class Pat¶

re.compile() patterns for data parsing.

at_block¶

Captures the entire block of atom IDs & weights, as well as the geometry data.

at_line¶

Retrieves individual lines within the atom / geometry specification block.

dipder_block¶

Captures the entire dipole derivatives block.

dipder_line¶

Retrieves individual lines in the dipole derivatives block.

eigvals_block¶

Captures the entire mass-weighted Hessian eigenvalues block.

eigvals_line¶

Retrieves individual lines of the mass-weighted hessian eigenvalues block.

eigvecs_block¶

Captures the entire set of mass-weighted Hessian eigenvectors blocks.

eigvecs_sec¶

Extracts sections (individual blocks) of the mass-weighted Hessian eigenvectors blocks.

eigvecs_line¶

Retrieves individual lines of a mass-weighted Hessian eigenvectors block.

energy¶

Retrieves the energy reported in the .hess file.

freq_block¶

Captures the entire vibrational frequencies block.

freq_line¶

Retrieves individual lines of the frequencies block.

hess_block¶

Captures the entire set of Hessian blocks.

hess_sec¶

Extracts full-height, 3- or 6-column sections (individual blocks) of the set of Hessian blocks.

hess_line¶

Retrieves individual lines within a Hessian block.

jobs_block¶

Captures the entire job list block.

jobs_line¶

Retrieves individual lines of the job list block.

ir_block¶

Captures the entire IR spectrum block

ir_line¶

Retrieves individual lines of the IR spectrum block

modes_block¶

Captures the entire set of (weighted, column-normalized) normal modes blocks

modes_sec¶

Extracts full-height, 3- or 6-column sections (individual blocks) of the set of normal modes blocks

modes_line¶

Retrieves individual lines within a normal modes block

polder_block¶

Captures the polarizability derivatives block

polder_line¶

Retrieves individual lines in the polarizability derivatives block

raman_block¶

Captures the Raman spectrum block

raman_line¶

Retrieves individual lines in the Raman spectrum block

temp¶

Retrieves the ‘actual temperature’ field (sometimes is spuriously zero)

Instance Variables

OrcaHess.atom_masses¶

length-N list of np.float_ – List of atom masses as reported in the .hess file

OrcaHess.atom_syms¶

length-N list of str – List of uppercase atomic symbols

OrcaHess.dipders¶

3N x 3 np.float_ – Matrix of dipole derivatives

OrcaHess.energy¶

float – Electronic energy reported in the Hessian file

OrcaHess.freqs¶

length-3N np.float_ – Vibrational frequencies in \(\mathrm{cyc\over cm}\), as reported in the Hessian file

OrcaHess.geom¶

length-3N np.float_ – Geometry vector

OrcaHess.hess¶

3N x 3N np.float_ – Cartesian Hessian matrix

OrcaHess.hess_path¶

str – Complete path/filename from which the Hessian data was retrieved

OrcaHess.in_str¶

str – Complete contents of the imported .hess file

OrcaHess.ir_comps¶

3N x 3 np.float_ – \(\left(T_x, T_y, T_z\right)\) components of the transition dipole for each normal mode

OrcaHess.ir_mags¶

length-3N np.float_ – \(T^2\) values (squared-magnitudes) of the transition dipole for each mode

OrcaHess.joblist¶

N x 3 bool – Completion status for each displacement in calculation of the Hessian

OrcaHess.modes¶

3N x 3N np.float_ – Rotation- and translation-purified, mass-weighted vibrational normal modes, with each mode (column vector) separately normalized by ORCA.

OrcaHess.mwh_eigvals¶

length-3N np.float_ – Eigenvalues of the mass-weighted Hessian, in \(\mathrm{E_h \over u\,B^2}\)

OrcaHess.mwh_eigvecs¶

3N x 3N np.float_ – Eigenvectors of the mass-weighted Hessian, as column vectors: the eigenvector of eigenvalue \(i\) would be retrieved with mwh_eigvecs[:,i]

OrcaHess.num_ats¶

int – Number of atoms in the system

OrcaHess.polders¶

3N x 6 np.float_ – Matrix of Cartesian polarizability derivatives

OrcaHess.raman_acts¶

length-3N np.float_ – Vector of Raman activities

OrcaHess.raman_depols¶

length-3N np.float_ – Vector of Raman depolarization factors

OrcaHess.temp¶

float – “Actual temperature” reported in the .hess file. Occasionally stored by ORCA as a meaningless zero value instead of the temperature used.

opan.output¶

Module implementing parsing of output data from external computations.

Superclass

To be implemented

Implemented Subclasses

OrcaOutput – Imports output files from ORCA

Subclasses

class opan.output.OrcaOutput(file_path)¶

Container for parsed textual output generated by ORCA.

All implemented results that are found in the indicated output are stored in the OrcaOutput instance. If a given quantity was not detectable, it is stored as None in the corresponding instance variable.

Note

In particular, thermochemistry from single atom/ion computations should work, with None or zero/negligible values returned for rotational and vibrational quantities.

The verbose contents of the output file are not generally retained within the OrcaOutput instance due to the potential for such to involve a tremendously large string. Exceptions include, if present:

• THERMOCHEMISTRY section

Contents

• Methods
  • __init__()
  • en_last()
• Class Variables
  • Enumerations
    • EN
    • SPINCONT
    • THERMO
  • Regular Expression Patterns
    • p_en
    • p_spincont
    • p_thermo
• Instance Variables

Methods

__init__(file_path)¶

Initialize OrcaOutput object.

Imports the data found in the output file found at file_path.

Warning

THIS CLASS PRESENTLY ONLY WORKS ON A VERY SMALL SUBSET OF COMPUTATION TYPES, currently HF, LDA-DFT, GGA-DFT, and mGGA-DFT. MAY work on some double-hybrid or range-separated DFT.

Available data includes:

• SCF energies (incl D3BJ, gCP, COSMO outlying charge corrections)
• Thermochemistry
• Spin expectation values (actual, ideal, and deviation)

Success indicators include:

• completed

  Checks for the ‘ORCA TERMINATED NORMALLY’ report at the end of the file

• converged

  Checks for any occurrence of successful SCF convergence in the file (questionable for anything but single-point calculations)

• optimized

  Checks for any occurrence of “OPTIMIZATION HAS CONVERGED” in the file (questionable for anything but a standalone OPT – i.e., not useful for a mode or internal coordinate scan)

Parameters:	file_path – str – Full path to the output file to be parsed.
Raises:	OutputError – (various typecodes) If indicated output is un-parseably malformed in some fashion

en_last()¶

Report the energies from the last SCF present in the output.

Returns a dict providing the various energy values from the last SCF cycle performed in the output. Keys are those of p_en. Any energy value not relevant to the parsed output is assigned as None.

Returns:	last_ens – dict of np.float_– Energies from the last SCF present in the output.

Class Variables

Enumerations

class EN¶

OpanEnum for the energies reported at the end of SCF cycles.

D3¶

Grimme’s D3BJ dispersion correction [Gri10]. May or may not play nicely with D3ZERO. Likely non-functional with DFT-NL dispersion.

GCP¶

Grimme’s geometric counterpose (gCP) correction [Kru12]

OCC¶

COSMO outlying charge correction

SCFFINAL¶

SCF energy including gCP and D3 corrections

SCFFINALOCC¶

SCFFINAL energy, but also with COSMO outlying charge correction

SCFOCC¶

SCF energy with only the COSMO outlying charge correction (no dispersion or gCP corrections)

class OrcaOutput.SPINCONT¶

OpanEnum for the spin contamination values reported after each unrestricted SCF cycle.

ACTUAL¶

Calculated \(\left<S^2\right>\) expectation value

DEV¶

Deviation of \(\left<S^2\right>\) (calculated minus ideal)

IDEAL¶

Ideal \(\left<S^2\right>\) expectation value

class OrcaOutput.THERMO¶

OpanEnum for the quantities reported in the THERMOCHEMISTRY block.

BLOCK¶

Entire THERMOCHEMISTRY block (as str)

E_EL¶

Electronic energy from the thermochemistry block, often slightly different than the last EN.SCFFINAL value \(\left(\mathrm{E_h}\right)\)

E_ROT¶

Thermal rotational internal energy correction \(\left(\mathrm{E_h}\right)\)

E_TRANS¶

Thermal translational internal energy correction \(\left(\mathrm{E_h}\right)\)

E_VIB¶

Thermal vibrational internal energy correction \(\left(\mathrm{E_h}\right)\)

E_ZPE¶

Zero-point energy correction \(\left(\mathrm{E_h}\right)\)

H_IG¶

Ideal-gas \(\left(k_\mathrm{B} T\right)\) enthalpy contribution \(\left(\mathrm{E_h}\right)\)

PRESS¶

Simulated pressure \(\left(\mathrm{atm}\right)\)

QROT¶

Rotational partition function (unitless)

TEMP¶

Simulated temperature \(\left(\mathrm K\right)\)

TS_EL¶

Electronic \(TS\) entropy contribution \(\left(\mathrm{E_h}\right)\)

TS_TRANS¶

Translational \(TS\) entropy contribution \(\left(\mathrm{E_h}\right)\)

TS_VIB¶

Vibrational \(TS\) entropy contribution \(\left(\mathrm{E_h}\right)\)

Regular Expression Patterns

OrcaOutput.p_en¶

dict of re.compile() for the energies reported at the end of SCF cycles. Keys are in EN.

OrcaOutput.p_spincont¶

dict of re.compile() for the spin contamination block values. Keys are in SPINCONT.

OrcaOutput.p_thermo¶

dict of re.compile() for the quantities extracted from the THERMOCHEMISTRY block. Keys are in THERMO.

Instance Variables

OrcaOutput.completed¶

bool – True if ORCA output reports normal termination, False otherwise.

OrcaOutput.converged¶

bool – True if SCF converged ANYWHERE in run.

OrcaOutput.en¶

dict of list of np.float_– Lists of the various energy values from the parsed output. Dict keys are those of EN, above. Any energy type not found in the output is assigned as an empty list.

OrcaOutput.optimized¶

bool – True if any OPT converged ANYWHERE in run. Fine for OPT, but ambiguous for scans.

OrcaOutput.spincont¶

dict of list of np.float_– Lists of the various values from the spin contamination calculations in the output, if present. Empty lists if absent. Dict keys are those of SPINCONT, above.

OrcaOutput.src_path¶

str – Full path to the associated output file

OrcaOutput.thermo¶

dict of np.float_– Values from the thermochemistry block of the parsed output. Dict keys are those of THERMO, above.

OrcaOutput.thermo_block¶

str – Full text of the thermochemistry block, if found.

opan.utils¶

Utility functions for Open Anharmonic, including execution automation.

Sub-Modules

decorate – Custom Open Anharmonic decorators

execute – Functions for execution of external computational software packages

inertia – Inertia-related tools (center of mass, rotational constants, principal moments/axes, etc.)

symm – Molecular symmetry utility functions (INCOMPLETE)

vector – Vector utility functions

Functions

opan.utils.base.assert_npfloatarray(obj, varname, desc, exc, tc, errsrc)¶

Assert a value is an np.array of NumPy floats.

Pass None to varname if obj itself is to be checked. Otherwise, varname is the string name of the attribute of obj to check. In either case, desc is a string description of the object to be checked, for use in raising of exceptions.

Raises the exception exc with typecode tc if the indicated object is determined not to be an np.array, with a NumPy float dtype.

Intended primarily to serve as an early check for proper implementation of subclasses of SuperOpanGrad and SuperOpanHess. Early type-checking of key attributes will hopefully avoid confusing bugs downstream.

Parameters:

obj – (arbitrary) – Object to be checked, or object with attribute to be checked. varname – str or None – Name of the attribute of obj to be type-checked. None indicates to check obj itself. desc – str – Description of the object being checked to be used in any raised exceptions. exc – Subclass of OpanError to be raised on a failed typecheck. tc – Typecode of exc to be raised on a failed typecheck. errsrc – str – String description of the source of the data leading to a failed typecheck.

opan.utils.base.check_geom(c1, a1, c2, a2[, tol])¶

Check for consistency of two geometries and atom symbol lists

Cartesian coordinates are considered consistent with the input coords if each component matches to within tol. If coords or atoms vectors are passed that are of mismatched lengths, a False value is returned.

Both coords vectors must be three times the length of the atoms vectors or a ValueError is raised.

Parameters:	c1 – length-3N np.float_ – Vector of first set of stacked ‘lab-frame’ Cartesian coordinates a1 – length-N str or int – Vector of first set of atom symbols or atomic numbers c2 – length-3N np.float_ – Vector of second set of stacked ‘lab-frame’ Cartesian coordinates a2 – length-N str or int – Vector of second set of atom symbols or atomic numbers tol – float, optional – Tolerance for acceptable deviation of each geometry coordinate from that in the reference instance to still be considered matching. Default value is specified by opan.const.DEF.XYZ_COORD_MATCH_TOL)
Returns:	match – bool – Whether input coords and atoms match (True) or not (False) fail_type – EnumCheckGeomMismatch or None – Type of check failure If match == True: Returns as None If match == False: An EnumCheckGeomMismatch value indicating the reason for the failed match: DIMENSION – Mismatch in geometry size (number of atoms) COORDS – Mismatch in one or more coordinates ATOMS – Mismatch in one or more atoms fail_loc – length-3N bool or length-N bool or None – Mismatched elements If match == True: Returns as None If match == False: For “array-level” problems such as a dimension mismatch, a None value is returned. For “element-level” problems, a vector is returned indicating positions of mismatch in either coords or atoms, depending on the value of fail_type. True elements indicate MATCHING values False elements mark MISMATCHES
Raises:	ValueError – If a pair of coords & atoms array lengths is inconsistent: if len(c1) != 3 * len(a1) or len(c2) != 3 * len(a2): raise ValueError(...)

opan.utils.base.delta_fxn(a, b)¶

Kronecker delta for objects a and b.

Parameters:	a – First object b – Second object
Returns:	delta – int – Value of Kronecker delta for provided indices, as tested by Python ==

opan.utils.base.iterable(y)¶

Check whether or not an object supports iteration.

Adapted directly from NumPy ~= 1.10 at commit 46d2e83.

Parameters:	y – (arbitrary) – Object to be tested.
Returns:	test – bool – Returns False if iter() raises an exception when y is passed to it; True otherwise.

Examples

>>> opan.utils.iterable([1, 2, 3])
True
>>> opan.utils.iterable(2)
False

opan.utils.base.make_timestamp(el_time)¶

Generate an hour-minutes-seconds timestamp from an interval in seconds.

Assumes numeric input of a time interval in seconds. Converts this interval to a string of the format “#h #m #s”, indicating the number of hours, minutes, and seconds in the interval. Intervals greater than 24h are unproblematic.

Parameters:	el_time – int or float – Time interval in seconds to be converted to h/m/s format
Returns:	stamp – str – String timestamp in #h #m #s format

opan.utils.base.pack_tups(*args)¶

Pack an arbitrary set of iterables and non-iterables into tuples.

Function packs a set of inputs with arbitrary iterability into tuples. Iterability is tested with iterable(). Non-iterable inputs are repeated in each output tuple. Iterable inputs are expanded uniformly across the output tuples. For consistency, all iterables must be the same length.

The input arguments are parsed such that bare strings are treated as NON-ITERABLE, through the use of a local subclass of str that cripples the __iter__() method. Any strings passed are returned in the packed tuples as standard, ITERABLE instances of str, however.

The order of the input arguments is retained within each output tuple.

No structural conversion is attempted on the arguments.

If all inputs are non-iterable, a list containing a single tuple will be returned.

Parameters:	*args – Arbitrary number of arbitrary mix of iterable and non-iterable objects to be packed into tuples.
Returns:	tups – list of tuple – Number of tuples returned is equal to the length of the iterables passed in *args
Raises:	ValueError – If any iterable objects are of different lengths

opan.utils.base.safe_cast(invar, totype)¶

Performs a “safe” typecast.

Ensures that invar properly casts to totype. Checks after casting that the result is actually of type totype. Any exceptions raised by the typecast itself are unhandled.

Parameters:	invar – (arbitrary) – Value to be typecast. totype – type – Type to which invar is to be cast.
Returns:	outvar – type ‘totype’ – Typecast version of invar
Raises:	TypeError – If result of typecast is not of type totype

opan.utils.base.template_subst(template, subs[, delims=['<', '>']])¶

Perform substitution of content into tagged string.

For substitutions into template input files for external computational packages, no checks for valid syntax are performed.

Each key in subs corresponds to a delimited substitution tag to be replaced in template by the entire text of the value of that key. For example, the dict {"ABC": "text"} would convert The <ABC> is working to The text is working, using the default delimiters of ‘<’ and ‘>’. Substitutions are performed in iteration order from subs; recursive substitution as the tag parsing proceeds is thus feasible if an OrderedDict is used and substitution key/value pairs are added in the proper order.

Start and end delimiters for the tags are modified by delims. For example, to substitute a tag of the form {|TAG|}, the tuple ("{|","|}") should be passed to subs_delims. Any elements in delims past the second are ignored. No checking is performed for whether the delimiters are “sensible” or not.

Parameters:

template – str – Template containing tags delimited by subs_delims, with tag names and substitution contents provided in subs subs – dict of str – Each item’s key and value are the tag name and corresponding content to be substituted into the provided template. delims – iterable of str – Iterable containing the ‘open’ and ‘close’ strings used to mark tags in the template, which are drawn from elements zero and one, respectively. Any elements beyond these are ignored.

Returns:

subst_text – str – String generated from the parsed template, with all tag substitutions performed.

opan.vpt2¶

Submodule implementing VPT2 anharmonic computations.

Sub-Modules

repo – HDF5 repository for OpanVPT2

Classes

OpanVPT2 – Core driver class for VPT2 anharmonic calculations.

API

class opan.vpt2.base.OpanVPT2¶

Container for data from VPT2 anharmonic calculations.

To be added...

opan.xyz¶

Module implementing OpenBabel XYZ parsing and interpretation.

The single class OpanXYZ imports molecular geometries in the OpenBabel XYZ format , with the following variations:

• Coordinates of any precision will be read, not just the \(10.5\) specified by OpenBabel
• Both atomic symbols and atomic numbers are valid
• Multiple geometries/frames are supported, but the number of atoms and their sequence in the atoms list must be maintained in all geometries.

Contents

Class Variables

Instance Variables

Methods

All return values from a single indicated geometry.

geom_single() – Entire geometry vector

displ_single() – Displacement between two atoms

dist_single() – Euclidean distance between two atoms

angle_single() – Spanned angle of three atoms (one central and two distal atoms)

dihed_single() – Dihedral angle among four atoms

Generators

All yielded values are composited from an arbitrary set of geometry and/or atom indices; indexing with negative values is supported.

Each parameter can either be a single index, or an iterable of indices. If any iterables are passed, all must be the same length R, and a total of R values will be returned, one for each set of elements across the iterables. (This behavior is loosly similar to Python’s zip() builtin.) Single values are used as provided for all values returned.

As an additional option, a None value can be passed to exactly one parameter, which will then be assigned the full ‘natural’ range of that parameter (range(G) for g_nums and range(N) for ats_#).

If the optional parameter invalid_error is False (the default), if IndexError or ValueError is raised in the course of calculating a given value, it is ignored and a None value is returned. If True, then the errors are raised as-is.

Note

For angle_iter() and dihed_iter(), using a None parameter with invalid_error == True is guaranteed to raise an error.

geom_iter() – Geometries

displ_iter() – Displacement vectors

dist_iter() – Euclidean distances

angle_iter() – Span angles

dihed_iter() – Dihedral angles

Class Definition

class opan.xyz.OpanXYZ(**kwargs)¶

Container for OpenBabel XYZ data.

Initializer can be called in one of two forms:

OpanXYZ(path='path/to/file')
OpanXYZ(atom_syms=[{array of atoms}], coords=[{array of coordinates}])

If path is specified, atom_syms and coords are ignored, and the instance will contain all validly formatted geometries present in the OpenBabel file at the indicated path.

Note

Certain types of improperly formatted geometry blocks, such as one with alphabetic characters on the ‘number-of-atoms’ line, may not raise errors during loading, but instead just result in import of fewer geometries/frames than expected.

If initialized with the atom_syms and coords keyword arguments, the instance will contain the single geometry represented by the provided inputs.

In both forms, the optional keyword argument bohrs can be specified, to indicate the units of the coordinates as Bohrs (True) or Angstroms (False). Angstrom and Bohr units are the default for the path and atom_syms/coords forms, respectively. The units of all coordinates stored in the instance are Bohrs.

‘N’ and ‘G’ in the below documentation refer to the number of atoms per geometry and the number of geometries present in the file, respectively. Note that ALL geometries present MUST contain the same number of atoms, and the elements must all FALL IN THE SAME SEQUENCE in each geometry/frame. No error will be raised if positions of like atoms are swapped, but for obvious reasons this will almost certainly cause semantic difficulties in downstream computations.

Note

In ORCA ‘.xyz’ files contain the highest precision geometry information of any output (save perhaps the textual output generated by the program), and are stored in Angstrom units.

Class Variables

p_coords¶

re.compile() pattern – Retrieves individual lines from coordinate blocks matched by p_geom

p_geom¶

re.compile() pattern – Retrieves full OpenBabel XYZ geometry frames/blocks

LOAD_DATA_FLAG = 'NOT FILE'¶

str – Flag for irrelevant data in atom_syms/coords initialization mode.

Instance Variables

Except where indicated, all str and list-of-str values are stored as LOAD_DATA_FLAG when initialized with atom_syms/coords arguments.

atom_syms¶

length-N str – Atomic symbols for the atoms (all uppercase)

descs¶

length-G str – Text descriptions for each geometry included in a loaded file

geoms¶

length-G list of length-3N np.float_ – Molecular geometry/geometries read from file or passed to coords argument

in_str¶

str – Complete contents of the input file

num_atoms¶

int – Number of atoms per geometry, N

num_geoms¶

int – Number of geometries, G

XYZ_path¶

str – Full path to imported OpenBabel file

Methods

geom_single(g_num)¶

Retrieve a single geometry.

The atom coordinates are returned with each atom’s x/y/z coordinates grouped together:

[A1x, A1y, A1z, A2x, A2y, A2z, ...]

An alternate method to achieve the same effect as this function is by simply indexing into geoms:

>>> x = opan.xyz.OpanXYZ(path='...')
>>> x.geom_single(g_num)    # One way to do it
>>> x.geoms[g_num]          # Another way

Parameters:	g_num – int – Index of the desired geometry
Returns:	geom – length-3N np.float_ – Vector of the atomic coordinates for the geometry indicated by g_num
Raises:	IndexError – If an invalid (out-of-range) g_num is provided

displ_single(g_num, at_1, at_2)¶

Displacement vector between two atoms.

Returns the displacement vector pointing from at_1 toward at_2 from geometry g_num. If at_1 == at_2 a strict zero vector is returned.

Displacement vector is returned in units of Bohrs.

Parameters:	g_num – int – Index of the desired geometry at_1 – int – Index of the first atom at_2 – int – Index of the second atom
Returns:	displ – length-3 np.float_ – Displacement vector from at_1 to at_2
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided

dist_single(g_num, at_1, at_2)¶

Distance between two atoms.

Parameters:	g_num – int – Index of the desired geometry at_1 – int – Index of the first atom at_2 – int – Index of the second atom
Returns:	dist – np.float_ – Distance in Bohrs between at_1 and at_2 from geometry g_num
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided

angle_single(g_num, at_1, at_2, at_3)¶

Spanning angle among three atoms.

The indices at_1 and at_3 can be the same (yielding a trivial zero angle), but at_2 must be different from both at_1 and at_3.

Parameters:	g_num – int – Index of the desired geometry at_1 – int – Index of the first atom at_2 – int – Index of the second atom at_3 – int – Index of the third atom
Returns:	angle – np.float_ – Spanning angle in degrees between at_1-at_2-at_3, from geometry g_num
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided ValueError – If at_2 is equal to either at_1 or at_3

dihed_single(g_num, at_1, at_2, at_3, at_4)¶

Dihedral/out-of-plane angle among four atoms.

Returns the out-of-plane angle among four atoms from geometry g_num, in degrees. The reference plane is spanned by at_1, at_2 and at_3. The out-of-plane angle is defined such that a positive angle represents a counter-clockwise rotation of the projected at_3\(\rightarrow\)at_4 vector with respect to the reference plane when looking from at_3 toward at_2. Zero rotation corresponds to occlusion of at_1 and at_4; that is, the case where the respective rejections of at_1 \(\rightarrow\)at_2 and at_3\(\rightarrow\)at_4 onto at_2\(\rightarrow\)at_3 are ANTI-PARALLEL.

All four atom indices must be distinct. Both of the atom trios 1-2-3 and 2-3-4 must be sufficiently nonlinear, as diagnosed by a bend angle different from 0 or 180 degrees by at least PRM.NON_PARALLEL_TOL.

Parameters:	g_num – int – Index of the desired geometry at_1 – int – Index of the first atom at_2 – int – Index of the second atom at_3 – int – Index of the third atom at_4 – int – Index of the fourth atom
Returns:	dihed – np.float_ – Out-of-plane/dihedral angle in degrees for the indicated at_#, drawn from geometry g_num
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided ValueError – If any indices at_# are equal XYZError – (typecode DIHED) If either of the atom trios (1-2-3 or 2-3-4) is too close to linearity

Generators

geom_iter(g_nums)¶

Iterator over a subset of geometries.

The indices of the geometries to be returned are indicated by an iterable of ints passed as g_nums.

As with geom_single(), each geometry is returned as a length-3N np.float_ with each atom’s x/y/z coordinates grouped together:

[A1x, A1y, A1z, A2x, A2y, A2z, ...]

In order to use NumPy slicing or advanced indexing, geoms must first be explicitly converted to np.array, e.g.:

>>> x = opan.xyz.OpanXYZ(path='...')
>>> np.array(x.geoms)[[2,6,9]]

Parameters:	g_nums – length-R iterable of int – Indices of the desired geometries
Yields:	geom – length-3N np.float_ – Vectors of the atomic coordinates for each geometry indicated in g_nums
Raises:	IndexError – If an item in g_nums is invalid (out of range)

displ_iter(g_nums, ats_1, ats_2)¶

Iterator over indicated displacement vectors.

Displacements are in Bohrs as with displ_single().

See above for more information on calling options.

Parameters:	g_nums – int or length-R iterable int or None – Index/indices of the desired geometry/geometries ats_1 – int or length-R iterable int or None – Index/indices of the first atom(s) ats_2 – int or length-R iterable int or None – Index/indices of the second atom(s) invalid_error – bool, optional – If False (the default), None values are returned for results corresponding to invalid indices. If True, exceptions are raised per normal.
Yields:	displ – np.float_ – Displacement vector in Bohrs between each atom pair of ats_1 \(\rightarrow\) ats_2 from the corresponding geometries of g_nums.
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided. ValueError – If all iterable objects are not the same length.

dist_iter(g_nums, ats_1, ats_2)¶

Iterator over selected interatomic distances.

Distances are in Bohrs as with dist_single().

See above for more information on calling options.

Parameters:	g_nums – int or length-R iterable int or None – Index/indices of the desired geometry/geometries ats_1 – int or iterable int or None – Index/indices of the first atom(s) ats_2 – int or iterable int or None – Index/indices of the second atom(s) invalid_error – bool, optional – If False (the default), None values are returned for results corresponding to invalid indices. If True, exceptions are raised per normal.
Yields:	dist – np.float_ – Interatomic distance in Bohrs between each atom pair of ats_1 and ats_2 from the corresponding geometries of g_nums.
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided. ValueError – If all iterable objects are not the same length.

angle_iter(g_nums, ats_1, ats_2, ats_3)¶

Iterator over selected atomic angles.

Angles are in degrees as with angle_single().

See above for more information on calling options.

Parameters:	g_nums – int or iterable int or None – Index of the desired geometry ats_1 – int or iterable int or None – Index of the first atom ats_2 – int or iterable int or None – Index of the second atom ats_3 – int or iterable int or None – Index of the third atom invalid_error – bool, optional – If False (the default), None values are returned for results corresponding to invalid indices. If True, exceptions are raised per normal.
Yields:	angle – np.float_ – Spanning angles in degrees between corresponding ats_1-ats_2-ats_3, from geometry/geometries g_nums
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided. ValueError – If all iterable objects are not the same length. ValueError – If any ats_2 element is equal to either the corresponding ats_1 or ats_3 element.

dihed_iter(g_nums, ats_1, ats_2, ats_3, ats_4)¶

Iterator over selected dihedral angles.

Angles are in degrees as with dihed_single().

See above for more information on calling options.

Parameters:	g_nums – int or iterable int or None – Indices of the desired geometry ats_1 – int or iterable int or None – Indices of the first atoms ats_2 – int or iterable int or None – Indices of the second atoms ats_3 – int or iterable int or None – Indices of the third atoms ats_4 – int or iterable int or None – Indices of the fourth atoms invalid_error – bool, optional – If False (the default), None values are returned for results corresponding to invalid indices. If True, exceptions are raised per normal.
Yields:	dihed – np.float_ – Out-of-plane/dihedral angles in degrees for the indicated atom sets ats_1-ats_2-ats_3-ats_4, drawn from the respective g_nums.
Raises:	IndexError – If an invalid (out-of-range) g_num or at_# is provided. ValueError – If all iterable objects are not the same length. ValueError – If any corresponding ats_# indices are equal. XYZError – (typecode DIHED) If either of the atom trios (1-2-3 or 2-3-4) is too close to linearity for any group of ats_#