### Navigation

- index
- modules
- toc
- next
- previous
- PSI4 [beta5] »

# Python Driver

## psiexceptions

Module with non-generic exceptions classes.

exception `PsiException`

  Error class for Psi.

exception `ValidationError`(msg)

  Error called for problems with the input file. Prints error message msg to standard output stream and output file.

## aliases

Module with functions that call upon those in modules `proc`, `driver`, and `wrappers`.

Place in this file quickly defined procedures such as
  - aliases for complex methods
  - simple modifications to existing methods

## gaussian_n

`run_gaussian_2`(name, **kwargs)

## molutil

Module with utility functions that act on molecule objects.

`BFS`(self)

  Perform a breadth-first search (BFS) on the real atoms in molecule, returning an array of atom indices of fragments. Relies upon van der Waals radii and so faulty for close (esp. hydrogen-bonded) fragments. Original code from Michael S. Marshall.

`activate`(mol)

  Function to set molecule object mol as the current active molecule.

`dynamic_variable_bind`(cls)

  Function to dynamically add extra members to the psi4.Molecule class.

`extract_cluster_indexing`(mol, cluster_size=0)

  Function to returns a LIST of all subclusters of the molecule mol of real size cluster_size. If cluster_size = 0, returns all possible combinations of cluster size.

`extract_clusters`(mol, ghost=True, cluster_size=0)

  Function to return all subclusters of the molecule mol of real size cluster_size and all other atoms ghosted if ghost equals true, all other atoms discarded if ghost is false. If cluster_size = 0, returns all possible combinations of cluster size.

`geometry`(geom, name='default')

  Function to create a molecule object of name name from the geometry in string geom.

`new_get_attr`(self, name)

  Function to redefine __getattr__ method of molecule class.

`new_set_attr`(self, name, value)

  Function to redefine __setattr__ method of molecule class.

## proc

`run_adc`(name, **kwargs)

  Function encoding sequence of PSI module calls for an algebraic diagrammatic construction calculation.

  Caution

  Get rid of active molecule lines- should be handled in energy.

`run_bccd`(name, **kwargs)

  Function encoding sequence of PSI module calls for a Brueckner CCD calculation.

`run_bccd_t`(name, **kwargs)

  Function encoding sequence of PSI module calls for a Brueckner CCD(T) calculation.

`run_cc_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a CCSD and CCSD(T) gradient calculation.

`run_cc_property`(name, **kwargs)

  Function encoding sequence of PSI module calls for all CC property calculations.

`run_ccenergy`(name, **kwargs)

  Function encoding sequence of PSI module calls for a CCSD, CC2, and CC3 calculation.

`run_cepa`(name, **kwargs)

  Function encoding sequence of PSI module calls for a cepa-like calculation.

      >>> energy('cepa(1)')

`run_cepa0`(name, **kwargs)

  Function encoding sequence of PSI module calls for a CEPA (LCCD) computation

`run_cepa0_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a CEPA(0) gradient calculation.

`run_dcft`(name, **kwargs)

  Function encoding sequence of PSI module calls for a density cumulant functional theory calculation.

`run_dcft_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for DCFT gradient calculation.

`run_detci`(name, **kwargs)

  Function encoding sequence of PSI module calls for a configuration interaction calculation, namely FCI, CIn, MPn, and ZAPTn.

`run_dfmp2`(name, **kwargs)

  Function encoding sequence of PSI module calls for a density-fitted MP2 calculation.

`run_dfmp2_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a DFMP2 gradient calculation.

`run_dfmp2_property`(name, **kwargs)

  Function encoding sequence of PSI module calls for a DFMP2 property calculation.

`run_dft`(name, **kwargs)

  Function encoding sequence of PSI module calls for a density-functional-theory calculation.

`run_dft_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a density-functional-theory gradient calculation.

`run_eom_cc`(name, **kwargs)

  Function encoding sequence of PSI module calls for an EOM-CC calculation, namely EOM-CC2, EOM-CCSD, and EOM-CC3.

`run_eom_cc_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for an EOM-CCSD gradient calculation.

`run_fnocc`(name, **kwargs)

  Function encoding sequence of PSI module calls for a QCISD(T), CCSD(T), MP2.5, MP3, and MP4 computation.

      >>> energy('fno-ccsd(t)')

`run_fnodfcc`(name, **kwargs)

  Function encoding sequence of PSI module calls for a DF-CCSD(T) computation.

      >>> energy('df-ccsd(t)')

`run_libfock`(name, **kwargs)

  Function encoding sequence of PSI module calls for a calculation through libfock, namely RCPHF, RCIS, RTDHF, RTDA, and RTDDFT.

`run_mcscf`(name, **kwargs)

  Function encoding sequence of PSI module calls for a multiconfigurational self-consistent-field calculation.

`run_mp2`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP2 calculation.

`run_mp2_5`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP2.5 calculation.

`run_mp2_5_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP3 gradient calculation.

`run_mp2_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP2 gradient calculation.

`run_mp2_select`(name, **kwargs)

  Function selecting the algorithm for a MP2 energy call and directing toward the OCC (conv MP2) or the DFMP2 modules.

`run_mp2_select_gradient`(name, **kwargs)

  Function selecting the algorithm for a MP2 gradient call and directing toward the OCC (conv MP2) or the DFMP2 modules.

`run_mp2c`(name, **kwargs)

  Function encoding sequence of PSI module calls for a coupled MP2 calculation.

`run_mp3`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP3 calculation.

`run_mp3_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP3 gradient calculation.

`run_mrcc`(name, **kwargs)

  Function that prepares environment and input files for a calculation calling Kallay’s MRCC code.

`run_ocepa`(name, **kwargs)

  Function encoding sequence of PSI module calls for an orbital-optimized CEPA computation

`run_ocepa_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for OCEPA gradient calculation.

`run_oldmp2`(name, **kwargs)

  Function encoding sequence of PSI module calls for a MP2 calculation.

`run_omp2`(name, **kwargs)

  Function encoding sequence of PSI module calls for an orbital-optimized MP2 computation

`run_omp2_5`(name, **kwargs)

  Function encoding sequence of PSI module calls for an orbital-optimized MP2.5 computation

`run_omp2_5_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for OMP2.5 gradient calculation.

`run_omp2_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for OMP2 gradient calculation.

`run_omp3`(name, **kwargs)

  Function encoding sequence of PSI module calls for an orbital-optimized MP3 computation

`run_omp3_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for OMP3 gradient calculation.

`run_psimrcc`(name, **kwargs)

  Function encoding sequence of PSI module calls for a PSIMRCC computation using a reference from the MCSCF module

`run_psimrcc_scf`(name, **kwargs)

  Function encoding sequence of PSI module calls for a PSIMRCC computation using a reference from the SCF module

`run_sapt`(name, **kwargs)

  Function encoding sequence of PSI module calls for a SAPT calculation of any level.

`run_sapt_ct`(name, **kwargs)

  Function encoding sequence of PSI module calls for a charge-transfer SAPT calcuation of any level.

`run_scf`(name, **kwargs)

  Function encoding sequence of PSI module calls for a self-consistent-field theory (HF & DFT) calculation.

`run_scf_gradient`(name, **kwargs)

  Function encoding sequence of PSI module calls for a SCF gradient calculation.

`run_scf_property`(name, **kwargs)

  Function encoding sequence of PSI module calls for SCF calculations. This is a simple alias to `run_scf()` since SCF properties all handled through oeprop.

`run_scs_omp2`(name, **kwargs)

  Function encoding sequence of PSI module calls for a spin-component scaled OMP2 computation

`run_scs_omp3`(name, **kwargs)

  Function encoding sequence of PSI module calls for a spin-component scaled OMP3 computation

`run_sos_omp2`(name, **kwargs)

  Function encoding sequence of PSI module calls for a spin-opposite scaled OMP2 computation

`run_sos_omp3`(name, **kwargs)

  Function encoding sequence of PSI module calls for a spin-opposite scaled OMP3 computation

`scf_helper`(name, **kwargs)

  Function serving as helper to SCF, choosing whether to cast up or just run SCF with a standard guess. This preserves previous SCF options set by other procedures (e.g., SAPT output file types for SCF).

## inputparser

`bad_option_syntax`(line)

  Function to report bad syntax to screen and output file.

`check_parentheses_and_brackets`(input_string, exit_on_error)

  Function to check that all parenthesis and brackets in input_string are paired. On that condition, exit_on_error =1, otherwise 0.

`parse_multiline_array`(input_list)

  Function to squash multiline arrays into a single line until all parentheses and brackets are fully paired.

`process_basis_block`(matchobj)

  Function to process match of `basis name { ... }`.

`process_basis_file`(matchobj)

  Function to process match of `basis file ...`.

`process_external_command`(matchobj)

  Function to process match of `external name? { ... }`.

`process_extract_command`(matchobj)

  Function to process match of `extract_subsets`.

`process_filename`(matchobj)

  Function to process match of `filename ...`.

`process_input`(raw_input, print_level=1)

  Function to preprocess raw input, the text of the input file, then parse it, validate it for format, and convert it into legitimate Python. raw_input is printed to the output file unless print_level =0. Does a series of regular expression filters, where the matching portion of the input is replaced by the output of the corresponding function (in this module) call. Returns a string concatenating module import lines, a copy of the user’s .psi4rc files, a setting of the scratch directory, a dummy molecule, and the processed raw_input.

`process_memory_command`(matchobj)

  Function to process match of `memory ...`.

`process_molecule_command`(matchobj)

  Function to process match of `molecule name? { ... }`.

`process_multiline_arrays`(inputfile)

  Function to find array inputs that are spread across multiple lines and squash them into a single line.

`process_option`(spaces, module, key, value, line)

  Function to process a line with set or in a set block into global/local domain and keyword/value.

`process_pcm_command`(matchobj)

  Function to process match of `pcm name? { ... }`.

`process_print_command`(matchobj)

  Function to process match of `print` and transform it to `psi4.print_out()`.

`process_pubchem_command`(matchobj)

  Function to process match of `pubchem` in molecule block.

`process_set_command`(matchobj)

  Function to process match of all individual `set (module_list) key {[value_list] or $value or value}`.

`process_set_commands`(matchobj)

  Function to process match of `set name? { ... }`.

`process_word_quotes`(matchobj)

  Function to determine if argument needs wrapping in quotes as string.

`quotify`(string)

  Function to wrap anything that looks like a string in quotes and to remove leading dollar signs from python variables.

## dashparam

Module to hold and distribute the -D dispersion correction parameters.

`dash_server`(func, dashlvl, mode='psi4')

  Function to serve up dispersion correction parameters in whatever form needed. When mode is ‘dftd3’, returns a string suitable for writing to ./dftd3_parameters to calculuate the correction at dashlvl with the default parameters for functional func. When mode is ‘psi4’, returns a tuple of arguments suitable for building a Dispersion object with dashlvl parameters for functional func.

  There are four computational dashlvl choices. ‘d2p4’ calls the -D2 correction within psi4 (hence, faked for mode=’dftd3’). The other three, ‘d2gr’, ‘d3zero’, and ‘d3bj’ call the three dftd3 modes of operation (corresponding to -old, -zero, -bj). Additionally, there are three aliased dashlvl choices since the aliases in dash_alias above are imposed.

## wrappers

Module with functions that call the four main `driver` functions: `driver.energy`, `driver.optimize`, `driver.response`, and `driver.frequency`.

`auto_fragments`(name, **kwargs)

  Detects fragments if the user does not supply them. Currently only used for the WebMO implementation of SAPT

  usage: auto_fragments(‘’)

`call_function_in_1st_argument`(funcarg, **largs)

  Function to make primary function call to energy(), opt(), etc. with options dictionary largs. Useful when funcarg to call is stored in variable.

`convert`(p, symbol)

`reconstitute_bracketed_basis`(needarray)

  Function to reform a bracketed basis set string from a sequential series of basis sets (e.g, form ‘cc-pv[q5]z’ from array [cc-pvqz, cc-pv5z]). The basis set array is extracted from the f_basis field of a NEED dictionary in `complete_basis_set()`. Result is used to print a nicely formatted basis set string in the results table.

`split_menial`(menial)

  Function used by `complete_basis_set()` to separate menial ‘scftot’ into [scf, tot] and ‘mp2corl’ into [mp2, corl].

`tblhead`(tbl_maxrgt, tbl_delimit, ttype)

  Function that prints the header for the changable-width results tables in db(). tbl_maxrgt is the number of reagent columns the table must plan for. tbl_delimit is a string of dashes of the correct length to set off the table. ttype is 1 for tables comparing the computed values to the reference or 2 for simple tabulation and sum of the computed values.

`validate_bracketed_basis`(basisstring)

  Function to transform and validate basis sets for cbs(). A basis set with no paired square brackets is passed through with zeta level 0 (e.g., ‘6-31+G(d,p)’ is returned as [6-31+G(d,p)] and [0]). A basis set with square brackets is checked for sensible sequence and Dunning-ness and returned as separate basis sets (e.g., ‘cc-pV[Q5]Z’ is returned as [cc-pVQZ, cc-pV5Z] and [4, 5]). Note that this function has no communication with the basis set library to check if the basis actually exists. Used by `complete_basis_set()`.

`validate_scheme_args`(functionname, **largs)

  Function called by each extrapolation scheme in `complete_basis_set()`. Checks that all the input arguments are present and suitable so that the scheme function can focus on defining the extrapolation.

## pcmpreprocess

`convert_area_scalar`(keyword)

`convert_length_array`(keyword)

`convert_length_scalar`(keyword)

`preprocess`()

  Takes the PCM input file in @pcmsolver.inp, and preprocesses to make it machine-readable.

`setup_keywords`()

`verify_cavity`(section)

`verify_green`(section)

`verify_medium`(section)

`verify_spheres`(keyword)

`verify_top`(section)

## interactive

`run`()

## frac

`frac_nuke`(mol, **kwargs)

`frac_traverse`(mol, **kwargs)

`ip_fitting`(mol, omega_l, omega_r, **kwargs)

## functional

Module to provide lightweight definitions of functionals and SuperFunctionals

`build_b2plyp_superfunctional`(name, npoints, deriv)

`build_b2plypd2gr_superfunctional`(name, npoints, deriv)

`build_b2plypd2p4_superfunctional`(name, npoints, deriv)

`build_b2plypd3bj_superfunctional`(name, npoints, deriv)

`build_b2plypd3zero_superfunctional`(name, npoints, deriv)

`build_b3_x_functional`(name)

`build_b3lyp5_superfunctional`(name, npoints, deriv)

`build_b3lyp5d2gr_superfunctional`(name, npoints, deriv)

`build_b3lyp5d2p4_superfunctional`(name, npoints, deriv)

`build_b3lyp5d3bj_superfunctional`(name, npoints, deriv)

`build_b3lyp5d3zero_superfunctional`(name, npoints, deriv)

`build_b3lyp_superfunctional`(name, npoints, deriv)

`build_b3lypchg_superfunctional`(name, npoints, deriv)

`build_b3lypd1_superfunctional`(name, npoints, deriv)

`build_b3lypd2gr_superfunctional`(name, npoints, deriv)

`build_b3lypd2p4_superfunctional`(name, npoints, deriv)

`build_b3lypd3bj_superfunctional`(name, npoints, deriv)

`build_b3lypd3zero_superfunctional`(name, npoints, deriv)

`build_b88_x_functional`(name)

`build_b970_superfunctional`(name, npoints, deriv)

`build_b971_superfunctional`(name, npoints, deriv)

`build_b972_superfunctional`(name, npoints, deriv)

`build_b97_x_functional`(name)

`build_b97d2gr_superfunctional`(name, npoints, deriv)

`build_b97d2p4_superfunctional`(name, npoints, deriv)

`build_b97d3bj_superfunctional`(name, npoints, deriv)

`build_b97d3zero_superfunctional`(name, npoints, deriv)

`build_blyp_superfunctional`(name, npoints, deriv)

`build_blypd1_superfunctional`(name, npoints, deriv)

`build_blypd2gr_superfunctional`(name, npoints, deriv)

`build_blypd2p4_superfunctional`(name, npoints, deriv)

`build_blypd3bj_superfunctional`(name, npoints, deriv)

`build_blypd3zero_superfunctional`(name, npoints, deriv)

`build_bp86_superfunctional`(name, npoints, deriv)

`build_bp86d1_superfunctional`(name, npoints, deriv)

`build_bp86d2gr_superfunctional`(name, npoints, deriv)

`build_bp86d2p4_superfunctional`(name, npoints, deriv)

`build_bp86d3bj_superfunctional`(name, npoints, deriv)

`build_bp86d3zero_superfunctional`(name, npoints, deriv)

`build_dldf_superfunctional`(name, npoints, deriv)

`build_dldfd09_superfunctional`(name, npoints, deriv)

`build_dldfd_superfunctional`(name, npoints, deriv)

`build_dsd_blyp_superfunctional`(name, npoints, deriv)

`build_dsd_pbep86_superfunctional`(name, npoints, deriv)

`build_dsd_pbepbe_superfunctional`(name, npoints, deriv)

`build_ft97_superfunctional`(name, npoints, deriv)

`build_functional`(alias)

`build_hcth120_superfunctional`(name, npoints, deriv)

`build_hcth120d3bj_superfunctional`(name, npoints, deriv)

`build_hcth120d3zero_superfunctional`(name, npoints, deriv)

`build_hcth147_superfunctional`(name, npoints, deriv)

`build_hcth407_superfunctional`(name, npoints, deriv)

`build_hcth_superfunctional`(name, npoints, deriv)

`build_hfd_superfunctional`(name, npoints, deriv)

`build_m05_2x_superfunctional`(name, npoints, deriv)

`build_m05_2xd3zero_superfunctional`(name, npoints, deriv)

`build_m05_superfunctional`(name, npoints, deriv)

`build_m05d3zero_superfunctional`(name, npoints, deriv)

`build_pbe0_2_superfunctional`(name, npoints, deriv)

`build_pbe0_superfunctional`(name, npoints, deriv)

`build_pbe0d2gr_superfunctional`(name, npoints, deriv)

`build_pbe0d2p4_superfunctional`(name, npoints, deriv)

`build_pbe0d3bj_superfunctional`(name, npoints, deriv)

`build_pbe0d3zero_superfunctional`(name, npoints, deriv)

`build_pbe_superfunctional`(name, npoints, deriv)

`build_pbe_x_functional`(name)

`build_pbed1_superfunctional`(name, npoints, deriv)

`build_pbed2gr_superfunctional`(name, npoints, deriv)

`build_pbed2p4_superfunctional`(name, npoints, deriv)

`build_pbed3bj_superfunctional`(name, npoints, deriv)

`build_pbed3zero_superfunctional`(name, npoints, deriv)

`build_pbesol_x_functional`(name)

`build_primitive_functional`(name)

`build_primitive_superfunctional`(name, npoints, deriv)

`build_pw91_superfunctional`(name, npoints, deriv)

`build_pw91_x_functional`(name)

`build_revpbe_x_functional`(name)

`build_rpbe_x_functional`(name)

`build_s_x_functional`(name)

`build_sogga_superfunctional`(name, npoints, deriv)

`build_sogga_x_functional`(name)

`build_superfunctional`(alias, npoints, deriv)

`build_svwn_superfunctional`(name, npoints, deriv)

`build_vwn3_c_functional`(name)

`build_vwn3rpa_c_functional`(name)

`build_vwn5_c_functional`(name)

`build_vwn5rpa_c_functional`(name)

`build_wb88_x_functional`(name)

`build_wb88_x_superfunctional`(name, npoints, deriv)

`build_wb97_superfunctional`(name, npoints, deriv)

`build_wb97x_2lp_superfunctional`(name, npoints, deriv)

`build_wb97x_2tqz_superfunctional`(name, npoints, deriv)

`build_wb97x_superfunctional`(name, npoints, deriv)

`build_wb97xd_superfunctional`(name, npoints, deriv)

`build_wblyp_superfunctional`(name, npoints, deriv)

`build_wpbe0_superfunctional`(name, npoints, deriv)

`build_wpbe_superfunctional`(name, npoints, deriv)

`build_wpbe_x_functional`(name)

`build_wpbe_x_superfunctional`(name, npoints, deriv)

`build_wpbesol0_superfunctional`(name, npoints, deriv)

`build_wpbesol_superfunctional`(name, npoints, deriv)

`build_wpbesol_x_functional`(name)

`build_wpbesol_x_superfunctional`(name, npoints, deriv)

`build_ws_x_functional`(name)

`build_ws_x_superfunctional`(name, npoints, deriv)

`build_wsvwn_superfunctional`(name, npoints, deriv)

`functional_list`()

`superfunctional_list`()

`test_ccl_functional`(functional, ccl_functional)

## pubchem

class `PubChemObj`(cid, mf, iupac)
  `getCartesian`()

    Function to return a string of the atom symbol and XYZ coordinates of the PubChem object.

  `getMoleculeString`()

    Function to obtain a molecule string through getCartesian() or fail.

  `getSDF`()

    Function to return the SDF (structure-data file) of the PubChem object.

  `getXYZFile`()

    Function to obtain preferentially a molecule string through getCartesian() or a query string otherwise.

  `name`()

    Function to return the IUPAC name of the PubChem object.

`getPubChemResults`(name)

  Function to query the PubChem database for molecules matching the input string. Builds a PubChem object if found.

## p4regex

## pcmgetkw

class `Getkw`(top)

  Unified interface to sections and keywords. Implements a path stack.

  `find_sect`(path)
  `get_active_section`()
  `get_keyword`(path)
  `get_topsect`()
  `getkw`(path)
  `pop_sect`()
  `push_sect`(path)
  `run_callbacks`(templ)
  `sanitize`(templ)
  `setkw`(path)

class `GetkwParser`(templ=None)

  Implements a class to do the actual parsing of input files and store the results in Sections and Keywords. The parseFile() method returns a Getkw object.

  `add_sect`(s, l, t)
  `bnf` = None
  `caseless` = False
  `check_type`(arg, argt)
  `conv_dval`(s, loc, toks)
  `conv_ival`(s, loc, toks)
  `conv_lval`(s, loc, toks)
  `fixate_type`(arg)
  `getkw_bnf`()
  `no` = <_sre.SRE_Pattern object at 0xadf54d0>
  `parseFile`(fil)
  `parseString`(str)
  `pop_sect`(s, l, t)
  `push_sect`(k)
  `set_caseless`(arg)
  `store_data`(s, l, t)
  `store_key`(s, l, t)
  `store_vector`(s, l, t)
  `yes` = <_sre.SRE_Pattern object at 0xc1813c0>

class `Keyword`(name, typ, arg=None, req=False, callback=None)

  Placehoder for keyword objects

  `get`()
  `is_required`()
  `is_set`()
  `is_type`(typ)
  `sanity_check`(path)
  `set`(val)
  `set_status`(set)
  `setkw`(arg)
  `typecheck`()
  `xvalidate`(templ, path=None)

class `Section`(name, tag=None, req=False, callback=None)

  Section class

  Placehoder for section objects

  `add_kw`(name, typ, arg=None, req=False, set=False, callback=None)
  `add_kwkw`(kw, set=False)
  `add_sect`(sect, set=False)
  `check_key`(key)
  `equalize`(templ)
  `fetch_kw`(name)
  `fetch_sect`(name)
  `find_sect`(path)
  `get`(k)
  `get_keys`()
  `get_keyword`(path)
  `get_sects`()
  `getkw`(path)
  `is_required`()
  `is_set`(key=None)
  `run_callbacks`(templ)
  `sanitize`(templ)
  `sanity_check`(path=None)
  `set`(k, val)
  `set_status`(set)
  `setkw`(name, arg)
  `status`()
  `xvalidate`(templ, path=None)

`check_ignored`(list, sect)

`check_opt`(sect, key)

`check_required`(list, sect)

`parse_error`(s, t, d, err)

`test`(strng)

## diatomic

## qmmm

Module with classes to integrate MM charges into a QM calculation.

class `Diffuse`(molecule, basisname, ribasisname)
  `fitGeneral`()

    Function to perform a general fit of diffuse charges to wavefunction density.

  `fitScf`()

    Function to run scf and fit a system of diffuse charges to resulting density.

  `populateExtern`(extern)

class `QMMM`
  `addChargeAngstrom`(Q, x, y, z)

    Function to add a point charge of magnitude Q at position (x, y, z) Angstroms.

  `addChargeBohr`(Q, x, y, z)

    Function to add a point charge of magnitude Q at position (x, y, z) Bohr.

  `addDiffuse`(diffuse)

    Function to add a diffuse charge field diffuse.

  `populateExtern`()

    Function to define a charge field external to the molecule through point and diffuse charges.

## driver

`gradient`(name, **kwargs)

  Function complementary to optimize(). Carries out one gradient pass, deciding analytic or finite difference.

`hessian`(name, **kwargs)

  Function complementary to `frequency()`. Computes force constants, deciding analytic, finite difference of gradients, or finite difference of energies.

`molden`(filename)

  Function to write wavefunction information in molden format to filename

`parse_arbitrary_order`(name)

  Function to parse name string into a method family like CI or MRCC and specific level information like 4 for CISDTQ or MRCCSDTQ.

`parse_cotton_irreps`(irrep)

  Function to return validated Cotton ordering index from string or integer irreducible representation irrep.

## qcdb

Module to facilitate quantum chemical computations on chemical databases. Contains Molecule class and physical constants from psi4 suite.

Module with non-generic exceptions classes.

exception `FeatureNotImplemented`(msg)

  Error called for functions defined but not yet implemented. Also for functions defined that will never be implemented.

exception `IncompleteAtomError`(msg)

  Error raised when not all variables in an atom specification have been defined at compute time. May be a temporary situation so message not printed but appears as traceback when error persists.

exception `QcdbException`

  Error class for QCDB.

exception `ValidationError`(msg)

  Error called for problems with syntax input file. Prints error message msg to standard output stream.

File for accessory procedures in the chem module. Credit for the libmints vector3 class to Justin M. Turney and incremental improvements by other psi4 developers.

`add`(v, u)

  Compute sum of vectors v and u.

`cross`(v, u)

  Compute cross product of length 3 vectors v and u.

`determinant`(mat)

  Given 3x3 matrix mat, compute the determinat

`diagonalize3x3symmat`(M)

  Given an real symmetric 3x3 matrix M, compute the eigenvalues

`distance`(v, u)

  Compute the distance between points defined by vectors v and u.

`dot`(v, u)

  Compute dot product of vectors v and u.

`mscale`(matrix, d)

  Return matrix scaled by scalar d

`mult`(matrix1, matrix2)

  Matrix multiplication

`norm`(v)

  Compute the magnitude of vector v.

`normalize`(v)

  Compute normalized vector v.

`perp_unit`(u, v)

  Compute unit vector perpendicular to length 3 vectors u and v.

`rotate`(v, theta, axis)

  Rotate length 3 vector v about axis by theta radians.

`scale`(v, d)

  Compute by-element scale by d of vector v.

`show`(matrix)

  Print out matrix

`sub`(v, u)

  Compute difference of vectors v - u.

`transpose`(matrix)

  Return matrix transpose

`zero`(m, n)

  Create zero matrix

class `LibmintsMolecule`(psi4molstr=None)

  Class to store the elements, coordinates, fragmentation pattern, charge, multiplicity of a molecule. Largely replicates psi4’s libmints Molecule class, developed by Justin M. Turney and Andy M. Simmonett with incremental improvements by other psi4 developers. Major differences from the C++ class are: no basisset handling, no symmetry, no pubchem, no efp, no discarding dummies. This class translated so that databases can function independently of psi4.

      >>> H2OH2O = qcdb.Molecule("""
          0 1
          O1  -1.551007  -0.114520   0.000000
          H1  -1.934259   0.762503   0.000000
          H2  -0.599677   0.040712   0.000000
          --
          0 1
          X    0.000000   0.000000   0.000000
          O2   1.350625   0.111469   0.000000
          H3   1.680398  -0.373741  -0.758561
          H4   1.680398  -0.373741   0.758561
          no_com
          no_reorient
          units angstrom
          """)

      >>> H2O = qcdb.Molecule.init_with_xyz('h2o.xyz')

  `FullPointGroupList` = ['ATOM', 'C_inf_v', 'D_inf_h', 'C1', 'Cs', 'Ci', 'Cn', 'Cnv', 'Cnh', 'Sn', 'Dn', 'Dnd', 'Dnh', 'Td', 'Oh', 'Ih']
  `Z`(atom)

    Nuclear charge of atom (0-indexed)

        >>> print H2OH2O.Z(4)
        1

  `activate_all_fragments`()

    Sets all fragments in the molecule to be active.

  `add_atom`(Z, x, y, z, label='', mass=0.0, charge=0.0, lineno=-1)

    Add an atom to the molecule Z atomic number x cartesian coordinate y cartesian coordinate z cartesian coordinate symb atomic symbol to use mass mass to use if non standard charge charge to use if non standard lineno line number when taken from a string

  `atom_at_position`(b, tol=0.05)

    Tests to see of an atom is at the passed position b in Bohr with a tolerance tol.

        >>> print H2OH2O.atom_at_position([1.35*(1.0/psi_bohr2angstroms), 0.10*(1.0/psi_bohr2angstroms), 0.0*(1.0/psi_bohr2angstroms)])
        3

  `atom_entry`(atom)

    Returns the CoordEntry for an atom.

  `atom_to_unique`(iatom)

    NYI Converts an atom number to the number of its generating unique atom. The return value is in [0, nunique).

  `atom_to_unique_offset`(iatom)

    NYI Converts an atom number to the offset of this atom in the list of generated atoms. The unique atom itself is allowed offset 0.

  `center_of_mass`()

    Computes center of mass of molecule (does not translate molecule).

        >>> H2OH2O.center_of_mass()
        [-0.12442647346606871, 0.00038657002584110707, 0.0]

  `charge`(atom)

    Returns charge of atom (0-indexed). Related to SAD guess in libmints version.

        >>> print H2OH2O.charge(4)
        1.0

  `charge_specified`()

    Whether the charge was given by the user

        >>> print H2OH2O.charge_specified()
        True

  `clear`()

    Zero it out.

  `clone`()

    Returns new, independent Molecule object.

        >>> dimer = H2OH2O.clone()

  `create_molecule_from_string`(text)

    Given a string geom of psi4-style geometry specification (including newlines to separate lines), builds a new molecule. Called from constructor.

  `create_psi4_string_from_molecule`()

    Regenerates a input file molecule specification string from the current state of the Molecule. Contains geometry info, fragmentation, charges and multiplicities, and any frame restriction.

  `deactivate_all_fragments`()

    Sets all fragments in the molecule to be inactive.

  `distance_matrix`()

    Computes a matrix depicting distances between atoms. Prints formatted and returns array.

        >>> H2OH2O.distance_matrix()
                Interatomic Distances (Angstroms)
                          [1]         [2]         [3]         [4]         [5]         [6]
          [1]         0.00000
          [2]         0.95711     0.00000
          [3]         0.96391     1.51726     0.00000
          [4]         2.91042     3.34878     1.95159     0.00000
          [5]         3.32935     3.86422     2.43843     0.95895     0.00000
          [6]         3.32935     3.86422     2.43843     0.95895     1.51712     0.00000

  `equivalent`(iuniq, j)

    NYI Returns the j’th atom equivalent to iuniq.

  `everything`()

    Quick print of class data

  `extract_fragments`(reals, ghosts=[])

    Makes a copy of the molecule, returning a new molecule with only certain fragment atoms present as either ghost or real atoms reals: The list or int of fragments (1-indexed) that should be present in the molecule as real atoms. ghosts: The list or int of fragments (1-indexed) that should be present in the molecule as ghosts. (method name in libmints is extract_subsets. This is different in qcdb because the psi4 input parser tries to process lines with that term, giving rise to Boost:Python type conlicts.) See usage at `extract_fragments()`.

  `extract_subsets`(reals, ghosts=[])

    Wrapper for `extract_fragments()`. See note there. This function can be used as long as not in psi4 input file. Use extract_fragments directly, then.

        >>> H2OH2O.extract_subsets(2)  # monomer B, unCP-corrected
        >>> H2OH2O.extract_subsets(2,1)  # monomer B, CP-corrected
        >>> obj.extract_subsets(1,[2,3])  # monomer A, CP-corrected if obj is tri-molecular complex

  `fZ`(atom)

    Nuclear charge of atom (includes dummies)

        >>> print H2OH2O.fZ(4)
        8

  `fcharge`(atom)

    Returns charge of atom (0-indexed, includes dummies). Related to SAD guess in libmints version.

        >>> print H2OH2O.fcharge(4)
        8.0

  `find_highest_point_group`(tol=1e-08)

    NYI Find highest molecular point group

  `find_point_group`(tol=1e-08)

    NYI Find computational molecular point group, user can override this with the “symmetry” keyword

  `fix_orientation`(_fix=True)

    Fix the orientation at its current frame (method name in libmints is set_orientation_fixed)

  `flabel`(atom)

    Returns the original label of the atom (0-indexed) as given in the input file (C2, H4) (includes dummies)

        >>> print H2OH2O.flabel(4)
        O2

  `fmass`(atom)

    Returns mass of atom (0-indexed, includes dummies)

        >>> print H2OH2O.fmass(4)
        15.9949146196

  `form_symmetry_information`(tol=1e-08)

    NYI Initialize molecular specific symmetry information. Uses the point group object obtain by calling point_group()

  `fsymbol`(atom)

    Returns the cleaned up label of the atom (C2 => C, H4 = H) (includes dummies)

        >>> print H2OH2O.fsymbol(4)
        O

  `full_geometry`()

    Returns the full (dummies included) geometry in Bohr as a N X 3 array.

        >>> print H2OH2O.full_geometry()
        [[-2.930978460188563, -0.21641143673806384, 0.0], [-3.655219780069251, 1.4409218455037016, 0.0], [-1.1332252981904638, 0.0769345303220403, 0.0], [0.0, 0.0, 0.0], [2.5523113582286716, 0.21064588230662976, 0.0], [3.175492014248769, -0.7062681346308132, -1.4334725450878665], [3.175492014248769, -0.7062681346308132, 1.4334725450878665]]

  `full_pg_n`()

    NYI Return n in Cnv, etc.; If there is no n (e.g. Td) it’s the highest-order rotation axis.

  `full_point_group_with_n`()

    NYI Return point group name such as Cnv or Sn.

  `fx`(atom)

    x position of atom (0-indexed, includes dummies) in Bohr

        >>> print H2OH2O.fx(4)
        2.55231135823

  `fxyz`(atom)

    Returns a Vector3 with x, y, z position of atom (0-indexed) in Bohr (includes dummies)

        >>> print H2OH2O.fxyz(4)
        [2.5523113582286716, 0.21064588230662976, 0.0]

  `fy`(atom)

    y position of atom (0-indexed, includes dummies) in Bohr

        >>> print H2OH2O.fy(4)
        0.210645882307

  `fz`(atom)

    z position of atom (0-indexed, includes dummies) in Bohr

        >>> print H2OH2O.fz(4)
        0.0

  `geometry`()

    Returns the geometry in Bohr as a N X 3 array.

        >>> print H2OH2O.geometry()
        [[-2.930978460188563, -0.21641143673806384, 0.0], [-3.655219780069251, 1.4409218455037016, 0.0], [-1.1332252981904638, 0.0769345303220403, 0.0], [2.5523113582286716, 0.21064588230662976, 0.0], [3.175492014248769, -0.7062681346308132, -1.4334725450878665], [3.175492014248769, -0.7062681346308132, 1.4334725450878665]]

  `get_anchor_atom`(vstr, line)

    Attempts to interpret a string vstr as an atom specifier in a zmatrix. Takes the current line for error message printing. Returns the atom number (adjusted to zero-based counting).

  `get_coord_value`(vstr)

    Attempts to interpret a string as a double, if not it assumes it’s a variable.

  `get_full_point_group`()

    NYI Return point group name such as C3v or S8. (method name in libmints is full_point_group)

  `get_variable`(vstr)

    Checks to see if the variable str is in the list, sets it to val and returns true if it is, and returns false if not.

  `has_inversion`(origin, tol=1e-08)

    Does the molecule have an inversion center at origin

  `has_symmetry_element`(op, tol=1e-08)

    NYI Whether molecule satisfies the vector symmetry operation op

  `has_zmatrix`()

    Gets the presence of any zmatrix entry

        >>> print H2OH2O.has_zmatrix()
        False

  `inertia_tensor`()

    Compute inertia tensor.

        >>> print H2OH2O.inertia_tensor()
        [[8.704574864178731, -8.828375721817082, 0.0], [-8.828375721817082, 280.82861714077666, 0.0], [0.0, 0.0, 281.249500988553]]

  `init_with_checkpoint`(chkpt)

    NYI Pull information from the chkpt object passed (method name in libmints is init_with_chkpt)

  `init_with_io`(psio)

    NYI Pull information from a chkpt object created from psio (method name in libmints is init_with_psio)

  classmethod `init_with_xyz`(xyzfilename)

    Pull information from an XYZ file. No fragment or chg/mult info detected.

        >>> H2O = qcdb.Molecule.init_with_xyz('h2o.xyz')

  `irrep_labels`()

    NYI Returns the irrep labels

  `is_axis`(origin, axis, order, tol=1e-08)

    Is axis an axis of order order with respect to origin?

  `is_linear_planar`(tol=1e-08)

    Is the molecule linear, or planar?

        >>> print H2OH2O.is_linear_planar()
        (False, False)

  `is_plane`(origin, uperp, tol=1e-08)

    Is a plane?

  `is_variable`(vstr)

    Checks to see if the variable str is in the list, returns true if it is, and returns false if not.

        >>> H2OH2O.is_variable('R')
        False

  `label`(atom)

    Returns the original label of the atom (0-indexed) as given in the input file (C2, H4).

        >>> print H2OH2O.label(4)
        H3

  static `like_world_axis`(axis, worldxaxis, worldyaxis, worldzaxis)

    Returns which worldaxis axis most overlaps with. Inverts axis when indicated.

  `mass`(atom)

    Returns mass of atom (0-indexed)

        >>> print H2OH2O.mass(4)
        1.00782503207

  `max_nequivalent`()

    NYI Returns the maximum number of equivalent atoms.

  `molecular_charge`()

    Gets the molecular charge

        >>> print H2OH2O.molecular_charge()
        -2

  `move_to_com`()

    Moves molecule to center of mass

  `multiplicity`()

    Get the multiplicity (defined as 2Ms + 1)

        >>> print H2OH2O.multiplicity()

  `multiplicity_specified`()

    Whether the multiplicity was given by the user

        >>> print H2OH2O.multiplicity_specified()
        True

  `nactive_fragments`()

    The number of active fragments in the molecule.

        >>> print H2OH2O.nactive_fragments()
        2

  `nallatom`()

    Number of all atoms (includes dummies)

        >>> print H2OH2O.nallatom()
        7

  `name`()

    Get molecule name

        >>> print H2OH2O.name()
        water_dimer

  `natom`()

    Number of atoms

        >>> print H2OH2O.natom()
        6

  `nequivalent`(iuniq)

    NYI Returns the number of atoms equivalent to iuniq.

  `nfragments`()

    The number of fragments in the molecule.

        >>> print H2OH2O.nfragments()
        2

  `nfrozen_core`(depth=False)

    Number of frozen core for molecule given freezing state.

        >>> print H2OH2O.nfrozen_core()
        2

  `nuclear_repulsion_energy`()

    Computes nuclear repulsion energy.

        >>> print H2OH2O.nuclear_repulsion_energy()
        36.6628478528

  `nuclear_repulsion_energy_deriv1`()

    Computes nuclear repulsion energy derivatives

        >>> print H2OH2O.nuclear_repulsion_energy_deriv1()
        [[3.9020946901323774, 2.76201566471991, 0.0], [1.3172905807089021, -2.3486366050337293, 0.0], [-1.8107598525022435, -0.32511212499256564, 0.0], [-1.217656141385739, -2.6120090867576717, 0.0], [-1.0954846384766488, 1.2618710760320282, 2.1130743287465603], [-1.0954846384766488, 1.2618710760320282, -2.1130743287465603]]

  `nuclear_repulsion_energy_deriv2`()

    NYI Computes nuclear repulsion energy second derivatives

  `nunique`()

    NYI Return the number of unique atoms.

  `orientation_fixed`()

    Get whether or not orientation is fixed.

        >>> H2OH2O.orientation_fixed()
        True

  `point_group`()

    NYI Returns the point group (object) if set

  `print_bond_angles`()

    Print the geometrical parameters (bond_angles) of the molecule.

        >>> print H2OH2O.print_bond_angles()
        Bond Angles (degrees)
        Angle 2-1-3:  104.337
        Angle 2-1-4:  109.152
        Angle 2-1-5:  117.387
        ...

  `print_dihedrals`()

    Print the geometrical parameters (dihedrals) of the molecule.

        >>> print H2OH2O.print_dihedrals()
        Dihedral Angles (Degrees)
        Dihedral 1-2-3-4:  180.000
        Dihedral 1-2-3-5:  133.511
        Dihedral 1-2-3-6:  133.511
        ...

  `print_distances`()

    Print the geometrical parameters (distances) of the molecule. suspect libmints version actually prints Bohr.

        >>> print H2OH2O.print_distances()
        Interatomic Distances (Angstroms)
        Distance 1 to 2 0.957
        Distance 1 to 3 0.964
        Distance 1 to 4 2.910
        ...

  `print_full`()

    Print full atom list. Same as `print_out()` only displays dummy atoms.

  `print_in_input_format`()

    Print the molecule in the same format that the user provided.

  `print_out`()

    Print the molecule. (method name in libmints is print)

        >>> H2OH2O.print_out()
        Geometry (in Angstrom), charge = -2, multiplicity = 3:
           Center              X                  Y                   Z
        ------------   -----------------  -----------------  -----------------
               O         -1.551007000000    -0.114520000000     0.000000000000
               H         -1.934259000000     0.762503000000     0.000000000000
               H         -0.599677000000     0.040712000000     0.000000000000
               O          1.350625000000     0.111469000000     0.000000000000
               H          1.680398000000    -0.373741000000    -0.758561000000
               H          1.680398000000    -0.373741000000     0.758561000000

  `print_out_in_angstrom`()

    Print the molecule in Angstroms. Same as `print_out()` only always in Angstroms. (method name in libmints is print_in_angstrom)

  `print_out_in_bohr`()

    Print the molecule in Bohr. Same as `print_out()` only in Bohr. (method name in libmints is print_in_bohr)

  `print_out_of_planes`()

    Print the geometrical parameters (out_of_planes) of the molecule.

        >>> print H2OH2O.print_out_of_planes()
        Out-Of-Plane Angles (Degrees)
        Out-of-plane 1-2-3-4:    0.000
        Out-of-plane 1-2-3-5:   -7.373
        Out-of-plane 1-2-3-6:    7.373
        ...

  `reinterpret_coordentries`()

    Reinterpret the fragments for reals/ghosts and build the atom list.

  `reinterpret_coordentry`(rc)

    Do we reinterpret coordentries during a call to update_geometry? (method name in libmints is set_reinterpret_coordentry)

  `release_symmetry_information`()

    NYI Release symmetry information

  `reset_point_group`(pgname)

    NYI Override symmetry from outside the molecule string

  `rotate`(R)

    Rotates the molecule using rotation matrix R.

        >>> H2OH2O.rotate([[0,-1,0],[-1,0,0],[0,0,1]])

  `rotate_full`(R)

    Rotates the full molecule using rotation matrix R.

        >>> H2OH2O.rotate_full([[0,-1,0],[-1,0,0],[0,0,1]])

  `rotational_constants`(tol=1e-08)

    Compute the rotational constants and return them in wavenumbers

  `rotor_type`(tol=1e-08)

    Returns the rotor type.

        >>> H2OH2O.rotor_type()
        RT_ASYMMETRIC_TOP

  `save_string_xyz`(save_ghosts=True)

    Save a string for a XYZ-style file.

        >>> H2OH2O.save_string_xyz()
        6
        _
         O   -1.551007000000   -0.114520000000    0.000000000000
         H   -1.934259000000    0.762503000000    0.000000000000
         H   -0.599677000000    0.040712000000    0.000000000000
         O    1.350625000000    0.111469000000    0.000000000000
         H    1.680398000000   -0.373741000000   -0.758561000000
         H    1.680398000000   -0.373741000000    0.758561000000

  `save_to_checkpoint`(chkpt, prefix='')

    NYI Save information to checkpoint file (method name in libmints is save_to_chkpt)

  `save_xyz`(filename, save_ghosts=True)

    Save an XYZ file.

        >>> H2OH2O.save_xyz('h2o.xyz')

  `schoenflies_symbol`()

    NYI Returns the Schoenflies symbol

  `set_active_fragment`(fr)

    Tags fragment index fr as composed of real atoms.

  `set_active_fragments`(reals)

    Tags the fragments in array reals as composed of real atoms.

  `set_basis_all_atoms`(name, type='BASIS')

    NYI Assigns basis name to all atoms.

  `set_basis_by_label`(label, name, type='BASIS')

    NYI Assigns basis name to all atoms with label.

  `set_basis_by_number`(number, name, type='BASIS')

    NYI Assigns basis name to atom number number (1-indexed, includes dummies).

  `set_basis_by_symbol`(symbol, name, type='BASIS')

    NYI Assigns basis name to all symbol atoms.

  `set_com_fixed`(_fix=True)

    NYI Fix the center of mass at its current frame. Not used in libmints so not implemented.

  `set_full_geometry`(geom)

    Sets the full geometry (dummies included), given a N X 3 array of coordinates geom in Bohr.

        >>> H2OH2O.set_full geometry([[1,2,3],[4,5,6],[7,8,9],[0,0,0],[-1,-2,-3],[-4,-5,-6],[-7,-8,-9]])

  `set_full_point_group`(tol=1e-08)

    NYI Determine and set FULL point group

  `set_geometry`(geom)

    Sets the geometry, given a N X 3 array of coordinates geom in Bohr.

        >>> H2OH2O.set_geometry([[1,2,3],[4,5,6],[7,8,9],[-1,-2,-3],[-4,-5,-6],[-7,-8,-9]])

  `set_ghost_fragment`(fr)

    Tags fragment index fr as composed of ghost atoms.

  `set_ghost_fragments`(ghosts)

    Tags the fragments in array ghosts as composed of ghost atoms.

  `set_has_zmatrix`(tf)

    Sets the presence of any zmatrix entry

        >>> H2OH2O.set_has_zmatrix(True)

  `set_molecular_charge`(charge)

    Sets the molecular charge

        >>> H2OH2O.set_molecular_charge(-2)

  `set_multiplicity`(mult)

    Sets the multiplicity (defined as 2Ms + 1)

        >>> H2OH2O.set_multiplicity(3)

  `set_name`(name)

    Set molecule name

        >>> H2OH2O.set_name('water_dimer')

  `set_point_group`(pg)

    NYI Set the point group to object pg

  `set_units`(units)

    Sets the geometry units

        >>> H2OH2O.set_units('Angstom')

  `set_variable`(vstr, val)

    Assigns the value val to the variable labelled string in the list of geometry variables. Also calls update_geometry()

  `sym_label`()

    NYI Returns the symmetry label

  `symbol`(atom)

    Returns the cleaned up label of the atom (C2 => C, H4 = H) (0-indexed)

        >>> print H2OH2O.symbol(4)
        H

  `symmetrize`()

    NYI Force the molecule to have the symmetry specified in pg. This is to handle noise coming in from optking.

  `symmetry_frame`(tol=1e-08)

    Determine symmetry reference frame. If noreorient is not set, this is the rotation matrix applied to the geometry in update_geometry.

        >>> print H2OH2O.symmetry_frame()
        [[1.0, -0.0, 0.0], [0.0, 1.0, 0.0], [0.0, -0.0, 1.0]]

  `symmetry_from_input`()

    Returns the symmetry specified in the input.

        >>> print H2OH2O.symmetry_from_input()
        C1

  `translate`(r)

    Translates molecule by r.

        >>> H2OH2O.translate([1.0, 1.0, 0.0])

  `unique`(iuniq)

    NYI Returns the overall number of the iuniq’th unique atom.

  `units`()

    Gets the geometry units

        >>> print H2OH2O.units()
        Angstrom

  `update_geometry`()

    Updates the geometry, by (re)interpreting the string used to create the molecule, and the current values of the variables. The atoms list is cleared, and then rebuilt by this routine. This function must be called after first instantiation of Molecule.

        >>> H2 = qcdb.Molecule("H\nH 1 0.74\n")
        >>> print H2.natom()
        0
        >>> H2.update_geometry()
        >>> print H2.natom()
        2

  `valid_atom_map`(tol=0.01)

    NYI Check if current geometry fits current point group

  `x`(atom)

    x position of atom (0-indexed) in Bohr

        >>> print H2OH2O.x(4)
        3.17549201425

  `xyz`(atom, posn=None)

    Returns a Vector3 with x, y, z position of atom (0-indexed) in Bohr or coordinate at posn

        >>> print H2OH2O.xyz(4)
        [3.175492014248769, -0.7062681346308132, -1.4334725450878665]

  `y`(atom)

    y position of atom (0-indexed) in Bohr

        >>> print H2OH2O.y(4)
        -0.706268134631

  `z`(atom)

    z position of atom (0-indexed) in Bohr

        >>> print H2OH2O.z(4)
        -1.43347254509

Module to largely replicate in python the psi4 libmints CoordValue and CoordEntry classes, which were developed by Justin M. Turney, with incremental improvements by other psi4 developers.

class `CartesianEntry`(entry_number, Z, charge, mass, symbol, label, x, y, z)

  Class to hold all information about an atom, including its coordinate specification as three Cartesians.

  `clone`()

    Returns new, independent CartesianEntry object

  `compute`()

    Computes the values of the coordinates (in whichever units were inputted), returning them in a Vector

  `everything`()
  `invalidate`()

    Flags the current coordinates as being outdated.

  `print_in_input_format`()

    Prints the updated geometry, in the format provided by the user.

  `set_coordinates`(x, y, z)

    Given the current set of coordinates, updates the values of this atom’s coordinates and any variables that may depend on it.

  `type`()

    The type of CoordEntry specialization.

class `CoordEntry`(entry_number, Z, charge, mass, symbol, label='')

  Class to

  `Z`()

    The nuclear charge of the current atom (0 if ghosted).

  static `a`(a1, a2, a3)

    Computes the angle (in rad.) between three sets of coordinates.

  `charge`()

    The “atomic charge” of the current atom (for SAD purposes).

  static `d`(a1, a2, a3, a4)

    Computes the dihedral (in rad.) between four sets of coordinates.

  `entry_number`()

    The order in which this appears in the full atom list.

  `everything`()
  `is_computed`()

    Whether the current atom’s coordinates are up-to-date.

  `is_equivalent_to`(other)

    Whether this atom has the same mass and ghost status as atom other. Unlike the libmints version, this does not compare basisset assignment.

  `is_ghosted`()

    Whether the current atom is ghosted or not.

  `label`()

    The atom label.

  `mass`()

    The atomic mass of the current atom.

  static `r`(a1, a2)

    Computes the distance between two sets of coordinates

  `set_ghosted`(gh)

    Flag the atom as either ghost or real.

  `symbol`()

    The atomic symbol.

class `CoordValue`(fixed=False, computed=False)

  An abstract class to handle storage of Cartesian coordinate values, which may be defined in terms of other variables through this mechanism, greatly simplifying Z-matrix specification, for example.

  `everything`()
  `fixed`()

    Get whether the coordinate value is fixed or not

  `invalidate`()

    Flag the current value as outdated

  `set_fixed`(fixed)

    Set whether the coordinate value is fixed or not

class `NumberValue`(value, fixed=False)

  Specialization of CoordValue that is simply a number to be stored.

  `clone`()

    Returns new, independent NumberValue object

  `compute`()

    Computes value of coordinate from member data

  `everything`()
  `rset`(val)

    Resets value of coordinate if not fixed

  `type`()

    Gets specialization type of CoordValue

  `variable_to_string`(precision)

    Takes a CoordValue object, and returns a string for printing.

class `VariableValue`(name, geometryVariables, negate=False, fixed=False)

  Specialization of CoordValue, where the current value depends on the list of geometry values stored by the molecule.

  `clone`()

    Returns new, independent VariableValue object

  `compute`()

    Computes value of coordinate from member data

  `everything`()
  `name`()

    Gets the name of the variable

  `negated`()

    Gets whether the coordinate value is actually the negative of the variable value

  `rset`(val)

    Resets value of coordinate if not fixed

  `type`()

    Gets specialization type of CoordValue

  `variable_to_string`(precision)

    Takes a CoordValue object, and returns a string for printing.

class `ZMatrixEntry`(entry_number, Z, charge, mass, symbol, label, rto=None, rval=0, ato=None, aval=0, dto=None, dval=0)

  Class to hold all information about an atom, including its coordinate specification as any position of ZMatrix.

  `clone`()

    Returns new, independent ZMatrixEntry object.

  `compute`()

    Compute the Cartesian coordinates in Bohr of current atom’s entry.

  `everything`()
  `invalidate`()

    Flags the current coordinates as being outdated

  `print_in_input_format`()

    Prints the updated geometry, in the format provided by the user

  `set_coordinates`(x, y, z)

    Given the current set of coordinates, updates the values of this atom’s coordinates, and any variables that may depend on it.

  `type`()

    The type of CoordEntry specialization.

File to

`dictify_database_docstrings`()

`drop_duplicates`(seq)

  Function that given an array or array of arrays seq, returns an array without any duplicate entries. There is no guarantee of which duplicate entry is dropped.

`useful`()

Stuff stolen from psi. Should import or not as necessary or some better way. Apologies to the coders.

`compare_matrices`(expected, computed, digits, label)

  Function to compare two matrices. Prints `util.success()` when elements of matrix computed match elements of matrix expected to number of digits. Performs a system exit on failure to match symmetry structure, dimensions, or element values. Used in input files in the test suite.

`compare_values`(expected, computed, digits, label)

  Function to compare two values. Prints `util.success()` when value computed matches value expected to number of digits. Performs a system exit on failure. Used in input files in the test suite.

`query_yes_no`(question, default=True)

  Ask a yes/no question via raw_input() and return their answer.

  question is a string that is presented to the user. default is the presumed answer if the user just hits <Enter>. It must be yes (the default), no or None (meaning an answer is required of the user).

  The return value is one of True or False.

class `Molecule`(psi4molstr=None)

  Class to store python extensions to the MoleculeLibmints class. Multiple classes allows separation of libmints and extension methods.

  `BFS`()

    Perform a breadth-first search (BFS) on the real atoms in molecule, returning an array of atom indices of fragments. Relies upon van der Waals radii and so faulty for close (esp. hydrogen-bonded) fragments. Original code from Michael S. Marshall.

  `auto_fragments`()

    Detects fragments in an unfragmented molecule using BFS algorithm. Returns a new Molecule in Cartesian, fixed-geom (no variable values), no dummy-atom format. Any non-default charge and multiplicity assigned to first fragment.

  `format_molecule_for_molpro`()
  `format_molecule_for_nwchem`()
  `format_molecule_for_psi4`()

    Returns string of molecule definition block.

  `format_molecule_for_qchem`()
  `grimme_dftd3`(func=None, dashlvl=None, dashparam=None, verbosity=1)

    Function to call Grimme’s dftd3 program (http://toc.uni-muenster.de/DFTD3/) to compute the -D correction of level dashlvl using parameters for the functional func. The dictionary dashparam can be used to supply a full set of dispersion parameters in the absense of func or to supply individual overrides in the presence of func. The dftd3 executable must be independently compiled and found in :envvar:PATH.

  `inertia_tensor`(masswt=True)

    Compute inertia tensor.

        >>> print H2OH2O.inertia_tensor()
        [[8.704574864178731, -8.828375721817082, 0.0], [-8.828375721817082, 280.82861714077666, 0.0], [0.0, 0.0, 281.249500988553]]

  `inertia_tensor_partial`(part, masswt=True)

    Compute inertia tensor based on atoms in part.

  `inertial_system`(masswt=True)

    Solve inertial system

  `inertial_system_partial`(part, masswt=True)

    Solve inertial system based on atoms in part

  classmethod `init_with_xyz`(xyzfilename, no_com=False, no_reorient=False)

    Pull information from an XYZ file. No fragment info detected. Charge, multiplicity, tagline pulled from second line if available.

        >>> H2O = qcdb.Molecule.init_with_xyz('h2o.xyz')

  `print_ring_planes`(entity1, entity2, entity3=None, entity4=None)

    (reals only, 1-indexed)

  `save_string_xyz`(save_ghosts=True)

    Save a string for a XYZ-style file.

        >>> H2OH2O.save_string_xyz()
        6
        -2 3 water_dimer
         O   -1.551007000000   -0.114520000000    0.000000000000
         H   -1.934259000000    0.762503000000    0.000000000000
         H   -0.599677000000    0.040712000000    0.000000000000
         O    1.350625000000    0.111469000000    0.000000000000
         H    1.680398000000   -0.373741000000   -0.758561000000
         H    1.680398000000   -0.373741000000    0.758561000000

Module to facilitate quantum chemical computations on chemical databases. Contains Molecule class and physical constants from psi4 suite.

Elemental masses (most common isotope), symbols, and atomic numbers from psi4.

## p4util

Module with utility functions for use in input files.

`compare_integers`(expected, computed, label)

  Function to compare two integers. Prints `util.success()` when value computed matches value expected. Performs a system exit on failure. Used in input files in the test suite.

`compare_matrices`(expected, computed, digits, label)

  Function to compare two matrices. Prints `util.success()` when elements of matrix computed match elements of matrix expected to number of digits. Performs a system exit on failure to match symmetry structure, dimensions, or element values. Used in input files in the test suite.

`compare_strings`(expected, computed, label)

  Function to compare two strings. Prints `util.success()` when string computed exactly matches string expected. Performs a system exit on failure. Used in input files in the test suite.

`compare_values`(expected, computed, digits, label)

  Function to compare two values. Prints `util.success()` when value computed matches value expected to number of digits. Performs a system exit on failure. Used in input files in the test suite.

`compare_vectors`(expected, computed, digits, label)

  Function to compare two vectors. Prints `util.success()` when elements of vector computed match elements of vector expected to number of digits. Performs a system exit on failure to match symmetry structure, dimension, or element values. Used in input files in the test suite.

`copy_file_from_scratch`(filename, prefix, namespace, unit, move=False)

  Function to move file out of scratch with correct naming convention.

  Arguments:

  @arg filename full path to target file @arg prefix computation prefix, usually ‘psi’ @arg namespace context namespace, usually molecule name @arg unit unit number, e.g. 32 @arg move copy or move? (default copy)

  Example:

  Assume PID is 12345 and SCRATCH is /scratch/parrish/

  copy_file_to_scratch(‘temp’, ‘psi’, ‘h2o’, 32):
    -cp /scratch/parrish/psi.12345.h2o.32 .temp
  copy_file_to_scratch(‘/tmp/temp’, ‘psi’, ‘h2o’, 32):
    -cp /scratch/parrish/psi.12345.h2o.32 /tmp/temp
  copy_file_to_scratch(‘/tmp/temp’, ‘psi’, ‘’, 32):
    -cp /scratch/parrish/psi.12345.32 /tmp/temp
  copy_file_to_scratch(‘/tmp/temp’, ‘psi’, ‘’, 32, True):
    -mv /scratch/parrish/psi.12345.32 /tmp/temp

`copy_file_to_scratch`(filename, prefix, namespace, unit, move=False)

  Function to move file into scratch with correct naming convention.

  Arguments:

  @arg filename full path to file @arg prefix computation prefix, usually ‘psi’ @arg namespace context namespace, usually molecule name @arg unit unit number, e.g. 32 @arg move copy or move? (default copy)

  Example:

  Assume PID is 12345 and SCRATCH is /scratch/parrish/

  copy_file_to_scratch(‘temp’, ‘psi’, ‘h2o’, 32):
    -cp ./temp /scratch/parrish/psi.12345.h2o.32
  copy_file_to_scratch(‘/tmp/temp’, ‘psi’, ‘h2o’, 32):
    -cp /tmp/temp /scratch/parrish/psi.12345.h2o.32
  copy_file_to_scratch(‘/tmp/temp’, ‘psi’, ‘’, 32):
    -cp /tmp/temp /scratch/parrish/psi.12345.32
  copy_file_to_scratch(‘/tmp/temp’, ‘psi’, ‘’, 32, True):
    -mv /tmp/temp /scratch/parrish/psi.12345.32

`get_memory`()

  Function to return the total memory allocation.

`get_num_threads`()

  Function to return the number of threads to parallelize across.

`oeprop`(*args, **kwargs)

`set_memory`(bytes)

  Function to reset the total memory allocation.

`set_num_threads`(nthread)

  Function to reset the number of threads to parallelize across.

`success`(label)

  Function to print a ‘label...PASSED’ line to screen. Used by `util.compare_values()` family when functions pass.

Module to provide mechanism to store and restore option states in driver.

class `OptionState`(option, module=None)

  Class to store the state of a single option. If module given, the option value and has_changed value is stored for global, local to module, and used by module scopes; otherwise (used for BASIS keywords), only global scope is stored. Class can store, print, and restore option values.

      >>> OptionState('SCF_TYPE', 'SCF')

      >>> print(OptionState('DF_BASIS_MP2'))

  `restore`()

class `OptionsState`(*largs)

  Class to contain multiple `OptionsState()` objects. Used in python driver functions to collect several options before altering them, then restoring before function return.

      >>> optstash = OptionsState(
              ['SCF', 'DFT_FUNCTIONAL'],
              ['DF_BASIS_SCF'],
              ['SCF', 'SCF_TYPE'],
              ['SCF', 'REFERENCE'])

      >>> print(optstash)

      >>> optstash.restore()

  `restore`()

Module (auto-generated from make_dunning.pl script) with commands building `BasisFamily` objects that encode the Dunning basis set orbital definitions in psi4/lib/basis/NOTES and fitting bases designed for those orbital bases.

`load_basfam_dunning`()

Module with utility functions used by several Python functions.

`all_casings`(input_string)

  Function to return a generator of all lettercase permutations of input_string.

`drop_duplicates`(seq)

  Function that given an array seq, returns an array without any duplicate entries. There is no guarantee of which duplicate entry is dropped.

`extract_sowreap_from_output`(sowout, quantity, sownum, linkage, allvital=False)

  Function to examine file sowout from a sow/reap distributed job for formatted line with electronic energy information about index sownum to be used for construction of quantity computations as directed by master input file with linkage kwarg. When file sowout is missing or incomplete files, function will either return zero (allvital is `False`) or terminate (allvital is `True`) since some sow/reap procedures can produce meaningful results (database) from an incomplete set of sown files, while others cannot (gradient, hessian).

`format_kwargs_for_input`(filename, lmode=1, **kwargs)

  Function to pickle to file filename the options dictionary kwargs. Mode lmode =2 pickles appropriate settings for reap mode. Used to capture Python options information for distributed (sow/reap) input files.

`format_molecule_for_input`(mol)

  Function to return a string of the output of `inputparser.process_input()` applied to the XYZ format of molecule, passed as either fragmented geometry string mol or molecule instance mol. Used to capture molecule information from database modules and for distributed (sow/reap) input files. For the reverse, see `molutil.geometry()`.

`format_options_for_input`()

  Function to return a string of commands to replicate the current state of user-modified options. Used to capture C++ options information for distributed (sow/reap) input files.

  Caution

  Some features are not yet implemented. Buy a developer a coffee.

  - Does not cover local (as opposed to global) options.
  - Does not work with array-type options.

`get_psifile`(fileno, pidspace='23383')

  Function to return the full path and filename for psi file fileno (e.g., psi.32) in current namespace pidspace.

`getattr_ignorecase`(module, attr)

  Function to extract attribute attr from module if attr is available in any possible lettercase permutation. Returns attribute if available, None if not.

`import_ignorecase`(module)

  Function to import module in any possible lettercase permutation. Returns module object if available, None if not.

`kwargs_lower`(kwargs)

  Function to rebuild and return kwargs dictionary with all keys made lowercase. Should be called by every function that could be called directly by the user.

Module to define a class `BasisFamily` that associates fitting basis sets to an orbital basis and to provide functions to query appropriate fitting bases for any orbital basis distributed with Psi4.

class `BasisFamily`(ornate, orbital=None, jk=None, ri=None, dual=None)

  Class to associate with an orbital basis name ornate the gbs file names in which the orbital basis orbital (usually the coded form of ornate) and jkfit, rifit, and dualfit auxiliary bases can be found.

  `add_dualfit`(fit)

    Function to add basis fit as associated helper basis member dualfit to a BasisFamily object.

  `add_jkfit`(fit)

    Function to add basis fit as associated fitting basis member jkfit to a BasisFamily object.

  `add_rifit`(fit)

    Function to add basis fit as associated fitting basis member rifit to a BasisFamily object.

  `name`()

    Function to return the ornate name of the orbital basis, e.g., 6-311++G** for 6-311ppgss.

`corresponding_dualfit`(name)

  Function to return an appropriate DUAL helper basis for the orbital basis name in coded or ornate form. `None` is returned if no fitting basis is defined or if the orbital basis is not found.

`corresponding_jkfit`(name)

  Function to return an appropriate JK fitting basis for the orbital basis name in coded or ornate form. `None` is returned if no fitting basis is defined or if the orbital basis is not found.

`corresponding_orbital`(name)

  Function to validate if the orbital basis name in coded or ornate form is in Psi4’s standard installed bases list. `None` is returned if the orbital basis is not found.

`corresponding_rifit`(name)

  Function to return an appropriate RI fitting basis for the orbital basis name in coded or ornate form. `None` is returned if no fitting basis is defined or if the orbital basis is not found.

`load_basis_families`()

  Function to load into the array `basisfamily_list` BasisFamily objects for all Psi4’s standard installed bases.

`print_basis_families`()

  Function to print to the output file a formatted summary of all the BasisFamily objects in `basisfamily_list`, by default all Psi4’s standard installed bases.

`sanitize_basisname`(name)

  Function to return name in coded form, stripped of characters that confuse filenames, characters into lowercase, `+` into `p`, `*` into `s`, and `(`, `)`, & `,` into `_`.

class `Table`(rows=(), row_label_width=10, row_label_precision=4, cols=(), width=16, precision=10)

  Class defining a flexible Table object for storing data.

  `absolute_to_relative`(Factor=627.5095)

    Function to shift the data of each column of the Table object such that the lowest value is zero. A scaling factor of Factor is applied.

  `copy`()

    Function to return a copy of the Table object.

  `format_label`()

    Function to pad the width of Table object labels.

  `format_values`(values)

    Function to pad the width of Table object data cells.

  `save`(file)

    Function to save string of the Table object to file.

  `scale`(Factor=627.5095)

    Function to apply a scaling factor Factor to the data of the Table object.

`banner`(text, type=1, width=35)

  Function to print text to output file in a banner of minimum width width and minimum three-line height for type = 1 or one-line height for type = 2.

`print_stderr`(stuff)

  Function to print stuff to standard error stream.

`print_stdout`(stuff)

  Function to print stuff to standard output stream.

Module with commands building `BasisFamily` objects for Pople and other non-Dunning orbital basis sets. Some plausible fitting basis sets are supplied as defaults.

`load_basfam_other`()

## grendel

`SystemInfo`

  alias of `CaseInsensativeOpenStruct`

class `r`

  A ‘raw’ list, by syntactic analogy to the Python raw string literal.

      >>> r[1,2,3]
      [1, 2, 3]
      >>> r[1, ..., 3]
      [1, Ellipsis, 3]
      >>> r[...]
      [Ellipsis]
      >>> r[...,...]
      [Ellipsis, Ellipsis]
      >>> r[...,...,1:3]
      [Ellipsis, Ellipsis, slice(1, 3, None)]
      >>> r[...,...,1:3:5]
      [Ellipsis, Ellipsis, slice(1, 3, 5)]
      >>> r[...,...,1:3:5,'hello']
      [Ellipsis, Ellipsis, slice(1, 3, 5), 'hello']
      >>> r['hello']
      ['hello']

`full_path`(path)

`caller`()

  Get the name of the calling function as a str

  Returns: |

  out : str
    The name of the function that called the function whose context caller() is called from. (Hopefully the examples makes this clearer.)

  Examples: |

      >>> def foo():
      ...     print caller()
      ...
      >>> def bar():
      ...     foo()
      ...
      >>> bar()
      bar
      >>> def foobar():
      ...     bar()
      ...
      >>> foobar()
      bar

`listify_args`(*args, **kwargs)

  A simple way to accept arguments that can be an Iterable or a bunch of arguments that should be treated as a single Iterable. (This method is pretty trivial, but I find myself doing it a whole lot.) The reason you can’t just use list() for this purpose is that if an Iterable is given as the only argument, list(args) will return a list of Iterables rather than a single Iterable.

  Examples: |

      >>> def test(*args):
      ...     return listify_args(*args)
      ...
      >>> test(1,2,3)
      [1, 2, 3]
      >>> test([1,2,3])
      [1, 2, 3]
      >>> test([1,2,3], 4)
      [[1, 2, 3], 4]
      >>> test("1,2,3", 4)
      ['1,2,3', 4]
      >>> test("1,2,3")
      ['1,2,3']

`get_multikwarg`(kwarg_dict, *args)

  Utility function for getting the value of a keyword argument that can be named multiple things. This function also checks to make sure no more than one of the possible names is specified in the keyword dictionary kwarg_dict. If the None of the keywords given are found in kwarg_dict, None is returned.

`get_kwarg`(kwarg_dict, *args)

  Utility function for getting the value of a keyword argument that can be named multiple things. This function also checks to make sure no more than one of the possible names is specified in the keyword dictionary kwarg_dict. If the None of the keywords given are found in kwarg_dict, None is returned.

`pop_multikwarg`(kwarg_dict, *args)

  Utility function for getting the value of a keyword argument that can be named multiple things and popping that value off of the kwarg dictionary. If the None of the keywords given are found in kwarg_dict, None is

  > returned.

  > See Also: |

  > get_multikwarg

`pop_kwarg`(kwarg_dict, *args)

  Utility function for getting the value of a keyword argument that can be named multiple things and popping that value off of the kwarg dictionary. If the None of the keywords given are found in kwarg_dict, None is

  > returned.

  > See Also: |

  > get_multikwarg

`andjoin`(iterable, fxn=<type 'str'>, oxford_comma=True)

`camel_to_lower`(instr, divider='_')

  Converts a CamalCase string to a lower_case_string_with_underscores If the divider argument is given, it is used instead of underscores to join words.

  Examples: |

`classname`(class_or_str_or_obj)

  Convenience method for getting the typename as a string from the <type ‘Something’> string sent back by str(type(obj))

`function_alias`(alias, function)

  Alias a function as something else. Set the documentation of the new method to “Alias for <function>()” and add “Aliased as <alias>()” to the documentation of function. Not inteded to be used as a decorator.

  Examples: |

      >>> def foo(a, b, c):
      ...     '''Print a test message.'''
      ...     print "testing {0}, {1}, {2}".format(a, b, c)
      ...
      >>> foo(1, 2, 3)
      testing 1, 2, 3
      >>> bar = function_alias('bar', foo)
      >>> bar(4, 5, 6)
      testing 4, 5, 6
      >>> print bar.__doc__
      Alias for `foo()`
      >>> print foo.__doc__
      Print a test message.

      Aliased as `bar()`
      >>> baz = function_alias('baz', foo)
      >>> baz(7, 8, 9)
      testing 7, 8, 9
      >>> print foo.__doc__
      Print a test message.

      Aliased as `baz()`, `bar()`

  Inside a class

      >>> class FooBar(object):
      ...     def testfunc(self, *args):
      ...         '''Print out the args.'''
      ...         print "testing " + ', '.join(str(a) for a in args)
      ...     another_name = function_alias('another_name', testfunc)
      ...     test_func = function_alias('test_func', testfunc)
      ...
      >>> f = FooBar()
      >>> f.test_func(1, 2, 3, 4)
      testing 1, 2, 3, 4
      >>> print FooBar.test_func.__doc__
      Alias for `testfunc()`
      >>> print FooBar.testfunc.__doc__
      Print out the args.

      Aliased as `test_func()`, `another_name()`

`indent`(*fargs, **fkeywords)

  Alias for indented()

`indented`(instr, nspaces=4)

  Aliased as indent()

`make_safe_identifier`(instr, replace_with='_')

`orjoin`(iterable, fxn=<type 'str'>, oxford_comma=True)

`raises_error`(callable_obj, *args, **kwargs)

  Returns True if a call of callable with args raises an error, and False if not. Note that the callable will get called, so don’t do anything that takes a long time or changes things in a way you don’t want them to be changed. If the optional keyword argument ‘error’ is given as either an Exception subclass or an Iterable, raises_error returns True if the call of callable raises the error given or one of the errors given in the list. (The keyword argument can also be named ‘errors’). Any other keyword arguments are passed through to callable.

  Technical note: As per the Python manual, only exceptions that subclass from Exception (and not BaseException directly) will be recognized. According to the python users manual, you should never implement a user exception that subclasses from BaseException directly.

  Examples: |

      >>> raises_error(int, "5")
      False
      >>> raises_error(int, "0x5ab7", 0)
      False
      >>> raises_error(lambda x: int(x), "5")
      False
      >>> raises_error(int, "abc")
      True
      >>> raises_error(int, "abc", error = ValueError)
      True
      >>> raises_error(int, "abc", error = BufferError)
      False
      >>> raises_error(int, "abc", error = (BufferError, EnvironmentError))
      False
      >>> raises_error(int, "abc", error = [BufferError, ValueError])
      True
      >>> raises_error(float, "abc")
      True
      >>> # Use raises_error to see what errors raises_error raises
      ... # Raise a type error if the first argument is not a callable (i.e. 17(25) doesn't make sense to Python)
      ... raises_error(raises_error, 17, 25, error = TypeError)
      True
      >>> # Raise a TypeError if the error keyword argument is not a subclass of Exception
      ... raises_error(lambda x: raises_error(int, x, error = "hello world"), 25, error = TypeError)
      True
      >>> raises_error(lambda x: raises_error(int, x, error = BaseException), 25, error = TypeError)
      True

`short_str`(obj)

  Aliased as shortstr()

`shortstr`(*fargs, **fkeywords)

  Alias for short_str()

`subscript`(num_or_str)

  Returns the unicode string subscript equivalent of num as a unicode string

`superscript`(num_or_str)

  Returns the unicode string superscript equivalent of num as a unicode string

class `Unit`(name, bases, dct)

  Metaclass for a general unit of something.

  `genre` None
  `genre_check`(other)
  `known_units` = ['Angstrom', 'Angstroms', YottaAngstrom, ZettaAngstrom, ExaAngstrom, PetaAngstrom, TeraAngstrom, GigaAngstrom, MegaAngstrom, KiloAngstrom, HectoAngstrom, DecaAngstrom, DeciAngstrom, CentiAngstrom, MilliAngstrom, MicroAngstrom, NanoAngstrom, PicoAngstrom, FemtoAngstrom, AttoAngstrom, ZeptoAngstrom, YoctoAngstrom, 'Bohr', 'Bohrs', YottaBohr, ZettaBohr, ExaBohr, PetaBohr, TeraBohr, GigaBohr, MegaBohr, KiloBohr, HectoBohr, DecaBohr, DeciBohr, CentiBohr, MilliBohr, MicroBohr, NanoBohr, PicoBohr, FemtoBohr, AttoBohr, ZeptoBohr, YoctoBohr, 'YottaAtomicUnitOfDistance', YottaAtomicUnitOfDistance, 'ZettaAtomicUnitOfDistance', ZettaAtomicUnitOfDistance, 'ExaAtomicUnitOfDistance', ExaAtomicUnitOfDistance, 'PetaAtomicUnitOfDistance', PetaAtomicUnitOfDistance, 'TeraAtomicUnitOfDistance', TeraAtomicUnitOfDistance, 'GigaAtomicUnitOfDistance', GigaAtomicUnitOfDistance, 'MegaAtomicUnitOfDistance', MegaAtomicUnitOfDistance, 'KiloAtomicUnitOfDistance', KiloAtomicUnitOfDistance, 'HectoAtomicUnitOfDistance', HectoAtomicUnitOfDistance, 'DecaAtomicUnitOfDistance', DecaAtomicUnitOfDistance, 'DeciAtomicUnitOfDistance', DeciAtomicUnitOfDistance, 'CentiAtomicUnitOfDistance', CentiAtomicUnitOfDistance, 'MilliAtomicUnitOfDistance', MilliAtomicUnitOfDistance, 'MicroAtomicUnitOfDistance', MicroAtomicUnitOfDistance, 'NanoAtomicUnitOfDistance', NanoAtomicUnitOfDistance, 'PicoAtomicUnitOfDistance', PicoAtomicUnitOfDistance, 'FemtoAtomicUnitOfDistance', FemtoAtomicUnitOfDistance, 'AttoAtomicUnitOfDistance', AttoAtomicUnitOfDistance, 'ZeptoAtomicUnitOfDistance', ZeptoAtomicUnitOfDistance, 'YoctoAtomicUnitOfDistance', YoctoAtomicUnitOfDistance, 'Meter', 'Meters', YottaMeter, ZettaMeter, ExaMeter, PetaMeter, TeraMeter, GigaMeter, MegaMeter, KiloMeter, HectoMeter, DecaMeter, DeciMeter, CentiMeter, MilliMeter, MicroMeter, NanoMeter, PicoMeter, FemtoMeter, AttoMeter, ZeptoMeter, YoctoMeter, 'Degree', 'Degrees', YottaDegree, ZettaDegree, ExaDegree, PetaDegree, TeraDegree, GigaDegree, MegaDegree, KiloDegree, HectoDegree, DecaDegree, DeciDegree, CentiDegree, MilliDegree, MicroDegree, NanoDegree, PicoDegree, FemtoDegree, AttoDegree, ZeptoDegree, YoctoDegree, 'Radian', 'Radians', YottaRadian, ZettaRadian, ExaRadian, PetaRadian, TeraRadian, GigaRadian, MegaRadian, KiloRadian, HectoRadian, DecaRadian, DeciRadian, CentiRadian, MilliRadian, MicroRadian, NanoRadian, PicoRadian, FemtoRadian, AttoRadian, ZeptoRadian, YoctoRadian, 'Joule', 'Joules', YottaJoule, ZettaJoule, ExaJoule, PetaJoule, TeraJoule, GigaJoule, MegaJoule, KiloJoule, HectoJoule, DecaJoule, DeciJoule, CentiJoule, MilliJoule, MicroJoule, NanoJoule, PicoJoule, FemtoJoule, AttoJoule, ZeptoJoule, YoctoJoule, 'Wavenumber', 'Wavenumbers', YottaWavenumber, ZettaWavenumber, ExaWavenumber, PetaWavenumber, TeraWavenumber, GigaWavenumber, MegaWavenumber, KiloWavenumber, HectoWavenumber, DecaWavenumber, DeciWavenumber, CentiWavenumber, MilliWavenumber, MicroWavenumber, NanoWavenumber, PicoWavenumber, FemtoWavenumber, AttoWavenumber, ZeptoWavenumber, YoctoWavenumber, 'Hertz', 'Hertzs', YottaHertz, ZettaHertz, ExaHertz, PetaHertz, TeraHertz, GigaHertz, MegaHertz, KiloHertz, HectoHertz, DecaHertz, DeciHertz, CentiHertz, MilliHertz, MicroHertz, NanoHertz, PicoHertz, FemtoHertz, AttoHertz, ZeptoHertz, YoctoHertz, 'Hartree', 'Hartrees', YottaHartree, ZettaHartree, ExaHartree, PetaHartree, TeraHartree, GigaHartree, MegaHartree, KiloHartree, HectoHartree, DecaHartree, DeciHartree, CentiHartree, MilliHartree, MicroHartree, NanoHartree, PicoHartree, FemtoHartree, AttoHartree, ZeptoHartree, YoctoHartree, 'YottaAtomicUnitOfEnergy', YottaAtomicUnitOfEnergy, 'ZettaAtomicUnitOfEnergy', ZettaAtomicUnitOfEnergy, 'ExaAtomicUnitOfEnergy', ExaAtomicUnitOfEnergy, 'PetaAtomicUnitOfEnergy', PetaAtomicUnitOfEnergy, 'TeraAtomicUnitOfEnergy', TeraAtomicUnitOfEnergy, 'GigaAtomicUnitOfEnergy', GigaAtomicUnitOfEnergy, 'MegaAtomicUnitOfEnergy', MegaAtomicUnitOfEnergy, 'KiloAtomicUnitOfEnergy', KiloAtomicUnitOfEnergy, 'HectoAtomicUnitOfEnergy', HectoAtomicUnitOfEnergy, 'DecaAtomicUnitOfEnergy', DecaAtomicUnitOfEnergy, 'DeciAtomicUnitOfEnergy', DeciAtomicUnitOfEnergy, 'CentiAtomicUnitOfEnergy', CentiAtomicUnitOfEnergy, 'MilliAtomicUnitOfEnergy', MilliAtomicUnitOfEnergy, 'MicroAtomicUnitOfEnergy', MicroAtomicUnitOfEnergy, 'NanoAtomicUnitOfEnergy', NanoAtomicUnitOfEnergy, 'PicoAtomicUnitOfEnergy', PicoAtomicUnitOfEnergy, 'FemtoAtomicUnitOfEnergy', FemtoAtomicUnitOfEnergy, 'AttoAtomicUnitOfEnergy', AttoAtomicUnitOfEnergy, 'ZeptoAtomicUnitOfEnergy', ZeptoAtomicUnitOfEnergy, 'YoctoAtomicUnitOfEnergy', YoctoAtomicUnitOfEnergy, 'KiloCaloriePerMol', 'KiloCaloriePerMols', 'KiloJoulePerMol', 'KiloJoulesPerMol', YottaKiloJoulePerMol, ZettaKiloJoulePerMol, ExaKiloJoulePerMol, PetaKiloJoulePerMol, TeraKiloJoulePerMol, GigaKiloJoulePerMol, MegaKiloJoulePerMol, KiloKiloJoulePerMol, HectoKiloJoulePerMol, DecaKiloJoulePerMol, DeciKiloJoulePerMol, CentiKiloJoulePerMol, MilliKiloJoulePerMol, MicroKiloJoulePerMol, NanoKiloJoulePerMol, PicoKiloJoulePerMol, FemtoKiloJoulePerMol, AttoKiloJoulePerMol, ZeptoKiloJoulePerMol, YoctoKiloJoulePerMol, 'Second', 'Seconds', YottaSecond, ZettaSecond, ExaSecond, PetaSecond, TeraSecond, GigaSecond, MegaSecond, KiloSecond, HectoSecond, DecaSecond, DeciSecond, CentiSecond, MilliSecond, MicroSecond, NanoSecond, PicoSecond, FemtoSecond, AttoSecond, ZeptoSecond, YoctoSecond, 'AtomicUnitOfTime', 'AtomicUnitsOfTime', YottaAtomicUnitOfTime, ZettaAtomicUnitOfTime, ExaAtomicUnitOfTime, PetaAtomicUnitOfTime, TeraAtomicUnitOfTime, GigaAtomicUnitOfTime, MegaAtomicUnitOfTime, KiloAtomicUnitOfTime, HectoAtomicUnitOfTime, DecaAtomicUnitOfTime, DeciAtomicUnitOfTime, CentiAtomicUnitOfTime, MilliAtomicUnitOfTime, MicroAtomicUnitOfTime, NanoAtomicUnitOfTime, PicoAtomicUnitOfTime, FemtoAtomicUnitOfTime, AttoAtomicUnitOfTime, ZeptoAtomicUnitOfTime, YoctoAtomicUnitOfTime, 'Minute', 'Minutes', YottaMinute, ZettaMinute, ExaMinute, PetaMinute, TeraMinute, GigaMinute, MegaMinute, KiloMinute, HectoMinute, DecaMinute, DeciMinute, CentiMinute, MilliMinute, MicroMinute, NanoMinute, PicoMinute, FemtoMinute, AttoMinute, ZeptoMinute, YoctoMinute, 'Hour', 'Hours', YottaHour, ZettaHour, ExaHour, PetaHour, TeraHour, GigaHour, MegaHour, KiloHour, HectoHour, DecaHour, DeciHour, CentiHour, MilliHour, MicroHour, NanoHour, PicoHour, FemtoHour, AttoHour, ZeptoHour, YoctoHour, 'Day', 'Days', YottaDay, ZettaDay, ExaDay, PetaDay, TeraDay, GigaDay, MegaDay, KiloDay, HectoDay, DecaDay, DeciDay, CentiDay, MilliDay, MicroDay, NanoDay, PicoDay, FemtoDay, AttoDay, ZeptoDay, YoctoDay, 'Week', 'Weeks', YottaWeek, ZettaWeek, ExaWeek, PetaWeek, TeraWeek, GigaWeek, MegaWeek, KiloWeek, HectoWeek, DecaWeek, DeciWeek, CentiWeek, MilliWeek, MicroWeek, NanoWeek, PicoWeek, FemtoWeek, AttoWeek, ZeptoWeek, YoctoWeek, 'Year', 'Years', YottaYear, ZettaYear, ExaYear, PetaYear, TeraYear, GigaYear, MegaYear, KiloYear, HectoYear, DecaYear, DeciYear, CentiYear, MilliYear, MicroYear, NanoYear, PicoYear, FemtoYear, AttoYear, ZeptoYear, YoctoYear, 'Decade', 'Decades', YottaDecade, ZettaDecade, ExaDecade, PetaDecade, TeraDecade, GigaDecade, MegaDecade, KiloDecade, HectoDecade, DecaDecade, DeciDecade, CentiDecade, MilliDecade, MicroDecade, NanoDecade, PicoDecade, FemtoDecade, AttoDecade, ZeptoDecade, YoctoDecade, 'Century', 'Centuries', YottaCentury, ZettaCentury, ExaCentury, PetaCentury, TeraCentury, GigaCentury, MegaCentury, KiloCentury, HectoCentury, DecaCentury, DeciCentury, CentiCentury, MilliCentury, MicroCentury, NanoCentury, PicoCentury, FemtoCentury, AttoCentury, ZeptoCentury, YoctoCentury, 'Millennium', 'Millennia', YottaMillennium, ZettaMillennium, ExaMillennium, PetaMillennium, TeraMillennium, GigaMillennium, MegaMillennium, KiloMillennium, HectoMillennium, DecaMillennium, DeciMillennium, CentiMillennium, MilliMillennium, MicroMillennium, NanoMillennium, PicoMillennium, FemtoMillennium, AttoMillennium, ZeptoMillennium, YoctoMillennium, 'Coulomb', 'Coulombs', YottaCoulomb, ZettaCoulomb, ExaCoulomb, PetaCoulomb, TeraCoulomb, GigaCoulomb, MegaCoulomb, KiloCoulomb, HectoCoulomb, DecaCoulomb, DeciCoulomb, CentiCoulomb, MilliCoulomb, MicroCoulomb, NanoCoulomb, PicoCoulomb, FemtoCoulomb, AttoCoulomb, ZeptoCoulomb, YoctoCoulomb, 'AtomicUnitOfElectricCharge', 'AtomicUnitsOfElectricCharge', YottaAtomicUnitOfElectricCharge, ZettaAtomicUnitOfElectricCharge, ExaAtomicUnitOfElectricCharge, PetaAtomicUnitOfElectricCharge, TeraAtomicUnitOfElectricCharge, GigaAtomicUnitOfElectricCharge, MegaAtomicUnitOfElectricCharge, KiloAtomicUnitOfElectricCharge, HectoAtomicUnitOfElectricCharge, DecaAtomicUnitOfElectricCharge, DeciAtomicUnitOfElectricCharge, CentiAtomicUnitOfElectricCharge, MilliAtomicUnitOfElectricCharge, MicroAtomicUnitOfElectricCharge, NanoAtomicUnitOfElectricCharge, PicoAtomicUnitOfElectricCharge, FemtoAtomicUnitOfElectricCharge, AttoAtomicUnitOfElectricCharge, ZeptoAtomicUnitOfElectricCharge, YoctoAtomicUnitOfElectricCharge, 'YottaAtomicUnitOfCharge', YottaAtomicUnitOfCharge, 'ZettaAtomicUnitOfCharge', ZettaAtomicUnitOfCharge, 'ExaAtomicUnitOfCharge', ExaAtomicUnitOfCharge, 'PetaAtomicUnitOfCharge', PetaAtomicUnitOfCharge, 'TeraAtomicUnitOfCharge', TeraAtomicUnitOfCharge, 'GigaAtomicUnitOfCharge', GigaAtomicUnitOfCharge, 'MegaAtomicUnitOfCharge', MegaAtomicUnitOfCharge, 'KiloAtomicUnitOfCharge', KiloAtomicUnitOfCharge, 'HectoAtomicUnitOfCharge', HectoAtomicUnitOfCharge, 'DecaAtomicUnitOfCharge', DecaAtomicUnitOfCharge, 'DeciAtomicUnitOfCharge', DeciAtomicUnitOfCharge, 'CentiAtomicUnitOfCharge', CentiAtomicUnitOfCharge, 'MilliAtomicUnitOfCharge', MilliAtomicUnitOfCharge, 'MicroAtomicUnitOfCharge', MicroAtomicUnitOfCharge, 'NanoAtomicUnitOfCharge', NanoAtomicUnitOfCharge, 'PicoAtomicUnitOfCharge', PicoAtomicUnitOfCharge, 'FemtoAtomicUnitOfCharge', FemtoAtomicUnitOfCharge, 'AttoAtomicUnitOfCharge', AttoAtomicUnitOfCharge, 'ZeptoAtomicUnitOfCharge', ZeptoAtomicUnitOfCharge, 'YoctoAtomicUnitOfCharge', YoctoAtomicUnitOfCharge, 'Gram', 'Grams', YottaGram, ZettaGram, ExaGram, PetaGram, TeraGram, GigaGram, MegaGram, KiloGram, HectoGram, DecaGram, DeciGram, CentiGram, MilliGram, MicroGram, NanoGram, PicoGram, FemtoGram, AttoGram, ZeptoGram, YoctoGram, 'AtomicMassUnit', 'AtomicMassUnits', YottaAtomicMassUnit, ZettaAtomicMassUnit, ExaAtomicMassUnit, PetaAtomicMassUnit, TeraAtomicMassUnit, GigaAtomicMassUnit, MegaAtomicMassUnit, KiloAtomicMassUnit, HectoAtomicMassUnit, DecaAtomicMassUnit, DeciAtomicMassUnit, CentiAtomicMassUnit, MilliAtomicMassUnit, MicroAtomicMassUnit, NanoAtomicMassUnit, PicoAtomicMassUnit, FemtoAtomicMassUnit, AttoAtomicMassUnit, ZeptoAtomicMassUnit, YoctoAtomicMassUnit, 'YottaAMU', YottaAMU, 'ZettaAMU', ZettaAMU, 'ExaAMU', ExaAMU, 'PetaAMU', PetaAMU, 'TeraAMU', TeraAMU, 'GigaAMU', GigaAMU, 'MegaAMU', MegaAMU, 'KiloAMU', KiloAMU, 'HectoAMU', HectoAMU, 'DecaAMU', DecaAMU, 'DeciAMU', DeciAMU, 'CentiAMU', CentiAMU, 'MilliAMU', MilliAMU, 'MicroAMU', MicroAMU, 'NanoAMU', NanoAMU, 'PicoAMU', PicoAMU, 'FemtoAMU', FemtoAMU, 'AttoAMU', AttoAMU, 'ZeptoAMU', ZeptoAMU, 'YoctoAMU', YoctoAMU, 'AtomicUnitOfMass', 'AtomicUnitsOfMass', YottaAtomicUnitOfMass, ZettaAtomicUnitOfMass, ExaAtomicUnitOfMass, PetaAtomicUnitOfMass, TeraAtomicUnitOfMass, GigaAtomicUnitOfMass, MegaAtomicUnitOfMass, KiloAtomicUnitOfMass, HectoAtomicUnitOfMass, DecaAtomicUnitOfMass, DeciAtomicUnitOfMass, CentiAtomicUnitOfMass, MilliAtomicUnitOfMass, MicroAtomicUnitOfMass, NanoAtomicUnitOfMass, PicoAtomicUnitOfMass, FemtoAtomicUnitOfMass, AttoAtomicUnitOfMass, ZeptoAtomicUnitOfMass, YoctoAtomicUnitOfMass]
  `name` None
  `prefix_factor`(other)
  `prefixes` = [<grendel.util.units.unit.Prefix object at 0xd1cea6c>, <grendel.util.units.unit.Prefix object at 0xd1cea8c>, <grendel.util.units.unit.Prefix object at 0xd1ceaac>, <grendel.util.units.unit.Prefix object at 0xd1ceacc>, <grendel.util.units.unit.Prefix object at 0xd1ceaec>, <grendel.util.units.unit.Prefix object at 0xd1ceb0c>, <grendel.util.units.unit.Prefix object at 0xd1ceb2c>, <grendel.util.units.unit.Prefix object at 0xd1ceb4c>, <grendel.util.units.unit.Prefix object at 0xd1ceb6c>, <grendel.util.units.unit.Prefix object at 0xd1ceb8c>, <grendel.util.units.unit.Prefix object at 0xd1cebac>, <grendel.util.units.unit.Prefix object at 0xd1cebcc>, <grendel.util.units.unit.Prefix object at 0xd1cebec>, <grendel.util.units.unit.Prefix object at 0xd1cec0c>, <grendel.util.units.unit.Prefix object at 0xd1cec2c>, <grendel.util.units.unit.Prefix object at 0xd1cec4c>, <grendel.util.units.unit.Prefix object at 0xd1cec6c>, <grendel.util.units.unit.Prefix object at 0xd1cec8c>, <grendel.util.units.unit.Prefix object at 0xd1cecac>, <grendel.util.units.unit.Prefix object at 0xd1ceccc>]
  `to`(other)

`isunit`(unit)

  Aliased as is_unit()

`is_unit`(*fargs, **fkeywords)

  Alias for isunit()

`convert`(*fargs, **fkeywords)

  Alias for convert_units()

`convert_units`(val, from_unit, to_unit)

  Aliased as convert()

`compatible_units`(unit1, unit2)

  Aliased as iscompatible()

`iscompatible`(*fargs, **fkeywords)

  Alias for compatible_units()

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `EnergyUnit`

  General superclass for all energy units

  `default`

    alias of `Wavenumber`

  `reference_unit`

    alias of `Joule`

class `AngularUnit`

  General superclass for all angular units

  `default`

    alias of `Degree`

  `reference_unit`

    alias of `Degree`

class `ElectricChargeUnit`

  General superclass for all units of electric charge

  `default`

    alias of `Coulomb`

  `reference_unit`

    alias of `Coulomb`

class `MassUnit`

  General superclass for all units of mass

  `default`

    alias of `AtomicMassUnit`

  `reference_unit`

    alias of `Gram`

class `TimeUnit`

  General superclass for all time units

  `default`

    alias of `Second`

  `reference_unit`

    alias of `Second`

class `Angstrom`
  classmethod `to`(other)

`Angstroms`

  alias of `Angstrom`

class `YottaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottaangstrom`

  alias of `YottaAngstrom`

`Yottaangstroms`

  alias of `YottaAngstrom`

class `ZettaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettaangstrom`

  alias of `ZettaAngstrom`

`Zettaangstroms`

  alias of `ZettaAngstrom`

class `ExaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exaangstrom`

  alias of `ExaAngstrom`

`Exaangstroms`

  alias of `ExaAngstrom`

class `PetaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petaangstrom`

  alias of `PetaAngstrom`

`Petaangstroms`

  alias of `PetaAngstrom`

class `TeraAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teraangstrom`

  alias of `TeraAngstrom`

`Teraangstroms`

  alias of `TeraAngstrom`

class `GigaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigaangstrom`

  alias of `GigaAngstrom`

`Gigaangstroms`

  alias of `GigaAngstrom`

class `MegaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megaangstrom`

  alias of `MegaAngstrom`

`Megaangstroms`

  alias of `MegaAngstrom`

class `KiloAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kiloangstrom`

  alias of `KiloAngstrom`

`Kiloangstroms`

  alias of `KiloAngstrom`

class `HectoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectoangstrom`

  alias of `HectoAngstrom`

`Hectoangstroms`

  alias of `HectoAngstrom`

class `DecaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decaangstrom`

  alias of `DecaAngstrom`

`Decaangstroms`

  alias of `DecaAngstrom`

class `DeciAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciangstrom`

  alias of `DeciAngstrom`

`Deciangstroms`

  alias of `DeciAngstrom`

class `CentiAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiangstrom`

  alias of `CentiAngstrom`

`Centiangstroms`

  alias of `CentiAngstrom`

class `MilliAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliangstrom`

  alias of `MilliAngstrom`

`Milliangstroms`

  alias of `MilliAngstrom`

class `MicroAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microangstrom`

  alias of `MicroAngstrom`

`Microangstroms`

  alias of `MicroAngstrom`

class `NanoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanoangstrom`

  alias of `NanoAngstrom`

`Nanoangstroms`

  alias of `NanoAngstrom`

class `PicoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picoangstrom`

  alias of `PicoAngstrom`

`Picoangstroms`

  alias of `PicoAngstrom`

class `FemtoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtoangstrom`

  alias of `FemtoAngstrom`

`Femtoangstroms`

  alias of `FemtoAngstrom`

class `AttoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attoangstrom`

  alias of `AttoAngstrom`

`Attoangstroms`

  alias of `AttoAngstrom`

class `ZeptoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptoangstrom`

  alias of `ZeptoAngstrom`

`Zeptoangstroms`

  alias of `ZeptoAngstrom`

class `YoctoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctoangstrom`

  alias of `YoctoAngstrom`

`Yoctoangstroms`

  alias of `YoctoAngstrom`

class `Bohr`

`Bohrs`

  alias of `Bohr`

class `YottaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottabohr`

  alias of `YottaBohr`

`Yottabohrs`

  alias of `YottaBohr`

class `ZettaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettabohr`

  alias of `ZettaBohr`

`Zettabohrs`

  alias of `ZettaBohr`

class `ExaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exabohr`

  alias of `ExaBohr`

`Exabohrs`

  alias of `ExaBohr`

class `PetaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petabohr`

  alias of `PetaBohr`

`Petabohrs`

  alias of `PetaBohr`

class `TeraBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terabohr`

  alias of `TeraBohr`

`Terabohrs`

  alias of `TeraBohr`

class `GigaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigabohr`

  alias of `GigaBohr`

`Gigabohrs`

  alias of `GigaBohr`

class `MegaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megabohr`

  alias of `MegaBohr`

`Megabohrs`

  alias of `MegaBohr`

class `KiloBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilobohr`

  alias of `KiloBohr`

`Kilobohrs`

  alias of `KiloBohr`

class `HectoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectobohr`

  alias of `HectoBohr`

`Hectobohrs`

  alias of `HectoBohr`

class `DecaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decabohr`

  alias of `DecaBohr`

`Decabohrs`

  alias of `DecaBohr`

class `DeciBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decibohr`

  alias of `DeciBohr`

`Decibohrs`

  alias of `DeciBohr`

class `CentiBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centibohr`

  alias of `CentiBohr`

`Centibohrs`

  alias of `CentiBohr`

class `MilliBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millibohr`

  alias of `MilliBohr`

`Millibohrs`

  alias of `MilliBohr`

class `MicroBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microbohr`

  alias of `MicroBohr`

`Microbohrs`

  alias of `MicroBohr`

class `NanoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanobohr`

  alias of `NanoBohr`

`Nanobohrs`

  alias of `NanoBohr`

class `PicoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picobohr`

  alias of `PicoBohr`

`Picobohrs`

  alias of `PicoBohr`

class `FemtoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtobohr`

  alias of `FemtoBohr`

`Femtobohrs`

  alias of `FemtoBohr`

class `AttoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attobohr`

  alias of `AttoBohr`

`Attobohrs`

  alias of `AttoBohr`

class `ZeptoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptobohr`

  alias of `ZeptoBohr`

`Zeptobohrs`

  alias of `ZeptoBohr`

class `YoctoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctobohr`

  alias of `YoctoBohr`

`Yoctobohrs`

  alias of `YoctoBohr`

`AtomicUnitOfDistance`

  alias of `Bohr`

`AtomicUnitsOfDistance`

  alias of `Bohr`

class `YottaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`YottaAtomicUnitsOfDistance`

  alias of `YottaAtomicUnitOfDistance`

class `ZettaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`ZettaAtomicUnitsOfDistance`

  alias of `ZettaAtomicUnitOfDistance`

class `ExaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`ExaAtomicUnitsOfDistance`

  alias of `ExaAtomicUnitOfDistance`

class `PetaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`PetaAtomicUnitsOfDistance`

  alias of `PetaAtomicUnitOfDistance`

class `TeraAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`TeraAtomicUnitsOfDistance`

  alias of `TeraAtomicUnitOfDistance`

class `GigaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`GigaAtomicUnitsOfDistance`

  alias of `GigaAtomicUnitOfDistance`

class `MegaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`MegaAtomicUnitsOfDistance`

  alias of `MegaAtomicUnitOfDistance`

class `KiloAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`KiloAtomicUnitsOfDistance`

  alias of `KiloAtomicUnitOfDistance`

class `HectoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`HectoAtomicUnitsOfDistance`

  alias of `HectoAtomicUnitOfDistance`

class `DecaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`DecaAtomicUnitsOfDistance`

  alias of `DecaAtomicUnitOfDistance`

class `DeciAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`DeciAtomicUnitsOfDistance`

  alias of `DeciAtomicUnitOfDistance`

class `CentiAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`CentiAtomicUnitsOfDistance`

  alias of `CentiAtomicUnitOfDistance`

class `MilliAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`MilliAtomicUnitsOfDistance`

  alias of `MilliAtomicUnitOfDistance`

class `MicroAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`MicroAtomicUnitsOfDistance`

  alias of `MicroAtomicUnitOfDistance`

class `NanoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`NanoAtomicUnitsOfDistance`

  alias of `NanoAtomicUnitOfDistance`

class `PicoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`PicoAtomicUnitsOfDistance`

  alias of `PicoAtomicUnitOfDistance`

class `FemtoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`FemtoAtomicUnitsOfDistance`

  alias of `FemtoAtomicUnitOfDistance`

class `AttoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`AttoAtomicUnitsOfDistance`

  alias of `AttoAtomicUnitOfDistance`

class `ZeptoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`ZeptoAtomicUnitsOfDistance`

  alias of `ZeptoAtomicUnitOfDistance`

class `YoctoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`YoctoAtomicUnitsOfDistance`

  alias of `YoctoAtomicUnitOfDistance`

class `Meter`

`Meters`

  alias of `Meter`

class `YottaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottameter`

  alias of `YottaMeter`

`Yottameters`

  alias of `YottaMeter`

class `ZettaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettameter`

  alias of `ZettaMeter`

`Zettameters`

  alias of `ZettaMeter`

class `ExaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exameter`

  alias of `ExaMeter`

`Exameters`

  alias of `ExaMeter`

class `PetaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petameter`

  alias of `PetaMeter`

`Petameters`

  alias of `PetaMeter`

class `TeraMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terameter`

  alias of `TeraMeter`

`Terameters`

  alias of `TeraMeter`

class `GigaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigameter`

  alias of `GigaMeter`

`Gigameters`

  alias of `GigaMeter`

class `MegaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megameter`

  alias of `MegaMeter`

`Megameters`

  alias of `MegaMeter`

class `KiloMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilometer`

  alias of `KiloMeter`

`Kilometers`

  alias of `KiloMeter`

class `HectoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectometer`

  alias of `HectoMeter`

`Hectometers`

  alias of `HectoMeter`

class `DecaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decameter`

  alias of `DecaMeter`

`Decameters`

  alias of `DecaMeter`

class `DeciMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decimeter`

  alias of `DeciMeter`

`Decimeters`

  alias of `DeciMeter`

class `CentiMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centimeter`

  alias of `CentiMeter`

`Centimeters`

  alias of `CentiMeter`

class `MilliMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millimeter`

  alias of `MilliMeter`

`Millimeters`

  alias of `MilliMeter`

class `MicroMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Micrometer`

  alias of `MicroMeter`

`Micrometers`

  alias of `MicroMeter`

class `NanoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanometer`

  alias of `NanoMeter`

`Nanometers`

  alias of `NanoMeter`

class `PicoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picometer`

  alias of `PicoMeter`

`Picometers`

  alias of `PicoMeter`

class `FemtoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtometer`

  alias of `FemtoMeter`

`Femtometers`

  alias of `FemtoMeter`

class `AttoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attometer`

  alias of `AttoMeter`

`Attometers`

  alias of `AttoMeter`

class `ZeptoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptometer`

  alias of `ZeptoMeter`

`Zeptometers`

  alias of `ZeptoMeter`

class `YoctoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctometer`

  alias of `YoctoMeter`

`Yoctometers`

  alias of `YoctoMeter`

class `Degree`
  classmethod `to`(other)

`Degrees`

  alias of `Degree`

class `YottaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottadegree`

  alias of `YottaDegree`

`Yottadegrees`

  alias of `YottaDegree`

class `ZettaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettadegree`

  alias of `ZettaDegree`

`Zettadegrees`

  alias of `ZettaDegree`

class `ExaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exadegree`

  alias of `ExaDegree`

`Exadegrees`

  alias of `ExaDegree`

class `PetaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petadegree`

  alias of `PetaDegree`

`Petadegrees`

  alias of `PetaDegree`

class `TeraDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teradegree`

  alias of `TeraDegree`

`Teradegrees`

  alias of `TeraDegree`

class `GigaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigadegree`

  alias of `GigaDegree`

`Gigadegrees`

  alias of `GigaDegree`

class `MegaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megadegree`

  alias of `MegaDegree`

`Megadegrees`

  alias of `MegaDegree`

class `KiloDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilodegree`

  alias of `KiloDegree`

`Kilodegrees`

  alias of `KiloDegree`

class `HectoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectodegree`

  alias of `HectoDegree`

`Hectodegrees`

  alias of `HectoDegree`

class `DecaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decadegree`

  alias of `DecaDegree`

`Decadegrees`

  alias of `DecaDegree`

class `DeciDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decidegree`

  alias of `DeciDegree`

`Decidegrees`

  alias of `DeciDegree`

class `CentiDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centidegree`

  alias of `CentiDegree`

`Centidegrees`

  alias of `CentiDegree`

class `MilliDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millidegree`

  alias of `MilliDegree`

`Millidegrees`

  alias of `MilliDegree`

class `MicroDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microdegree`

  alias of `MicroDegree`

`Microdegrees`

  alias of `MicroDegree`

class `NanoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanodegree`

  alias of `NanoDegree`

`Nanodegrees`

  alias of `NanoDegree`

class `PicoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picodegree`

  alias of `PicoDegree`

`Picodegrees`

  alias of `PicoDegree`

class `FemtoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtodegree`

  alias of `FemtoDegree`

`Femtodegrees`

  alias of `FemtoDegree`

class `AttoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attodegree`

  alias of `AttoDegree`

`Attodegrees`

  alias of `AttoDegree`

class `ZeptoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptodegree`

  alias of `ZeptoDegree`

`Zeptodegrees`

  alias of `ZeptoDegree`

class `YoctoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctodegree`

  alias of `YoctoDegree`

`Yoctodegrees`

  alias of `YoctoDegree`

class `Radian`

`Radians`

  alias of `Radian`

class `YottaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottaradian`

  alias of `YottaRadian`

`Yottaradians`

  alias of `YottaRadian`

class `ZettaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettaradian`

  alias of `ZettaRadian`

`Zettaradians`

  alias of `ZettaRadian`

class `ExaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exaradian`

  alias of `ExaRadian`

`Exaradians`

  alias of `ExaRadian`

class `PetaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petaradian`

  alias of `PetaRadian`

`Petaradians`

  alias of `PetaRadian`

class `TeraRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teraradian`

  alias of `TeraRadian`

`Teraradians`

  alias of `TeraRadian`

class `GigaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigaradian`

  alias of `GigaRadian`

`Gigaradians`

  alias of `GigaRadian`

class `MegaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megaradian`

  alias of `MegaRadian`

`Megaradians`

  alias of `MegaRadian`

class `KiloRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kiloradian`

  alias of `KiloRadian`

`Kiloradians`

  alias of `KiloRadian`

class `HectoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectoradian`

  alias of `HectoRadian`

`Hectoradians`

  alias of `HectoRadian`

class `DecaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decaradian`

  alias of `DecaRadian`

`Decaradians`

  alias of `DecaRadian`

class `DeciRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciradian`

  alias of `DeciRadian`

`Deciradians`

  alias of `DeciRadian`

class `CentiRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiradian`

  alias of `CentiRadian`

`Centiradians`

  alias of `CentiRadian`

class `MilliRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliradian`

  alias of `MilliRadian`

`Milliradians`

  alias of `MilliRadian`

class `MicroRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microradian`

  alias of `MicroRadian`

`Microradians`

  alias of `MicroRadian`

class `NanoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanoradian`

  alias of `NanoRadian`

`Nanoradians`

  alias of `NanoRadian`

class `PicoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picoradian`

  alias of `PicoRadian`

`Picoradians`

  alias of `PicoRadian`

class `FemtoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtoradian`

  alias of `FemtoRadian`

`Femtoradians`

  alias of `FemtoRadian`

class `AttoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attoradian`

  alias of `AttoRadian`

`Attoradians`

  alias of `AttoRadian`

class `ZeptoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptoradian`

  alias of `ZeptoRadian`

`Zeptoradians`

  alias of `ZeptoRadian`

class `YoctoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctoradian`

  alias of `YoctoRadian`

`Yoctoradians`

  alias of `YoctoRadian`

class `Joule`
  classmethod `to`(other)

`Joules`

  alias of `Joule`

class `YottaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottajoule`

  alias of `YottaJoule`

`Yottajoules`

  alias of `YottaJoule`

class `ZettaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettajoule`

  alias of `ZettaJoule`

`Zettajoules`

  alias of `ZettaJoule`

class `ExaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exajoule`

  alias of `ExaJoule`

`Exajoules`

  alias of `ExaJoule`

class `PetaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petajoule`

  alias of `PetaJoule`

`Petajoules`

  alias of `PetaJoule`

class `TeraJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terajoule`

  alias of `TeraJoule`

`Terajoules`

  alias of `TeraJoule`

class `GigaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigajoule`

  alias of `GigaJoule`

`Gigajoules`

  alias of `GigaJoule`

class `MegaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megajoule`

  alias of `MegaJoule`

`Megajoules`

  alias of `MegaJoule`

class `KiloJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilojoule`

  alias of `KiloJoule`

`Kilojoules`

  alias of `KiloJoule`

class `HectoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectojoule`

  alias of `HectoJoule`

`Hectojoules`

  alias of `HectoJoule`

class `DecaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decajoule`

  alias of `DecaJoule`

`Decajoules`

  alias of `DecaJoule`

class `DeciJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decijoule`

  alias of `DeciJoule`

`Decijoules`

  alias of `DeciJoule`

class `CentiJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centijoule`

  alias of `CentiJoule`

`Centijoules`

  alias of `CentiJoule`

class `MilliJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millijoule`

  alias of `MilliJoule`

`Millijoules`

  alias of `MilliJoule`

class `MicroJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microjoule`

  alias of `MicroJoule`

`Microjoules`

  alias of `MicroJoule`

class `NanoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanojoule`

  alias of `NanoJoule`

`Nanojoules`

  alias of `NanoJoule`

class `PicoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picojoule`

  alias of `PicoJoule`

`Picojoules`

  alias of `PicoJoule`

class `FemtoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtojoule`

  alias of `FemtoJoule`

`Femtojoules`

  alias of `FemtoJoule`

class `AttoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attojoule`

  alias of `AttoJoule`

`Attojoules`

  alias of `AttoJoule`

class `ZeptoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptojoule`

  alias of `ZeptoJoule`

`Zeptojoules`

  alias of `ZeptoJoule`

class `YoctoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctojoule`

  alias of `YoctoJoule`

`Yoctojoules`

  alias of `YoctoJoule`

class `Wavenumber`

`Wavenumbers`

  alias of `Wavenumber`

class `YottaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottawavenumber`

  alias of `YottaWavenumber`

`Yottawavenumbers`

  alias of `YottaWavenumber`

class `ZettaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettawavenumber`

  alias of `ZettaWavenumber`

`Zettawavenumbers`

  alias of `ZettaWavenumber`

class `ExaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exawavenumber`

  alias of `ExaWavenumber`

`Exawavenumbers`

  alias of `ExaWavenumber`

class `PetaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petawavenumber`

  alias of `PetaWavenumber`

`Petawavenumbers`

  alias of `PetaWavenumber`

class `TeraWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terawavenumber`

  alias of `TeraWavenumber`

`Terawavenumbers`

  alias of `TeraWavenumber`

class `GigaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigawavenumber`

  alias of `GigaWavenumber`

`Gigawavenumbers`

  alias of `GigaWavenumber`

class `MegaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megawavenumber`

  alias of `MegaWavenumber`

`Megawavenumbers`

  alias of `MegaWavenumber`

class `KiloWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilowavenumber`

  alias of `KiloWavenumber`

`Kilowavenumbers`

  alias of `KiloWavenumber`

class `HectoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectowavenumber`

  alias of `HectoWavenumber`

`Hectowavenumbers`

  alias of `HectoWavenumber`

class `DecaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decawavenumber`

  alias of `DecaWavenumber`

`Decawavenumbers`

  alias of `DecaWavenumber`

class `DeciWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciwavenumber`

  alias of `DeciWavenumber`

`Deciwavenumbers`

  alias of `DeciWavenumber`

class `CentiWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiwavenumber`

  alias of `CentiWavenumber`

`Centiwavenumbers`

  alias of `CentiWavenumber`

class `MilliWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliwavenumber`

  alias of `MilliWavenumber`

`Milliwavenumbers`

  alias of `MilliWavenumber`

class `MicroWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microwavenumber`

  alias of `MicroWavenumber`

`Microwavenumbers`

  alias of `MicroWavenumber`

class `NanoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanowavenumber`

  alias of `NanoWavenumber`

`Nanowavenumbers`

  alias of `NanoWavenumber`

class `PicoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picowavenumber`

  alias of `PicoWavenumber`

`Picowavenumbers`

  alias of `PicoWavenumber`

class `FemtoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtowavenumber`

  alias of `FemtoWavenumber`

`Femtowavenumbers`

  alias of `FemtoWavenumber`

class `AttoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attowavenumber`

  alias of `AttoWavenumber`

`Attowavenumbers`

  alias of `AttoWavenumber`

class `ZeptoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptowavenumber`

  alias of `ZeptoWavenumber`

`Zeptowavenumbers`

  alias of `ZeptoWavenumber`

class `YoctoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctowavenumber`

  alias of `YoctoWavenumber`

`Yoctowavenumbers`

  alias of `YoctoWavenumber`

class `Hertz`

`Hertzs`

  alias of `Hertz`

class `YottaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottahertz`

  alias of `YottaHertz`

`Yottahertzs`

  alias of `YottaHertz`

class `ZettaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettahertz`

  alias of `ZettaHertz`

`Zettahertzs`

  alias of `ZettaHertz`

class `ExaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exahertz`

  alias of `ExaHertz`

`Exahertzs`

  alias of `ExaHertz`

class `PetaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petahertz`

  alias of `PetaHertz`

`Petahertzs`

  alias of `PetaHertz`

class `TeraHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terahertz`

  alias of `TeraHertz`

`Terahertzs`

  alias of `TeraHertz`

class `GigaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigahertz`

  alias of `GigaHertz`

`Gigahertzs`

  alias of `GigaHertz`

class `MegaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megahertz`

  alias of `MegaHertz`

`Megahertzs`

  alias of `MegaHertz`

class `KiloHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilohertz`

  alias of `KiloHertz`

`Kilohertzs`

  alias of `KiloHertz`

class `HectoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectohertz`

  alias of `HectoHertz`

`Hectohertzs`

  alias of `HectoHertz`

class `DecaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decahertz`

  alias of `DecaHertz`

`Decahertzs`

  alias of `DecaHertz`

class `DeciHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decihertz`

  alias of `DeciHertz`

`Decihertzs`

  alias of `DeciHertz`

class `CentiHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centihertz`

  alias of `CentiHertz`

`Centihertzs`

  alias of `CentiHertz`

class `MilliHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millihertz`

  alias of `MilliHertz`

`Millihertzs`

  alias of `MilliHertz`

class `MicroHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microhertz`

  alias of `MicroHertz`

`Microhertzs`

  alias of `MicroHertz`

class `NanoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanohertz`

  alias of `NanoHertz`

`Nanohertzs`

  alias of `NanoHertz`

class `PicoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picohertz`

  alias of `PicoHertz`

`Picohertzs`

  alias of `PicoHertz`

class `FemtoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtohertz`

  alias of `FemtoHertz`

`Femtohertzs`

  alias of `FemtoHertz`

class `AttoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attohertz`

  alias of `AttoHertz`

`Attohertzs`

  alias of `AttoHertz`

class `ZeptoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptohertz`

  alias of `ZeptoHertz`

`Zeptohertzs`

  alias of `ZeptoHertz`

class `YoctoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctohertz`

  alias of `YoctoHertz`

`Yoctohertzs`

  alias of `YoctoHertz`

class `Hertz`

class `Hartree`

`Hartrees`

  alias of `Hartree`

class `YottaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottahartree`

  alias of `YottaHartree`

`Yottahartrees`

  alias of `YottaHartree`

class `ZettaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettahartree`

  alias of `ZettaHartree`

`Zettahartrees`

  alias of `ZettaHartree`

class `ExaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exahartree`

  alias of `ExaHartree`

`Exahartrees`

  alias of `ExaHartree`

class `PetaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petahartree`

  alias of `PetaHartree`

`Petahartrees`

  alias of `PetaHartree`

class `TeraHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terahartree`

  alias of `TeraHartree`

`Terahartrees`

  alias of `TeraHartree`

class `GigaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigahartree`

  alias of `GigaHartree`

`Gigahartrees`

  alias of `GigaHartree`

class `MegaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megahartree`

  alias of `MegaHartree`

`Megahartrees`

  alias of `MegaHartree`

class `KiloHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilohartree`

  alias of `KiloHartree`

`Kilohartrees`

  alias of `KiloHartree`

class `HectoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectohartree`

  alias of `HectoHartree`

`Hectohartrees`

  alias of `HectoHartree`

class `DecaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decahartree`

  alias of `DecaHartree`

`Decahartrees`

  alias of `DecaHartree`

class `DeciHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decihartree`

  alias of `DeciHartree`

`Decihartrees`

  alias of `DeciHartree`

class `CentiHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centihartree`

  alias of `CentiHartree`

`Centihartrees`

  alias of `CentiHartree`

class `MilliHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millihartree`

  alias of `MilliHartree`

`Millihartrees`

  alias of `MilliHartree`

class `MicroHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microhartree`

  alias of `MicroHartree`

`Microhartrees`

  alias of `MicroHartree`

class `NanoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanohartree`

  alias of `NanoHartree`

`Nanohartrees`

  alias of `NanoHartree`

class `PicoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picohartree`

  alias of `PicoHartree`

`Picohartrees`

  alias of `PicoHartree`

class `FemtoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtohartree`

  alias of `FemtoHartree`

`Femtohartrees`

  alias of `FemtoHartree`

class `AttoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attohartree`

  alias of `AttoHartree`

`Attohartrees`

  alias of `AttoHartree`

class `ZeptoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptohartree`

  alias of `ZeptoHartree`

`Zeptohartrees`

  alias of `ZeptoHartree`

class `YoctoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctohartree`

  alias of `YoctoHartree`

`Yoctohartrees`

  alias of `YoctoHartree`

class `Hartree`

`AtomicUnitOfEnergy`

  alias of `Hartree`

`AtomicUnitsOfEnergy`

  alias of `Hartree`

class `YottaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`YottaAtomicUnitsOfEnergy`

  alias of `YottaAtomicUnitOfEnergy`

class `ZettaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`ZettaAtomicUnitsOfEnergy`

  alias of `ZettaAtomicUnitOfEnergy`

class `ExaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`ExaAtomicUnitsOfEnergy`

  alias of `ExaAtomicUnitOfEnergy`

class `PetaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`PetaAtomicUnitsOfEnergy`

  alias of `PetaAtomicUnitOfEnergy`

class `TeraAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`TeraAtomicUnitsOfEnergy`

  alias of `TeraAtomicUnitOfEnergy`

class `GigaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`GigaAtomicUnitsOfEnergy`

  alias of `GigaAtomicUnitOfEnergy`

class `MegaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`MegaAtomicUnitsOfEnergy`

  alias of `MegaAtomicUnitOfEnergy`

class `KiloAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`KiloAtomicUnitsOfEnergy`

  alias of `KiloAtomicUnitOfEnergy`

class `HectoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`HectoAtomicUnitsOfEnergy`

  alias of `HectoAtomicUnitOfEnergy`

class `DecaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`DecaAtomicUnitsOfEnergy`

  alias of `DecaAtomicUnitOfEnergy`

class `DeciAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`DeciAtomicUnitsOfEnergy`

  alias of `DeciAtomicUnitOfEnergy`

class `CentiAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`CentiAtomicUnitsOfEnergy`

  alias of `CentiAtomicUnitOfEnergy`

class `MilliAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`MilliAtomicUnitsOfEnergy`

  alias of `MilliAtomicUnitOfEnergy`

class `MicroAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`MicroAtomicUnitsOfEnergy`

  alias of `MicroAtomicUnitOfEnergy`

class `NanoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`NanoAtomicUnitsOfEnergy`

  alias of `NanoAtomicUnitOfEnergy`

class `PicoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`PicoAtomicUnitsOfEnergy`

  alias of `PicoAtomicUnitOfEnergy`

class `FemtoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`FemtoAtomicUnitsOfEnergy`

  alias of `FemtoAtomicUnitOfEnergy`

class `AttoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`AttoAtomicUnitsOfEnergy`

  alias of `AttoAtomicUnitOfEnergy`

class `ZeptoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`ZeptoAtomicUnitsOfEnergy`

  alias of `ZeptoAtomicUnitOfEnergy`

class `YoctoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`YoctoAtomicUnitsOfEnergy`

  alias of `YoctoAtomicUnitOfEnergy`

class `KiloCaloriePerMol`

`KiloCaloriePerMols`

  alias of `KiloCaloriePerMol`

class `KiloCaloriePerMol`

`KiloCaloriePerMole`

  alias of `KiloCaloriePerMol`

`KiloCaloriesPerMol`

  alias of `KiloCaloriePerMol`

`KCalPerMol`

  alias of `KiloCaloriePerMol`

`KCalsPerMol`

  alias of `KiloCaloriePerMol`

`KcalPerMol`

  alias of `KiloCaloriePerMol`

`KcalsPerMol`

  alias of `KiloCaloriePerMol`

class `KiloJoulePerMol`

`KiloJoulesPerMol`

  alias of `KiloJoulePerMol`

class `YottaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `ZettaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ExaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `PetaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `TeraKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `GigaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `MegaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `KiloKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `HectoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `DecaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DeciKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `CentiKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `MilliKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MicroKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `NanoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `PicoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `FemtoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `AttoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `ZeptoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `YoctoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `KiloJoulePerMol`

class `Second`
  classmethod `to`(other)

`Seconds`

  alias of `Second`

class `YottaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottasecond`

  alias of `YottaSecond`

`Yottaseconds`

  alias of `YottaSecond`

class `ZettaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettasecond`

  alias of `ZettaSecond`

`Zettaseconds`

  alias of `ZettaSecond`

class `ExaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exasecond`

  alias of `ExaSecond`

`Exaseconds`

  alias of `ExaSecond`

class `PetaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petasecond`

  alias of `PetaSecond`

`Petaseconds`

  alias of `PetaSecond`

class `TeraSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terasecond`

  alias of `TeraSecond`

`Teraseconds`

  alias of `TeraSecond`

class `GigaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigasecond`

  alias of `GigaSecond`

`Gigaseconds`

  alias of `GigaSecond`

class `MegaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megasecond`

  alias of `MegaSecond`

`Megaseconds`

  alias of `MegaSecond`

class `KiloSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilosecond`

  alias of `KiloSecond`

`Kiloseconds`

  alias of `KiloSecond`

class `HectoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectosecond`

  alias of `HectoSecond`

`Hectoseconds`

  alias of `HectoSecond`

class `DecaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decasecond`

  alias of `DecaSecond`

`Decaseconds`

  alias of `DecaSecond`

class `DeciSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decisecond`

  alias of `DeciSecond`

`Deciseconds`

  alias of `DeciSecond`

class `CentiSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centisecond`

  alias of `CentiSecond`

`Centiseconds`

  alias of `CentiSecond`

class `MilliSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millisecond`

  alias of `MilliSecond`

`Milliseconds`

  alias of `MilliSecond`

class `MicroSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microsecond`

  alias of `MicroSecond`

`Microseconds`

  alias of `MicroSecond`

class `NanoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanosecond`

  alias of `NanoSecond`

`Nanoseconds`

  alias of `NanoSecond`

class `PicoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picosecond`

  alias of `PicoSecond`

`Picoseconds`

  alias of `PicoSecond`

class `FemtoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtosecond`

  alias of `FemtoSecond`

`Femtoseconds`

  alias of `FemtoSecond`

class `AttoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attosecond`

  alias of `AttoSecond`

`Attoseconds`

  alias of `AttoSecond`

class `ZeptoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptosecond`

  alias of `ZeptoSecond`

`Zeptoseconds`

  alias of `ZeptoSecond`

class `YoctoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctosecond`

  alias of `YoctoSecond`

`Yoctoseconds`

  alias of `YoctoSecond`

class `AtomicUnitOfTime`

`AtomicUnitsOfTime`

  alias of `AtomicUnitOfTime`

class `YottaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `ZettaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ExaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `PetaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `TeraAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `GigaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `MegaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `KiloAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `HectoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `DecaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DeciAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `CentiAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `MilliAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MicroAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `NanoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `PicoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `FemtoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `AttoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `ZeptoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `YoctoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `AtomicUnitOfTime`

class `Minute`

`Minutes`

  alias of `Minute`

class `YottaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottaminute`

  alias of `YottaMinute`

`Yottaminutes`

  alias of `YottaMinute`

class `ZettaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettaminute`

  alias of `ZettaMinute`

`Zettaminutes`

  alias of `ZettaMinute`

class `ExaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Examinute`

  alias of `ExaMinute`

`Examinutes`

  alias of `ExaMinute`

class `PetaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petaminute`

  alias of `PetaMinute`

`Petaminutes`

  alias of `PetaMinute`

class `TeraMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teraminute`

  alias of `TeraMinute`

`Teraminutes`

  alias of `TeraMinute`

class `GigaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigaminute`

  alias of `GigaMinute`

`Gigaminutes`

  alias of `GigaMinute`

class `MegaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megaminute`

  alias of `MegaMinute`

`Megaminutes`

  alias of `MegaMinute`

class `KiloMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilominute`

  alias of `KiloMinute`

`Kilominutes`

  alias of `KiloMinute`

class `HectoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectominute`

  alias of `HectoMinute`

`Hectominutes`

  alias of `HectoMinute`

class `DecaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decaminute`

  alias of `DecaMinute`

`Decaminutes`

  alias of `DecaMinute`

class `DeciMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciminute`

  alias of `DeciMinute`

`Deciminutes`

  alias of `DeciMinute`

class `CentiMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiminute`

  alias of `CentiMinute`

`Centiminutes`

  alias of `CentiMinute`

class `MilliMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliminute`

  alias of `MilliMinute`

`Milliminutes`

  alias of `MilliMinute`

class `MicroMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microminute`

  alias of `MicroMinute`

`Microminutes`

  alias of `MicroMinute`

class `NanoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanominute`

  alias of `NanoMinute`

`Nanominutes`

  alias of `NanoMinute`

class `PicoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picominute`

  alias of `PicoMinute`

`Picominutes`

  alias of `PicoMinute`

class `FemtoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtominute`

  alias of `FemtoMinute`

`Femtominutes`

  alias of `FemtoMinute`

class `AttoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attominute`

  alias of `AttoMinute`

`Attominutes`

  alias of `AttoMinute`

class `ZeptoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptominute`

  alias of `ZeptoMinute`

`Zeptominutes`

  alias of `ZeptoMinute`

class `YoctoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctominute`

  alias of `YoctoMinute`

`Yoctominutes`

  alias of `YoctoMinute`

class `Minute`

class `Hour`

`Hours`

  alias of `Hour`

class `YottaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottahour`

  alias of `YottaHour`

`Yottahours`

  alias of `YottaHour`

class `ZettaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettahour`

  alias of `ZettaHour`

`Zettahours`

  alias of `ZettaHour`

class `ExaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exahour`

  alias of `ExaHour`

`Exahours`

  alias of `ExaHour`

class `PetaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petahour`

  alias of `PetaHour`

`Petahours`

  alias of `PetaHour`

class `TeraHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terahour`

  alias of `TeraHour`

`Terahours`

  alias of `TeraHour`

class `GigaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigahour`

  alias of `GigaHour`

`Gigahours`

  alias of `GigaHour`

class `MegaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megahour`

  alias of `MegaHour`

`Megahours`

  alias of `MegaHour`

class `KiloHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilohour`

  alias of `KiloHour`

`Kilohours`

  alias of `KiloHour`

class `HectoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectohour`

  alias of `HectoHour`

`Hectohours`

  alias of `HectoHour`

class `DecaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decahour`

  alias of `DecaHour`

`Decahours`

  alias of `DecaHour`

class `DeciHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decihour`

  alias of `DeciHour`

`Decihours`

  alias of `DeciHour`

class `CentiHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centihour`

  alias of `CentiHour`

`Centihours`

  alias of `CentiHour`

class `MilliHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millihour`

  alias of `MilliHour`

`Millihours`

  alias of `MilliHour`

class `MicroHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microhour`

  alias of `MicroHour`

`Microhours`

  alias of `MicroHour`

class `NanoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanohour`

  alias of `NanoHour`

`Nanohours`

  alias of `NanoHour`

class `PicoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picohour`

  alias of `PicoHour`

`Picohours`

  alias of `PicoHour`

class `FemtoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtohour`

  alias of `FemtoHour`

`Femtohours`

  alias of `FemtoHour`

class `AttoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attohour`

  alias of `AttoHour`

`Attohours`

  alias of `AttoHour`

class `ZeptoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptohour`

  alias of `ZeptoHour`

`Zeptohours`

  alias of `ZeptoHour`

class `YoctoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctohour`

  alias of `YoctoHour`

`Yoctohours`

  alias of `YoctoHour`

class `Hour`

class `Day`

`Days`

  alias of `Day`

class `YottaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottaday`

  alias of `YottaDay`

`Yottadays`

  alias of `YottaDay`

class `ZettaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettaday`

  alias of `ZettaDay`

`Zettadays`

  alias of `ZettaDay`

class `ExaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exaday`

  alias of `ExaDay`

`Exadays`

  alias of `ExaDay`

class `PetaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petaday`

  alias of `PetaDay`

`Petadays`

  alias of `PetaDay`

class `TeraDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teraday`

  alias of `TeraDay`

`Teradays`

  alias of `TeraDay`

class `GigaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigaday`

  alias of `GigaDay`

`Gigadays`

  alias of `GigaDay`

class `MegaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megaday`

  alias of `MegaDay`

`Megadays`

  alias of `MegaDay`

class `KiloDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kiloday`

  alias of `KiloDay`

`Kilodays`

  alias of `KiloDay`

class `HectoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectoday`

  alias of `HectoDay`

`Hectodays`

  alias of `HectoDay`

class `DecaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decaday`

  alias of `DecaDay`

`Decadays`

  alias of `DecaDay`

class `DeciDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciday`

  alias of `DeciDay`

`Decidays`

  alias of `DeciDay`

class `CentiDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiday`

  alias of `CentiDay`

`Centidays`

  alias of `CentiDay`

class `MilliDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliday`

  alias of `MilliDay`

`Millidays`

  alias of `MilliDay`

class `MicroDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microday`

  alias of `MicroDay`

`Microdays`

  alias of `MicroDay`

class `NanoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanoday`

  alias of `NanoDay`

`Nanodays`

  alias of `NanoDay`

class `PicoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picoday`

  alias of `PicoDay`

`Picodays`

  alias of `PicoDay`

class `FemtoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtoday`

  alias of `FemtoDay`

`Femtodays`

  alias of `FemtoDay`

class `AttoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attoday`

  alias of `AttoDay`

`Attodays`

  alias of `AttoDay`

class `ZeptoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptoday`

  alias of `ZeptoDay`

`Zeptodays`

  alias of `ZeptoDay`

class `YoctoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctoday`

  alias of `YoctoDay`

`Yoctodays`

  alias of `YoctoDay`

class `Day`

class `Week`

`Weeks`

  alias of `Week`

class `YottaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottaweek`

  alias of `YottaWeek`

`Yottaweeks`

  alias of `YottaWeek`

class `ZettaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettaweek`

  alias of `ZettaWeek`

`Zettaweeks`

  alias of `ZettaWeek`

class `ExaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exaweek`

  alias of `ExaWeek`

`Exaweeks`

  alias of `ExaWeek`

class `PetaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petaweek`

  alias of `PetaWeek`

`Petaweeks`

  alias of `PetaWeek`

class `TeraWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teraweek`

  alias of `TeraWeek`

`Teraweeks`

  alias of `TeraWeek`

class `GigaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigaweek`

  alias of `GigaWeek`

`Gigaweeks`

  alias of `GigaWeek`

class `MegaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megaweek`

  alias of `MegaWeek`

`Megaweeks`

  alias of `MegaWeek`

class `KiloWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kiloweek`

  alias of `KiloWeek`

`Kiloweeks`

  alias of `KiloWeek`

class `HectoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectoweek`

  alias of `HectoWeek`

`Hectoweeks`

  alias of `HectoWeek`

class `DecaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decaweek`

  alias of `DecaWeek`

`Decaweeks`

  alias of `DecaWeek`

class `DeciWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciweek`

  alias of `DeciWeek`

`Deciweeks`

  alias of `DeciWeek`

class `CentiWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiweek`

  alias of `CentiWeek`

`Centiweeks`

  alias of `CentiWeek`

class `MilliWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliweek`

  alias of `MilliWeek`

`Milliweeks`

  alias of `MilliWeek`

class `MicroWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microweek`

  alias of `MicroWeek`

`Microweeks`

  alias of `MicroWeek`

class `NanoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanoweek`

  alias of `NanoWeek`

`Nanoweeks`

  alias of `NanoWeek`

class `PicoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picoweek`

  alias of `PicoWeek`

`Picoweeks`

  alias of `PicoWeek`

class `FemtoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtoweek`

  alias of `FemtoWeek`

`Femtoweeks`

  alias of `FemtoWeek`

class `AttoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attoweek`

  alias of `AttoWeek`

`Attoweeks`

  alias of `AttoWeek`

class `ZeptoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptoweek`

  alias of `ZeptoWeek`

`Zeptoweeks`

  alias of `ZeptoWeek`

class `YoctoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctoweek`

  alias of `YoctoWeek`

`Yoctoweeks`

  alias of `YoctoWeek`

class `Week`

class `Year`

`Years`

  alias of `Year`

class `YottaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottayear`

  alias of `YottaYear`

`Yottayears`

  alias of `YottaYear`

class `ZettaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettayear`

  alias of `ZettaYear`

`Zettayears`

  alias of `ZettaYear`

class `ExaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exayear`

  alias of `ExaYear`

`Exayears`

  alias of `ExaYear`

class `PetaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petayear`

  alias of `PetaYear`

`Petayears`

  alias of `PetaYear`

class `TeraYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Terayear`

  alias of `TeraYear`

`Terayears`

  alias of `TeraYear`

class `GigaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigayear`

  alias of `GigaYear`

`Gigayears`

  alias of `GigaYear`

class `MegaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megayear`

  alias of `MegaYear`

`Megayears`

  alias of `MegaYear`

class `KiloYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kiloyear`

  alias of `KiloYear`

`Kiloyears`

  alias of `KiloYear`

class `HectoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectoyear`

  alias of `HectoYear`

`Hectoyears`

  alias of `HectoYear`

class `DecaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decayear`

  alias of `DecaYear`

`Decayears`

  alias of `DecaYear`

class `DeciYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciyear`

  alias of `DeciYear`

`Deciyears`

  alias of `DeciYear`

class `CentiYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiyear`

  alias of `CentiYear`

`Centiyears`

  alias of `CentiYear`

class `MilliYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliyear`

  alias of `MilliYear`

`Milliyears`

  alias of `MilliYear`

class `MicroYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microyear`

  alias of `MicroYear`

`Microyears`

  alias of `MicroYear`

class `NanoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanoyear`

  alias of `NanoYear`

`Nanoyears`

  alias of `NanoYear`

class `PicoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picoyear`

  alias of `PicoYear`

`Picoyears`

  alias of `PicoYear`

class `FemtoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtoyear`

  alias of `FemtoYear`

`Femtoyears`

  alias of `FemtoYear`

class `AttoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attoyear`

  alias of `AttoYear`

`Attoyears`

  alias of `AttoYear`

class `ZeptoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptoyear`

  alias of `ZeptoYear`

`Zeptoyears`

  alias of `ZeptoYear`

class `YoctoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctoyear`

  alias of `YoctoYear`

`Yoctoyears`

  alias of `YoctoYear`

class `Year`

class `Decade`

`Decades`

  alias of `Decade`

class `YottaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottadecade`

  alias of `YottaDecade`

`Yottadecades`

  alias of `YottaDecade`

class `ZettaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettadecade`

  alias of `ZettaDecade`

`Zettadecades`

  alias of `ZettaDecade`

class `ExaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exadecade`

  alias of `ExaDecade`

`Exadecades`

  alias of `ExaDecade`

class `PetaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petadecade`

  alias of `PetaDecade`

`Petadecades`

  alias of `PetaDecade`

class `TeraDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teradecade`

  alias of `TeraDecade`

`Teradecades`

  alias of `TeraDecade`

class `GigaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigadecade`

  alias of `GigaDecade`

`Gigadecades`

  alias of `GigaDecade`

class `MegaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megadecade`

  alias of `MegaDecade`

`Megadecades`

  alias of `MegaDecade`

class `KiloDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilodecade`

  alias of `KiloDecade`

`Kilodecades`

  alias of `KiloDecade`

class `HectoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectodecade`

  alias of `HectoDecade`

`Hectodecades`

  alias of `HectoDecade`

class `DecaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decadecade`

  alias of `DecaDecade`

`Decadecades`

  alias of `DecaDecade`

class `DeciDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decidecade`

  alias of `DeciDecade`

`Decidecades`

  alias of `DeciDecade`

class `CentiDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centidecade`

  alias of `CentiDecade`

`Centidecades`

  alias of `CentiDecade`

class `MilliDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millidecade`

  alias of `MilliDecade`

`Millidecades`

  alias of `MilliDecade`

class `MicroDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microdecade`

  alias of `MicroDecade`

`Microdecades`

  alias of `MicroDecade`

class `NanoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanodecade`

  alias of `NanoDecade`

`Nanodecades`

  alias of `NanoDecade`

class `PicoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picodecade`

  alias of `PicoDecade`

`Picodecades`

  alias of `PicoDecade`

class `FemtoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtodecade`

  alias of `FemtoDecade`

`Femtodecades`

  alias of `FemtoDecade`

class `AttoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attodecade`

  alias of `AttoDecade`

`Attodecades`

  alias of `AttoDecade`

class `ZeptoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptodecade`

  alias of `ZeptoDecade`

`Zeptodecades`

  alias of `ZeptoDecade`

class `YoctoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctodecade`

  alias of `YoctoDecade`

`Yoctodecades`

  alias of `YoctoDecade`

class `Decade`

class `Century`

`Centuries`

  alias of `Century`

class `YottaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottacentury`

  alias of `YottaCentury`

`Yottacenturies`

  alias of `YottaCentury`

class `ZettaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettacentury`

  alias of `ZettaCentury`

`Zettacenturies`

  alias of `ZettaCentury`

class `ExaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exacentury`

  alias of `ExaCentury`

`Exacenturies`

  alias of `ExaCentury`

class `PetaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petacentury`

  alias of `PetaCentury`

`Petacenturies`

  alias of `PetaCentury`

class `TeraCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teracentury`

  alias of `TeraCentury`

`Teracenturies`

  alias of `TeraCentury`

class `GigaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigacentury`

  alias of `GigaCentury`

`Gigacenturies`

  alias of `GigaCentury`

class `MegaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megacentury`

  alias of `MegaCentury`

`Megacenturies`

  alias of `MegaCentury`

class `KiloCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilocentury`

  alias of `KiloCentury`

`Kilocenturies`

  alias of `KiloCentury`

class `HectoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectocentury`

  alias of `HectoCentury`

`Hectocenturies`

  alias of `HectoCentury`

class `DecaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decacentury`

  alias of `DecaCentury`

`Decacenturies`

  alias of `DecaCentury`

class `DeciCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decicentury`

  alias of `DeciCentury`

`Decicenturies`

  alias of `DeciCentury`

class `CentiCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centicentury`

  alias of `CentiCentury`

`Centicenturies`

  alias of `CentiCentury`

class `MilliCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millicentury`

  alias of `MilliCentury`

`Millicenturies`

  alias of `MilliCentury`

class `MicroCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microcentury`

  alias of `MicroCentury`

`Microcenturies`

  alias of `MicroCentury`

class `NanoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanocentury`

  alias of `NanoCentury`

`Nanocenturies`

  alias of `NanoCentury`

class `PicoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picocentury`

  alias of `PicoCentury`

`Picocenturies`

  alias of `PicoCentury`

class `FemtoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtocentury`

  alias of `FemtoCentury`

`Femtocenturies`

  alias of `FemtoCentury`

class `AttoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attocentury`

  alias of `AttoCentury`

`Attocenturies`

  alias of `AttoCentury`

class `ZeptoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptocentury`

  alias of `ZeptoCentury`

`Zeptocenturies`

  alias of `ZeptoCentury`

class `YoctoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctocentury`

  alias of `YoctoCentury`

`Yoctocenturies`

  alias of `YoctoCentury`

class `Century`

class `Millennium`

`Millennia`

  alias of `Millennium`

class `YottaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottamillennium`

  alias of `YottaMillennium`

`Yottamillennia`

  alias of `YottaMillennium`

class `ZettaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettamillennium`

  alias of `ZettaMillennium`

`Zettamillennia`

  alias of `ZettaMillennium`

class `ExaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Examillennium`

  alias of `ExaMillennium`

`Examillennia`

  alias of `ExaMillennium`

class `PetaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petamillennium`

  alias of `PetaMillennium`

`Petamillennia`

  alias of `PetaMillennium`

class `TeraMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teramillennium`

  alias of `TeraMillennium`

`Teramillennia`

  alias of `TeraMillennium`

class `GigaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigamillennium`

  alias of `GigaMillennium`

`Gigamillennia`

  alias of `GigaMillennium`

class `MegaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megamillennium`

  alias of `MegaMillennium`

`Megamillennia`

  alias of `MegaMillennium`

class `KiloMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilomillennium`

  alias of `KiloMillennium`

`Kilomillennia`

  alias of `KiloMillennium`

class `HectoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectomillennium`

  alias of `HectoMillennium`

`Hectomillennia`

  alias of `HectoMillennium`

class `DecaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decamillennium`

  alias of `DecaMillennium`

`Decamillennia`

  alias of `DecaMillennium`

class `DeciMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decimillennium`

  alias of `DeciMillennium`

`Decimillennia`

  alias of `DeciMillennium`

class `CentiMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centimillennium`

  alias of `CentiMillennium`

`Centimillennia`

  alias of `CentiMillennium`

class `MilliMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millimillennium`

  alias of `MilliMillennium`

`Millimillennia`

  alias of `MilliMillennium`

class `MicroMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Micromillennium`

  alias of `MicroMillennium`

`Micromillennia`

  alias of `MicroMillennium`

class `NanoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanomillennium`

  alias of `NanoMillennium`

`Nanomillennia`

  alias of `NanoMillennium`

class `PicoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picomillennium`

  alias of `PicoMillennium`

`Picomillennia`

  alias of `PicoMillennium`

class `FemtoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtomillennium`

  alias of `FemtoMillennium`

`Femtomillennia`

  alias of `FemtoMillennium`

class `AttoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attomillennium`

  alias of `AttoMillennium`

`Attomillennia`

  alias of `AttoMillennium`

class `ZeptoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptomillennium`

  alias of `ZeptoMillennium`

`Zeptomillennia`

  alias of `ZeptoMillennium`

class `YoctoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctomillennium`

  alias of `YoctoMillennium`

`Yoctomillennia`

  alias of `YoctoMillennium`

class `Millennium`

class `Coulomb`
  classmethod `to`(other)

`Coulombs`

  alias of `Coulomb`

class `YottaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottacoulomb`

  alias of `YottaCoulomb`

`Yottacoulombs`

  alias of `YottaCoulomb`

class `ZettaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettacoulomb`

  alias of `ZettaCoulomb`

`Zettacoulombs`

  alias of `ZettaCoulomb`

class `ExaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exacoulomb`

  alias of `ExaCoulomb`

`Exacoulombs`

  alias of `ExaCoulomb`

class `PetaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petacoulomb`

  alias of `PetaCoulomb`

`Petacoulombs`

  alias of `PetaCoulomb`

class `TeraCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teracoulomb`

  alias of `TeraCoulomb`

`Teracoulombs`

  alias of `TeraCoulomb`

class `GigaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigacoulomb`

  alias of `GigaCoulomb`

`Gigacoulombs`

  alias of `GigaCoulomb`

class `MegaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megacoulomb`

  alias of `MegaCoulomb`

`Megacoulombs`

  alias of `MegaCoulomb`

class `KiloCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilocoulomb`

  alias of `KiloCoulomb`

`Kilocoulombs`

  alias of `KiloCoulomb`

class `HectoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectocoulomb`

  alias of `HectoCoulomb`

`Hectocoulombs`

  alias of `HectoCoulomb`

class `DecaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decacoulomb`

  alias of `DecaCoulomb`

`Decacoulombs`

  alias of `DecaCoulomb`

class `DeciCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decicoulomb`

  alias of `DeciCoulomb`

`Decicoulombs`

  alias of `DeciCoulomb`

class `CentiCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centicoulomb`

  alias of `CentiCoulomb`

`Centicoulombs`

  alias of `CentiCoulomb`

class `MilliCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Millicoulomb`

  alias of `MilliCoulomb`

`Millicoulombs`

  alias of `MilliCoulomb`

class `MicroCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microcoulomb`

  alias of `MicroCoulomb`

`Microcoulombs`

  alias of `MicroCoulomb`

class `NanoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanocoulomb`

  alias of `NanoCoulomb`

`Nanocoulombs`

  alias of `NanoCoulomb`

class `PicoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picocoulomb`

  alias of `PicoCoulomb`

`Picocoulombs`

  alias of `PicoCoulomb`

class `FemtoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtocoulomb`

  alias of `FemtoCoulomb`

`Femtocoulombs`

  alias of `FemtoCoulomb`

class `AttoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attocoulomb`

  alias of `AttoCoulomb`

`Attocoulombs`

  alias of `AttoCoulomb`

class `ZeptoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptocoulomb`

  alias of `ZeptoCoulomb`

`Zeptocoulombs`

  alias of `ZeptoCoulomb`

class `YoctoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctocoulomb`

  alias of `YoctoCoulomb`

`Yoctocoulombs`

  alias of `YoctoCoulomb`

class `AtomicUnitOfElectricCharge`

`AtomicUnitsOfElectricCharge`

  alias of `AtomicUnitOfElectricCharge`

class `YottaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `ZettaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ExaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `PetaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `TeraAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `GigaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `MegaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `KiloAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `HectoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `DecaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DeciAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `CentiAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `MilliAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MicroAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `NanoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `PicoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `FemtoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `AttoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `ZeptoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `YoctoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `AtomicUnitOfElectricCharge`

`AtomicUnitOfCharge`

  alias of `AtomicUnitOfElectricCharge`

`AtomicUnitsOfCharge`

  alias of `AtomicUnitOfElectricCharge`

class `YottaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`YottaAtomicUnitsOfCharge`

  alias of `YottaAtomicUnitOfCharge`

class `ZettaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`ZettaAtomicUnitsOfCharge`

  alias of `ZettaAtomicUnitOfCharge`

class `ExaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`ExaAtomicUnitsOfCharge`

  alias of `ExaAtomicUnitOfCharge`

class `PetaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`PetaAtomicUnitsOfCharge`

  alias of `PetaAtomicUnitOfCharge`

class `TeraAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`TeraAtomicUnitsOfCharge`

  alias of `TeraAtomicUnitOfCharge`

class `GigaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`GigaAtomicUnitsOfCharge`

  alias of `GigaAtomicUnitOfCharge`

class `MegaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`MegaAtomicUnitsOfCharge`

  alias of `MegaAtomicUnitOfCharge`

class `KiloAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`KiloAtomicUnitsOfCharge`

  alias of `KiloAtomicUnitOfCharge`

class `HectoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`HectoAtomicUnitsOfCharge`

  alias of `HectoAtomicUnitOfCharge`

class `DecaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`DecaAtomicUnitsOfCharge`

  alias of `DecaAtomicUnitOfCharge`

class `DeciAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`DeciAtomicUnitsOfCharge`

  alias of `DeciAtomicUnitOfCharge`

class `CentiAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`CentiAtomicUnitsOfCharge`

  alias of `CentiAtomicUnitOfCharge`

class `MilliAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`MilliAtomicUnitsOfCharge`

  alias of `MilliAtomicUnitOfCharge`

class `MicroAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`MicroAtomicUnitsOfCharge`

  alias of `MicroAtomicUnitOfCharge`

class `NanoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`NanoAtomicUnitsOfCharge`

  alias of `NanoAtomicUnitOfCharge`

class `PicoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`PicoAtomicUnitsOfCharge`

  alias of `PicoAtomicUnitOfCharge`

class `FemtoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`FemtoAtomicUnitsOfCharge`

  alias of `FemtoAtomicUnitOfCharge`

class `AttoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`AttoAtomicUnitsOfCharge`

  alias of `AttoAtomicUnitOfCharge`

class `ZeptoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`ZeptoAtomicUnitsOfCharge`

  alias of `ZeptoAtomicUnitOfCharge`

class `YoctoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`YoctoAtomicUnitsOfCharge`

  alias of `YoctoAtomicUnitOfCharge`

class `Gram`
  classmethod `to`(other)

`Grams`

  alias of `Gram`

class `YottaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottagram`

  alias of `YottaGram`

`Yottagrams`

  alias of `YottaGram`

class `ZettaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettagram`

  alias of `ZettaGram`

`Zettagrams`

  alias of `ZettaGram`

class `ExaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exagram`

  alias of `ExaGram`

`Exagrams`

  alias of `ExaGram`

class `PetaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petagram`

  alias of `PetaGram`

`Petagrams`

  alias of `PetaGram`

class `TeraGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teragram`

  alias of `TeraGram`

`Teragrams`

  alias of `TeraGram`

class `GigaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigagram`

  alias of `GigaGram`

`Gigagrams`

  alias of `GigaGram`

class `MegaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megagram`

  alias of `MegaGram`

`Megagrams`

  alias of `MegaGram`

class `KiloGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kilogram`

  alias of `KiloGram`

`Kilograms`

  alias of `KiloGram`

class `HectoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectogram`

  alias of `HectoGram`

`Hectograms`

  alias of `HectoGram`

class `DecaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decagram`

  alias of `DecaGram`

`Decagrams`

  alias of `DecaGram`

class `DeciGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Decigram`

  alias of `DeciGram`

`Decigrams`

  alias of `DeciGram`

class `CentiGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centigram`

  alias of `CentiGram`

`Centigrams`

  alias of `CentiGram`

class `MilliGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milligram`

  alias of `MilliGram`

`Milligrams`

  alias of `MilliGram`

class `MicroGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microgram`

  alias of `MicroGram`

`Micrograms`

  alias of `MicroGram`

class `NanoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanogram`

  alias of `NanoGram`

`Nanograms`

  alias of `NanoGram`

class `PicoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picogram`

  alias of `PicoGram`

`Picograms`

  alias of `PicoGram`

class `FemtoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtogram`

  alias of `FemtoGram`

`Femtograms`

  alias of `FemtoGram`

class `AttoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attogram`

  alias of `AttoGram`

`Attograms`

  alias of `AttoGram`

class `ZeptoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptogram`

  alias of `ZeptoGram`

`Zeptograms`

  alias of `ZeptoGram`

class `YoctoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctogram`

  alias of `YoctoGram`

`Yoctograms`

  alias of `YoctoGram`

class `AtomicMassUnit`

`AtomicMassUnits`

  alias of `AtomicMassUnit`

class `YottaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `ZettaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ExaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `PetaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `TeraAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `GigaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `MegaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `KiloAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `HectoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `DecaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DeciAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `CentiAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `MilliAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MicroAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `NanoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `PicoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `FemtoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `AttoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `ZeptoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `YoctoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`AMU`

  alias of `AtomicMassUnit`

`AMUs`

  alias of `AtomicMassUnit`

class `YottaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`YottaAMUs`

  alias of `YottaAMU`

class `ZettaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`ZettaAMUs`

  alias of `ZettaAMU`

class `ExaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`ExaAMUs`

  alias of `ExaAMU`

class `PetaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`PetaAMUs`

  alias of `PetaAMU`

class `TeraAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`TeraAMUs`

  alias of `TeraAMU`

class `GigaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`GigaAMUs`

  alias of `GigaAMU`

class `MegaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`MegaAMUs`

  alias of `MegaAMU`

class `KiloAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`KiloAMUs`

  alias of `KiloAMU`

class `HectoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`HectoAMUs`

  alias of `HectoAMU`

class `DecaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`DecaAMUs`

  alias of `DecaAMU`

class `DeciAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`DeciAMUs`

  alias of `DeciAMU`

class `CentiAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`CentiAMUs`

  alias of `CentiAMU`

class `MilliAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`MilliAMUs`

  alias of `MilliAMU`

class `MicroAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`MicroAMUs`

  alias of `MicroAMU`

class `NanoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`NanoAMUs`

  alias of `NanoAMU`

class `PicoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`PicoAMUs`

  alias of `PicoAMU`

class `FemtoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`FemtoAMUs`

  alias of `FemtoAMU`

class `AttoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`AttoAMUs`

  alias of `AttoAMU`

class `ZeptoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`ZeptoAMUs`

  alias of `ZeptoAMU`

class `YoctoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`YoctoAMUs`

  alias of `YoctoAMU`

class `AtomicUnitOfMass`

`AtomicUnitsOfMass`

  alias of `AtomicUnitOfMass`

class `YottaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `ZettaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ExaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `PetaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `TeraAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `GigaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `MegaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `KiloAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `HectoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `DecaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DeciAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `CentiAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `MilliAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MicroAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `NanoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `PicoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `FemtoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `AttoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `ZeptoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `YoctoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `CompositeUnit`(numer_units_or_composed, denom_units=None, coeff=1.0)

  A class for composite units, e.g. Joules/Angstrom^2

  `coefficient` = 1.0
  `composed` = None
  `genre` None

    Analog of Unit.genre. Always returns CompositeUnit

  `name` None

    The name of the composite unit, as a product of base units

  `reduced`(using_units=None)

    Reduce the composite unit into the fewest base units possible.

        >>> from grendel.util.units import *
        >>> (Angstroms**2/Bohr).reduced()
        (1.88972612457 Angstrom)
        >>> (Degree / (Bohr**2)).reduced()
        Degree / Bohr**2
        >>> (Degree / (Bohr*Meter)).reduced()
        (5.2917721092e-11 Degree / Bohr**2)

  `to`()

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

exception `UnknownUnitError`(unit1)

  Exception for attempted conversion of something that is not a subclass of Unit

exception `UnitizedObjectError`

  For errors encountered in handling unitized objects

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`has_units`(obj)

  Aliased as hasunits()

`strip_units` None
  Strips the units off of a unitized object
    (or, if the object is not Unitized, just return it). If convert_to is given, convert to these units if obj is Unitized. If assume_units is given, obj is assumed to have the units given by this argument if (and only if) it is not an instance of Unitized.

  Aliased as stripunits()

`stripunits`(*fargs, **fkeywords)

  Alias for strip_units()

class `ValueWithUnits`(value, units)

  A class for encapsulating a physical constant and it’s units.

  units : CompositeUnit or a class with Unit as its metaclass
    The units in which the value of self is to be interpreted
  `convert_to`(units)
  `in_units`(units)
  `units` = None
  `value` None

class `Unitized`

  Abstract base class for things with units. It requires its subclasses to implement the properties ‘value’ and ‘units’. Unitized subclasses are also expected have __mul__, __div__, __truediv__, __pow__, __add__, __sub__, __neg__, __pos__, and __abs__ handle units correctly, when implemented in the given subclass.

  `in_units`(new_units)
  `units` None
  `value` None

exception `MoleculeNotFoundError`(identifier, value, url)

  Raised when a function within the web_getter module cannot find a molecule with the given identifier.

`I_ll`(nballs, nboxes, labels)

`I_llbar`(nballs, nboxes, labels)

`I_lu`(nballs, nboxes, labels)

`I_lubar`(nballs, nboxes, labels)

`I_ul`(nballs, nboxes, labels)

`I_ulbar`(nballs, nboxes, labels)

`I_uu`(nballs, nboxes, labels)

`I_uubar`(nballs, nboxes, labels)

class `Iterable`

class `Iterator`
  `next`()

    Return the next item from the iterator. When exhausted, raise StopIteration

`all_partitions_iter`(sequence, length, allow_zero=True)

  Iterate over all possible partitions of a sequence

  Examples: |

`brace_notation_iter`(sequence_of_sequences)

  This iterates over the brace notation combinations from Allen, et al. Mol. Phys. 89 (1996), 1213-1221 See the explanation of its funtion therein. This is needed for the arbitrary order B tensor formulae.

  Examples: |

      >>> [tuple(''.join(part) for part in parts) for parts in brace_notation_iter(['AB', 'C', 'D'])]
      [('AB', 'C', 'D'), ('AC', 'B', 'D'), ('AD', 'B', 'C'), ('BC', 'A', 'D'), ('BD', 'A', 'C'), ('CD', 'A', 'B')]

class `chain`

  chain(*iterables) –> chain object

  Return a chain object whose .next() method returns elements from the first iterable until it is exhausted, then elements from the next iterable, until all of the iterables are exhausted.

  static `from_iterable`()

    chain.from_iterable(iterable) –> chain object

    Alternate chain() contructor taking a single iterable argument that evaluates lazily.

  `next` None

    x.next() -> the next value, or raise StopIteration

class `combinations_with_replacement`

  combinations_with_replacement(iterable, r) –> combinations_with_replacement object

  Return successive r-length combinations of elements in the iterable allowing individual elements to have successive repeats. combinations_with_replacement(‘ABC’, 2) –> AA AB AC BB BC CC

  `next` None

    x.next() -> the next value, or raise StopIteration

`cummulative_sum`(iterable, initial_value=0, op=<built-in function add>)

  Iterate over the progressive cumulative sum of the items in the iterable.

  Examples: |

      >>> [i for i in cummulative_sum(xrange(6))]
      [0, 1, 3, 6, 10, 15]
      >>> [a for a in cummulative_sum('ABCD', '')]
      ['A', 'AB', 'ABC', 'ABCD']
      >>> [a for a in cummulative_sum(cummulative_sum('ABCD', ''), '')]
      ['A', 'AAB', 'AABABC', 'AABABCABCD']
      >>> [i for i in cummulative_sum(xrange(1,6), 1, op=operator.mul)]
      [1, 2, 6, 24, 120]

class `cycle`

  cycle(iterable) –> cycle object

  Return elements from the iterable until it is exhausted. Then repeat the sequence indefinitely.

  `next` None

    x.next() -> the next value, or raise StopIteration

`first`(iterable, predicate=<function <lambda> at 0xd24ded4>, default_value=<object object at 0x9ad0b08>)

`flattened`(iterable, keep_types=None, debug=False)

  Flatten across all levels of iteration.

  Examples: |

      >>> [f for f in flattened([1,2,3,[4,5,[6]]])]
      [1, 2, 3, 4, 5, 6]
      >>> [f for f in flattened([1,2,3,[4,5,[6],[[xrange(1,17)]]]])]
      [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
      >>> [f for f in flattened([range(1,4),1,2,3,[4,5,[6],[[xrange(1,17)]]]])]
      [1, 2, 3, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
      >>> [f for f in flattened([1, [3, 4], [["hello", ["world"]]], {"yes": True}])]
      [1, 3, 4, 'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', 'y', 'e', 's']
      >>> [f for f in flattened([1, [3, 4], [["hello", ["world"]]], {"yes": True}], keep_types=str)]
      [1, 3, 4, 'hello', 'world', 'yes']
      >>> [f for f in flattened([1, [3, 4], [["hello", ["world"]]], {"yes": True}], keep_types=(str, dict))]
      [1, 3, 4, 'hello', 'world', {'yes': True}]
      >>> [f for f in flattened([1, [3, 4], [["hello", ["world"]]], {"yes": True}], keep_types=(str, dict, list))]
      [[1, [3, 4], [['hello', ['world']]], {'yes': True}]]

`grouper`(n, iterable, fillvalue=None)

  group(3, ‘ABCDEFG’, ‘x’) –> ABC DEF Gxx

class `islice`

  islice(iterable, [start,] stop [, step]) –> islice object

  Return an iterator whose next() method returns selected values from an iterable. If start is specified, will skip all preceding elements; otherwise, start defaults to zero. Step defaults to one. If specified as another value, step determines how many values are skipped between successive calls. Works like a slice() on a list but returns an iterator.

  `next` None

    x.next() -> the next value, or raise StopIteration

class `izip_longest`

  izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) –> izip_longest object

  Return an izip_longest object whose .next() method returns a tuple where the i-th element comes from the i-th iterable argument. The .next() method continues until the longest iterable in the argument sequence is exhausted and then it raises StopIteration. When the shorter iterables are exhausted, the fillvalue is substituted in their place. The fillvalue defaults to None or can be specified by a keyword argument.

  `next` None

    x.next() -> the next value, or raise StopIteration

`labeled_balls_in_labeled_boxes`(balls, box_sizes)

  OVERVIEW

  This function returns a generator that produces all distinct distributions of distinguishable balls among distinguishable boxes, with specified box sizes (capacities). This is a generalization of the most common formulation of the problem, where each box is sufficiently large to accommodate all of the balls.

  CONSTRUCTOR INPUTS

  n: the number of balls

  box_sizes: This argument is a list of length 1 or greater. The length of the list corresponds to the number of boxes. box_sizes[i] is a positive integer that specifies the maximum capacity of the ith box. If box_sizes[i] equals n (or greater), then the ith box can accommodate all n balls and thus effectively has unlimited capacity.

  EXAMPLE

  Issue the following statement issued at the IPython prompt:

  list(labeled_balls_in_labeled_boxes(3,[2,2]))

  The output is as follows:

  [((0, 1), (2,)),
    ((0, 2), (1,)), ((1, 2), (0,)), ((0,), (1, 2)), ((1,), (0, 2)), ((2,), (0, 1))]

`labeled_balls_in_unlabeled_boxes`(balls, box_sizes)

  OVERVIEW

  This function returns a generator that produces all distinct distributions of distinguishable balls among indistinguishable boxes, with specified box sizes (capacities). This is a generalization of the most common formulation of the problem, where each box is sufficiently large to accommodate all of the balls. It might be asked, ‘In what sense are the boxes indistinguishable if they have different capacities?’ The answer is that the box capacities must be considered when distributing the balls, but once the balls have been distributed, the identities of the boxes no longer matter.

  CONSTRUCTOR INPUTS

  n: the number of balls

  box_sizes: This argument is a list of length 1 or greater. The length of the list corresponds to the number of boxes. box_sizes[i] is a positive integer that specifies the maximum capacity of the ith box. If box_sizes[i] equals n (or greater), then the ith box can accommodate all n balls and thus effectively has unlimited capacity.

  NOTE

  For labeled_balls_in_unlabeled_boxes, the order of the elements of the box_sizes list is unimportant because the code will sort it into non- increasing order before any other processing is done.

`last`(iterable, predicate=<function <lambda> at 0xd24df44>, default_value=<object object at 0x9ad0b08>)

`ordered_partitions`(sequence, length)

  see ordered_partitions_iter

`ordered_partitions_iter`(sequence, length)

  This iterates over the P^k,m operator from Allen, et al. Mol. Phys. 89 (1996), 1213-1221 See the explanation of its funtion therein. This is needed for the arbitrary order B tensor formulae.

  Examples: |

      >>> [tuple(''.join(part) for part in parts) for parts in ordered_partitions_iter('ABCD', 2)]
      [('A', 'BCD'), ('AB', 'CD')]
      >>> [tuple(''.join(part) for part in parts) for parts in ordered_partitions_iter('ABCDEF', 3)]
      [('A', 'B', 'CDEF'), ('A', 'BC', 'DEF'), ('AB', 'CD', 'EF')]

`partitioned`(iterable, partitions)

  Iterate over iterable in chunks of sizes given in partitions. If partitions runs out before iterable does, partitions will be cycled (i.e. the next partition size will be the first element of partitions, the following size will be the second, and so on). If there are not enough elements remaining to fill the last partition, the last item yielded will be shorter (just as if a slice running over the end of the list were taken).

  Examples: |

      >>> [''.join(a) for a in partitioned('ABCDEFG', (1, 3, 2, 1))]
      ['A', 'BCD', 'EF', 'G']
      >>> [''.join(a) for a in partitioned('ABCDEFGHIJ', (1, 3, 2, 1))]
      ['A', 'BCD', 'EF', 'G', 'H', 'IJ']
      >>> [''.join(a) for a in partitioned('ABCDEFGHIJK', (2,))]
      ['AB', 'CD', 'EF', 'GH', 'IJ', 'K']
      >>> [''.join(a) for a in partitioned('ABC', (1, 3, 2, 1))]
      ['A', 'BC']
      >>> [i for i in partitioned('abcdef', (0,3))]
      [(), ('a', 'b', 'c'), (), ('d', 'e', 'f'), ()]
      >>> [i for i in partitioned('abcdef', (3,1,0,3))]
      [('a', 'b', 'c'), ('d',), (), ('e', 'f')]
      >>> [i for i in partitioned('abcdef', (3,1,0))]
      [('a', 'b', 'c'), ('d',), (), ('e', 'f')]

`perm_unique_helper`(listunique, result_list, d)

`stutter`(iterable, ntimes)

  repeat each element n times before moving on.

  Examples: |

      >>> [s for s in stutter([1, 2, 3, 4], 3)]
      [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]
      >>> ''.join(a for a in stutter('hello', 2))
      'hheelllloo'

`tee`()

  tee(iterable, n=2) –> tuple of n independent iterators.

class `unique_element`(value, occurrences)

`unique_permutations`(elements)

`unlabeled_balls_in_labeled_boxes`(balls, box_sizes)

  OVERVIEW

  This function returns a generator that produces all distinct distributions of indistinguishable balls among labeled boxes with specified box sizes (capacities). This is a generalization of the most common formulation of the problem, where each box is sufficiently large to accommodate all of the balls, and is an important example of a class of combinatorics problems called ‘weak composition’ problems.

  CONSTRUCTOR INPUTS

  n: the number of balls

  box_sizes: This argument is a list of length 1 or greater. The length of the list corresponds to the number of boxes. box_sizes[i] is a positive integer that specifies the maximum capacity of the ith box. If box_sizes[i] equals n (or greater), then the ith box can accommodate all n balls and thus effectively has unlimited capacity.

  ACKNOWLEDGMENT

  I’d like to thank Chris Rebert for helping me to convert my prototype class-based code into a generator function.

`unlabeled_balls_in_unlabeled_boxes`(balls, box_sizes)

  OVERVIEW

  This function returns a generator that produces all distinct distributions of indistinguishable balls among indistinguishable boxes, with specified box sizes (capacities). This is a generalization of the most common formulation of the problem, where each box is sufficiently large to accommodate all of the balls. It might be asked, ‘In what sense are the boxes indistinguishable if they have different capacities?’ The answer is that the box capacities must be considered when distributing the balls, but once the balls have been distributed, the identities of the boxes no longer matter.

  CONSTRUCTOR INPUTS

  n: the number of balls

  box_sizes: This argument is a list of length 1 or greater. The length of the list corresponds to the number of boxes. box_sizes[i] is a positive integer that specifies the maximum capacity of the ith box. If box_sizes[i] equals n (or greater), then the ith box can accommodate all n balls and thus effectively has unlimited capacity.

  NOTE

  For unlabeled_balls_in_unlabeled_boxes, the order of the elements of the box_sizes list is unimportant because the code will sort it into non- increasing order before any other processing is done.

class `RegexSequence`(main, main_flags=0, start=None, start_flags=0, stop=None, stop_flags=0, last_only=False, require_stop=False, match_function=<function search at 0x55848454>)

  A sequence of regular expressions for parsing a piece of data from a file. The sequence can have optional activation (“start”) and deactivation (“stop”) sequences, and matches are collected from every match of the main regex (or main list of regexes) given. The Ellipsis object may be given in the main sequence (or the start/stop sequences) to indicate that any number of lines may come in between the preceeding and succeding regexes. A RegexSequence.RepeatedRegex object can be used to indicate that a regex can be repeated without invalidating the sequence.

  The RegexSequence object is used by passing a file in line by line to the parse_line() method.

  If the last_only keyword argument is given to the initialization, only the last match (or sequence of matches,
    if a list of regexes is given for the main sequence) is kept
  class `Duplicated`(duplicated, prelude=None, postlude=None, interludes=None, min_dups=None, max_dups=None, flags=None)

    A mechanism for allowing a certain part of a pattern to be duplicated an arbitrary number of times in a line.

    class `Interlude`(regex, frequency, max_repeats=None, offset=None)

      A super-lightweight class to hold an interlude

      `frequency` = None
      `max_repeats` = None
      `offset` = None
      `regex` = None
      `reset`()
    `RegexSequence.Duplicated.``duplicated` = None
    `RegexSequence.Duplicated.``flags` = None
    `RegexSequence.Duplicated.``interludes` = None
    `RegexSequence.Duplicated.``match`(string)
    `RegexSequence.Duplicated.``max_dups` = None
    `RegexSequence.Duplicated.``min_dups` = None
    `RegexSequence.Duplicated.``pattern` None

      Returns the main regex, in order to conform with the Regex class protocol

    `RegexSequence.Duplicated.``postlude` = None
    `RegexSequence.Duplicated.``prelude` = None
    `RegexSequence.Duplicated.``search`(string)
  class `RegexSequence.``RepeatedRegex`(regexes, repeats=None, min_repeats=1, flags=0, exactly=False, greedy=True)

    A regex that may be repeated on multiple consecutive lines without invalidating the sequence. The RepeatedRegex may be repeated an arbitrary (repeats = None, the default) or specified number of times. Currently, the behavior of repeated regexes with exact=False is not stable when multiple (different) RepeatedRegex objects are given consecutively and the number of intervening lines to be matched is fewer than the number of consecutive RepeatedRegex objects minus 1. This is a fairly extreme edge case that is demonstrated in the test suite in test_expected_failures() in the file “test_parsing.py”.

    `exactly` = None
    `greedy` = None
    `in_reset_state`()

      True if reset() would change nothing

    `match`(string)
    `min_repeats` = None
    `okay_to_finish`()
    `regexes` = None
    `repeats` = None
    `reset`()
    `search`(string)
  `RegexSequence.``groups`(flat=True)

    Returns a tuple containing all the match groups from all the matches. If the flat argument is True, (default) the groups are flattened across all matches. If flat is False, the groups are only flattened within a given series (this makes no difference for cases where the main regex is a single expression rather than a list of regexes; in this case a flat list of groups is always returned).

    The name “groups” is meant to correspond roughly with the naming convention in Python’s re module.

  `RegexSequence.``last_only` = None
  `RegexSequence.``main` = None
  `RegexSequence.``match_function` = None
  `RegexSequence.``matches` None

    A (possibly nested) list of the matches collected thus far.

  `RegexSequence.``parse_line`(line)

    Parse a line from a file.

  `RegexSequence.``require_stop` = None
  `RegexSequence.``reset`()

    Reset the regex sequence. Do this, for instance, when you’ve finished parsing one file and need to start parsing another. This gets called by the constructor. Most internal uses of this class should already do this when it is supposed to be done.

  `RegexSequence.``start` = None
  `RegexSequence.``stop` = None

class `Regex`

  Abstract base class for regular expressions. For now, anything that responds to ‘match’, ‘search’, and has the attributes ‘flags’ and ‘pattern’ is considered a Regex object. You can’t instantiate a Regex object; the __new__() just returns re.compile() with the same arguments.

  Examples: |

      >>> import re
      >>> isinstance(re.compile(r'test123'), Regex)
      True
      >>> isinstance(r'test123', Regex)
      False

class `Duplicated`(duplicated, prelude=None, postlude=None, interludes=None, min_dups=None, max_dups=None, flags=None)

  A mechanism for allowing a certain part of a pattern to be duplicated an arbitrary number of times in a line.

  class `Interlude`(regex, frequency, max_repeats=None, offset=None)

    A super-lightweight class to hold an interlude

    `frequency` = None
    `max_repeats` = None
    `offset` = None
    `regex` = None
    `reset`()
  `Duplicated.``duplicated` = None
  `Duplicated.``flags` = None
  `Duplicated.``interludes` = None
  `Duplicated.``match`(string)
  `Duplicated.``max_dups` = None
  `Duplicated.``min_dups` = None
  `Duplicated.``pattern` None

    Returns the main regex, in order to conform with the Regex class protocol

  `Duplicated.``postlude` = None
  `Duplicated.``prelude` = None
  `Duplicated.``search`(string)

`Repeated`

  alias of `RepeatedRegex`

class `RepeatedRegex`(regexes, repeats=None, min_repeats=1, flags=0, exactly=False, greedy=True)

  A regex that may be repeated on multiple consecutive lines without invalidating the sequence. The RepeatedRegex may be repeated an arbitrary (repeats = None, the default) or specified number of times. Currently, the behavior of repeated regexes with exact=False is not stable when multiple (different) RepeatedRegex objects are given consecutively and the number of intervening lines to be matched is fewer than the number of consecutive RepeatedRegex objects minus 1. This is a fairly extreme edge case that is demonstrated in the test suite in test_expected_failures() in the file “test_parsing.py”.

  `exactly` = None
  `greedy` = None
  `in_reset_state`()

    True if reset() would change nothing

  `match`(string)
  `min_repeats` = None
  `okay_to_finish`()
  `regexes` = None
  `repeats` = None
  `reset`()
  `search`(string)

class `working_directory`(dir, permissions=0, create=False)

  Change to a certain working directory for the execution of a block of code, then change back upon (any kind of) exit.

`divisors`(n)

  Generate the factors of an integer.

  Examples: |

      >>> for i in divisors(12): print i
      ...
      1
      2
      3
      4
      6
      12

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

`chop`(tens, thresh=1e-14)

  Round off near-integer values (within thresh) to integers for each value in the Tensor.

`chopped`(tens, thresh=1e-14)

  Same as chop, but does not modify the original and instead returns a copy.

class `ComputableTensor`

  A tensor with elements that can be computed as needed. .. warning:

  > Using this class is a very bad idea. It makes development a nightmare. Don’t do it.

  `compute_function` = None
  `fill`()
  `hasitem`(item)

    Returns True if and only if the tensor has the item without having to compute it. Same as item in self.

  `is_sentinal_value`(test_val)
  `sentinal_value` = None

class `Vector`

  Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to `numpy.ndarray`. Special functionality for vectors gets implemented here.

  Examples: |

  - Multiplication *

      >>> from grendel.gmath import Matrix, Vector
      >>> Matrix([1,2],[3,4]) * Vector([5,6])
      Vector([ 17.,  39.])

  - Cartesian components *

      >>> vtwo = Vector(1., 2.)
      >>> vthree = Vector(1.11, 2.22, 3.33)
      >>> vtwo[0]
      1.0
      >>> vtwo.x
      1.0
      >>> vtwo.y == vtwo[1]
      True
      >>> vthree[2] == vthree.z
      True
      >>> # Can also set:
      >>> vtwo.x = -1
      >>> vtwo.y = -2
      >>> vtwo
      Vector([-1., -2.])
      >>> vthree.x, vthree.z, vthree.y = 1, 3, 2
      >>> vthree
      Vector([ 1.,  2.,  3.])

  `column` None

    Return the column-vector version of self, which is currently implemented as a Matrix object. Note that matrix-vector multiplication will work without getting column first, so don’t use this unless you have a good reason to do so.

  `cross`(other)

    Returns cross product of self with other. Wrapper to numpy.cross

  `normalized`()

    Same as normalize(), but does not modify self

  `reshape`(newshape, order='C')

    Overrides the numpy.ndarray reshape function to make things make sense.

    Examples: |

        >>> v = Vector([1,2,3,4])
        >>> v.reshape((2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])
        >>> # `v` is unchanged:
        >>> v
        Vector([ 1.,  2.,  3.,  4.])
        >>> v.reshape((4,1))
        Matrix([[ 1.],
                [ 2.],
                [ 3.],
                [ 4.]])
        >>> import numpy as np
        >>> np.reshape(v, (2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])

  `x` None

    The x component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `y` None

    The y component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `z` None

    The z component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not three dimensional

`cross`(v1, v2, *args, **kwargs)

  Wrapper to numpy.cross which viewcasts the result as a Vector if the first two arguments are Vector objects

  Examples: |

      >>> cross( Vector(1, 2, 3), Vector(4, 5, 6) )
      Vector([-3.,  6., -3.])
      >>> # Can also be called as a method of Vector
      >>> Vector(1, 2, 3).cross( Vector(4, 5, 6) )
      Vector([-3.,  6., -3.])

`magnitude`(v)

  Wrapper for Vector.magnitude()

  Examples: |

      >>> magnitude(Vector(3.0, 4.0))
      5.0

`norm`(v)

  Wrapper for Vector.magnitude()

  Examples: |

      >>> magnitude(Vector(3.0, 4.0))
      5.0

class `Matrix`

  > Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to

  `numpy.ndarray`. Special functionality for vectors gets implemented here.

  `I` None
  `col_iter` None
  `cols` None
  `columns` None
  classmethod `diagonal`(iterable)
  `eigensystem`()

    Wrapper to numpy.eigh and numpy.eig for symmetric and non-symmetric matrices, respectively. Note that the eigenvectors are column vectors in the returned matrix.

  classmethod `identity`(n)
  `is_hermitian`()
  `is_square`()
  `is_symmetric`()
  `ncols` None

    Number of columns that self has

  `nrows` None

    Number of rows that self has

  `row_iter` None
  `rows` None
  `sqrt_matrix`()
  `symmetrized`()
  `transformed`(other)

`rotate_point_about_axis`(point, axis, angle)

  Returns the Cartesian vector point rotated about axis by angle

  Source: http://en.wikipedia.org/wiki/Rotation_matrix

`angle_between_vectors`(a, b)

  Returns the angle between the two vectors, in radians

class `IndexRange`(*args, **kwargs)

  Allows for the definition of special indices that cover specific ranges and subranges of Tensor axes in einstein summations.

  Examples: |

      >>> IndexRange.clear_known_ranges()  # Don't do this in your program; this is just for the doctest
      >>> p = IndexRange('p,q,r,s', 5).with_subranges(
      ...   IndexRange('i,j,k,l', 0, 2),
      ...   IndexRange('a,b,c,d', 2, 5)
      ... )
      >>> p
      <IndexRange object covering slice 0:5 represented by indices ['p', 'q', 'r', 's']>
      >>> p.subranges[0]
      <IndexRange object covering slice 0:2 represented by indices ['i', 'j', 'k', 'l']>
      >>> p.subranges[1]
      <IndexRange object covering slice 2:5 represented by indices ['a', 'b', 'c', 'd']>
      >>> prime = IndexRange["m, m',m''", 10, "m range"].with_subranges(
      ...            IndexRange["n,n',n''", ..., 6, "n range"],
      ...            IndexRange["o,o',o''", 6, ...]
      ... )
      >>> prime
      <IndexRange named 'm range' represented by indices ['m', 'm'', 'm''']>
      >>> prime.subranges[0]
      <IndexRange named 'n range' represented by indices ['n', 'n'', 'n''']>
      >>> prime.subranges[1]
      <IndexRange object covering slice 6:10 represented by indices ['o', 'o'', 'o''']>

  `add_subrange`(subrange)

    Add a subrange to the list of subranges for self. Note that this returns subrange (with subrange.parent modified) to allow for a ‘pass-through’ like usage (see examples below)

    Examples: |

        >>> IndexRange.reset_ranges()
        >>> p = IndexRange('p,q,r,s', 4, name="orbital space")
        >>> # Convenient "pass-through" usage for saving subranges:
        >>> i = p.add_subrange(IndexRange('i,j,k,l', 0, 2, name="occupied space"))
        >>> a = p.add_subrange(IndexRange('a,b,c,d',2,4))
        >>> a
        <IndexRange object covering slice 2:4 represented by indices ['a', 'b', 'c', 'd']>
        >>> p.subranges[0]
        <IndexRange named 'occupied space' represented by indices ['i', 'j', 'k', 'l']>
        >>> p.subranges[1]
        <IndexRange object covering slice 2:4 represented by indices ['a', 'b', 'c', 'd']>
        >>> a.parent
        <IndexRange named 'orbital space' represented by indices ['p', 'q', 'r', 's']>

  `begin_index` None
  classmethod `begin_indexing_context`(new_global_set)
  classmethod `clear_known_ranges`()

    Clears the known ranges. Use with care and only if you’re sure you know what you’re doing!

  `end_index` None
  classmethod `end_indexing_context`(context_to_end=None)
  `global_index_range_set` = <grendel.gmath.einsum_indices.IndexRangeSet object at 0xd26ffcc>
  `index_range_set` = None
  `indices` = None
  `name` = None
  `parent` None
  classmethod `reset_ranges`()

    Clears the known ranges. Use with care and only if you’re sure you know what you’re doing!

  classmethod `set_global_index_range_set`(new_global_set)
  classmethod `set_indexing_context`(new_global_set)
  `size` None
  `slice` None
  `slice_in`(parent_range)

    Gets the slice of parent_range represented by self (parent_range need not be a direct parent of self, but it should be a parent. See is_subrange())

    Examples: |

        >>> IndexRange.reset_ranges()
        >>> p = IndexRange('p,q,r,s',4)
        >>> i = p.add_subrange(IndexRange('i,j,k,l',0,2))
        >>> a = p.add_subrange(IndexRange('a,b,c,d',2,4))
        >>> a.slice_in(p)
        slice(2, 4, None)

  `subranges` = None
  classmethod `unset_global_index_range_set`(context_to_end=None)
  `with_subranges`(*subranges)

    Basically the same thing as calling add_subrange() multiple times, except returns self instead of the subrange, allowing for a different syntax (see below)

    Examples: |

        >>> IndexRange.reset_ranges()
        >>> orb = DeclareIndexRange('p,q,r,s', 10, name="Orbital space").with_subranges(
        ...           DeclareIndexRange('i,j,k,l', 0, 3, name="Occupied space").with_subranges(
        ...               DeclareIndexRange("i*,j*,k*,l*", 0, 1, name="Core"),
        ...               DeclareIndexRange("i',j',k',l'", 1, 3)
        ...           ),
        ...           DeclareIndexRange('a,b,c,d', 3, 10, name="Virtual space")
        ...       )
        >>> orb
        <IndexRange named 'Orbital space' represented by indices ['p', 'q', 'r', 's']>
        >>> len(orb.subranges)
        2
        >>> len(orb.subranges[0].subranges)
        2

`DeclareIndexRange`(indices, begin_index_or_size, end_index=None, name=None, **kwargs)

  Alias for IndexRange constructor that more accurately describes what is actually going on.

class `IndexRangeSet`
  `known_ranges` = None

`IndexingContext`

  alias of `IndexRangeSet`

`issubrange`(child_range, parent_range)

  Returns True if child_range is parent_range or child_range is a child of parent_range (analogous to isinstance from the python standard library)

`is_subrange`(child_range, parent_range)

  Returns True if child_range is parent_range or child_range is a child of parent_range (analogous to isinstance from the python standard library)

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `Differentiable`

  Abstract base class for things that you are allowed to take derivatives of.

  `shape` None
  `value` None

    The value of the differentiable property. If this function is not overridden, assume that self can be added and subtracted, as well as multiplied by a float.

class `FiniteDifferenceDerivative`(*args, **kwargs)

  An arbitrary finite difference derivative with respect to k FiniteDifferenceVariable instances (not necessarily distinct) of a FiniteDifferenceFunction of an arbitrary number of FiniteDifferenceVariable instances whose output is a Differentiable instance. Ideally, the derivative can be calculated to an arbitrary order of robustness in the displacement, though in practice not all orders may be implemented yet.

  `compute`()
  `formula` = None
  `formulas` = []
  `function` = None
  `generated_single_variable_formulas` = {}
  `needed_increments` None
  `orders` = None
  classmethod `precompute_single_variable`(max_derivative, max_order, forward=False)

    Save a little bit of time by prepopulating the single variable displacement formulas dictionary up to max_derivative and max_order. If forward is True, the forward formulas are precomputed instead of the central ones.

  `target_robustness` = None
  `value` None
  `variables` = None

class `FiniteDifferenceFormula`(orders, robustness, pairs, forward=False)

  A formula for a given finite difference derivative.

  `CENTRAL` = 0
  `FORWARD` = 1
  `coefficients` = None
  `direction` = None
  `is_central`()
  `is_forward`()
  `needed_displacements` None
  `order` None
  `orders` = None
  `robustness` = None

class `FiniteDifferenceFunction`
  `deltas_for_variables`(vars)

    The displacement amounts for each of the variables.

  `value_for_displacements`(pairs)

    Get a value for the displacement corresponding to the (variable, number of deltas) pairs given in the argument pairs

  `variables` None

    The list of FiniteDifferenceVariable instances on which the function depends.

class `FiniteDifferenceVariable`

class `FloatShell`

class `Fraction`

  This class implements rational numbers.

  In the two-argument form of the constructor, Fraction(8, 6) will produce a rational number equivalent to 4/3. Both arguments must be Rational. The numerator defaults to 0 and the denominator defaults to 1 so that Fraction(3) == 3 and Fraction() == 0.

  Fractions can also be constructed from:

  > - numeric strings similar to those accepted by the float constructor (for example, ‘-2.3’ or ‘1e10’)
  > - strings of the form ‘123/456’
  > - float and Decimal instances
  > - other Rational instances (including integers)

  `denominator` None
  classmethod `from_decimal`(dec)

    Converts a finite Decimal instance to a rational number, exactly.

  classmethod `from_float`(f)

    Converts a finite float to a rational number, exactly.

    Beware that Fraction.from_float(0.3) != Fraction(3, 10).

  `limit_denominator`(max_denominator=1000000)

    Closest Fraction to self with denominator at most max_denominator.

        >>> Fraction('3.141592653589793').limit_denominator(10)
        Fraction(22, 7)
        >>> Fraction('3.141592653589793').limit_denominator(100)
        Fraction(311, 99)
        >>> Fraction(4321, 8765).limit_denominator(10000)
        Fraction(4321, 8765)

  `numerator` None

class `IterableOf`(types)
  `arg_type_okay`(arg)
  `collection_type`

    alias of `Iterable`

  `types` = None

`ReadOnlyAttribute` None

  A read-only attribute. See SpecialAttribute for initialization variables standard to all SpecialAttribute subclasses.

  Attributes: |

  error_text : str
    The text for the error raised when setting of the attribute is attempted. Defaults to “cannot set read-only attribute”

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

class `abstractproperty`

  A decorator indicating abstract properties.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract properties are overridden. The abstract properties can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractproperty def my_abstract_property(self):

  >   > ...

  This defines a read-only property; you can also define a read-write abstract property using the ‘long’ form of property declaration:

  > class C:
  >   __metaclass__ = ABCMeta def getx(self): ... def setx(self, value): ... x = abstractproperty(getx, setx)

`add`()

  add(a, b) – Same as a + b.

class `attrgetter`

  attrgetter(attr, ...) –> attrgetter object

  Return a callable object that fetches the given attribute(s) from its operand. After f = attrgetter(‘name’), the call f(r) returns r.name. After g = attrgetter(‘name’, ‘date’), the call g(r) returns (r.name, r.date). After h = attrgetter(‘name.first’, ‘name.last’), the call h(r) returns (r.name.first, r.name.last).

`fornberg_coefficient_generator`(M, N, x0, *alpha)

  From Fornberg, Bengt. Mathematics of Computation 51 (1988), p. 699-706 M: “the order of the highest derivative we wish to approximate” N: given “a set of N + 1 grid points” x0: the point at which we wish to take the derivative alpha: alpha_i is the ith grid point

`generate_single_variable_formulas`(max_derivative, max_order, forward=False)

class `groupby`

  groupby(iterable[, keyfunc]) -> create an iterator which returns (key, sub-iterator) grouped by each value of key(value).

  `next` None

    x.next() -> the next value, or raise StopIteration

`indented`(instr, nspaces=4)

  Aliased as indent()

`listify_args`(*args, **kwargs)

  A simple way to accept arguments that can be an Iterable or a bunch of arguments that should be treated as a single Iterable. (This method is pretty trivial, but I find myself doing it a whole lot.) The reason you can’t just use list() for this purpose is that if an Iterable is given as the only argument, list(args) will return a list of Iterables rather than a single Iterable.

  Examples: |

      >>> def test(*args):
      ...     return listify_args(*args)
      ...
      >>> test(1,2,3)
      [1, 2, 3]
      >>> test([1,2,3])
      [1, 2, 3]
      >>> test([1,2,3], 4)
      [[1, 2, 3], 4]
      >>> test("1,2,3", 4)
      ['1,2,3', 4]
      >>> test("1,2,3")
      ['1,2,3']

`load_formulas`()

`mul`()

  mul(a, b) – Same as a * b.

`typechecked` None

  Type checking for functions and methods.

`with_flexible_arguments`(required=None, optional=None, what_to_call_it=None)

  Allows the creation of functions with case insensative, alternately named keyword arguments.

  Examples: |

      >>> @with_flexible_arguments(
      ...     required=[
      ...         ('name', 'greet', 'name_to_greet'),
      ...         ('from_where', 'source')
      ...     ],
      ...     optional=[
      ...         ('greeting', 'hello_phrase', 'salutation'),
      ...         ('message',)
      ...     ]
      ... )
      ... def say_hello(name, from_where, greeting='Hello', message=''):
      ...     print(greeting + ', ' + name + ', from ' + from_where + '!' + message)
      ...
      >>> say_hello('moon', 'Earth')
      Hello, moon, from Earth!
      >>> say_hello('world', source='the moon')
      Hello, world, from the moon!
      >>> say_hello(source='France', name_to_greet='visitor', salutation='Bonjour')
      Bonjour, visitor, from France!
      >>> say_hello('earthlings', 'outer space', 'Greetings', message='  We come in peace!')
      Greetings, earthlings, from outer space!  We come in peace!

class `CachedProperty`(func)

  Decorator for properties with cached return values. The decorator creates a property that stores the return value of the method call in a variable named _[func_name] (where [func_name] is the name of the function).

  Examples: |

      >>> class Factorializer(object):
      ...
      ...    n = None
      ...
      ...    def __init__(self, n):
      ...        self.n = n
      ...
      ...    @CachedProperty
      ...    def thirty_plus_n_fact(self):
      ...        ret_val = 1
      ...        for i in xrange(2, self.n + 31):
      ...            ret_val *= i
      ...        return ret_val
      ...
      >>> f = Factorializer(3000)
      >>> # Takes some time...
      >>> var = f.thirty_plus_n_fact
      >>> # Should take no time...
      >>> for i in xrange(100):
      ...     var = f.thirty_plus_n_fact
      ...
      >>> # Be careful... Remember to invalidate the cache when the appropriate variables are updated...
      >>> f.n = 2500
      >>> # Takes no time but gives the wrong answer:
      >>> var = f.thirty_plus_n_fact
      >>> # Invalidate the cache:
      >>> f._thirty_plus_n_fact = None
      >>> # This should take some time again, but now it will get the right answer
      >>> var = f.thirty_plus_n_fact

  `cached_var_name` = None
  `func` = None
  `name` = None

class `Coordinate`

  Abstract base class for a general coordinate of a Molecule.

  > Coordinate`s are the components in which `Molecule`s are represented. The most important thing about `Coordinate`s is that they are immutible, like Python’s `str and tuple classes.[#f1]_ Let me say that again a bit louder:

  > Note

  > All coordinates are immutable!

  > Coordinate instances are typically (though not always) associated with a Representation, accessible through the parent read-only attribute. Coordinate instances that do not have a parent associated with them are called “orphaned” coordinates, and can be identified using the is_orphaned() instance method. Even orphaned coordinates must have a Molecule associated with them in one way or another. This happens in one of three ways: 1. If the Coordinate is not orphaned, then parent‘s molecule attribute is used. Note

  > > that in this case, the Coordinate protocol requires the Coordinate‘s constituant atoms to have a parent molecule that is exactly the same instance as parent‘s molecule attribute. (If you aren’t doing something weird, this shouldn’t be an issue).

  > 2. If the Coordinate is orphaned, it still must be composed of one or more Atom instances, accessible through the atoms attribute. These Atom`s may themselves be orphaned, but if they are not, the first non-orphaned `Atom‘s parent is used. Note that if one Atom is non-orphaned, the Coordinate protocol requires that all of them must not be orphaned (i. e. the Coordinate constructor enforces this when sanity_checking_enabled is True)
  > 3. If the Coordinate is orphaned and all of its Atom`s are also orphaned (as is the case, for instance, with `Coordinate instances created for the purpose of finite difference B tensor computation), the Coordinate‘s base_analog attribute may be set to a Coordinate instance whose constituate Atom instances correspond to the derived Coordinate‘s atoms’ base_atom attributes. In this case, the base_analog‘s molecule attribute is used, though it should be utilized for index translation purposes only, since the positions of the atoms in the base molecule will not correspond to the positions of the Coordinate‘s atoms. (The base_analog, in turn, may be an orphaned coordinate of this third type, in which case that coordinate’s base_analog will be used, and so on recursively.)
  > 4. If the Coordinate is orphaned and no base_analog is given, then all of the atoms must have a base_atom that either has a parent_molecule or also has a base_atom defined (and so on so that a base_atom eventually has a parent_molecule somewhere up the line). In this case, the Coordinate protocol requires that all the atoms refer to the same Molecule obtained in this manner. Coordinates created in the course of analytic computation of B tensors fall into this catagory.

  > Because all Coordinate`s may be austensibly associated with a `Molecule instance in one way or another, there are two different ways to index various tensor properties of a Coordinate: the Molecule‘s indices (3 * natoms total indices) and the Coordinate‘s indexing scheme (3 * len(coord.atoms) total indices, where coord is a Coordinate instance). The internal indexing scheme makes a lot more sense in many instances, (see the documentation of Coordinate.atoms for a simple example), but for determining properties of the whole molecule, we need to use the Molecule‘s indexing scheme. All of this should be handled seemlessly behind the scenes, but it’s a good distinction to be aware of.

  > Coordinate has a number of methods that can be used to get the value of a Coordinate in a particular scenario. They hierarchically call each other to determine the value of the Coordinate. The basic scheme is as follows:

  value”]
    value_for_molecule [label=”value_for_molecule()”] value_for_molecule_matrix [label=”value_for_molecule_matrix()”,style=dotted]; value_for_molecule_matrix-> value_for_positions [style=dotted,label=”(only InternalCoordinate)”] value_for_positions -> value_for_xyz [style=dotted,label=”(only SimpleInternalCoordinate)”]; value_for_positions [label=”@classmethod
  value_for_positions()”,style=dotted];
    value_for_xyz [label=”@classmethod
  value_for_xyz()”,style=dotted];

    > }

    The reason for this relatively complex hierarchy is that there are instances in which I have needed each variety for some reason or another. Nodes with dotted borders must be implemented in the relevant subclasses: SimpleInternalCoordinate subclasses must implement value_for_xyz, InternalCoordinate subclasses must implement value_for_positions, and Coordinate subclasses must implement value_for_molecule_matrix().

    TODO: write this part

    Footnotes

    [1]

    Since Python doesn’t really have private attributes, you could in theory change some of the attributes of a Coordinate instance after it is created; the designation of “immutible” here merely means that the class is not guarenteed to work if you do. While it’s technically more of a “please don’t” than a “you can’t”, I for one will not be held responsible for your code not working if you do something like that, and the way these private attributes are used and changed is not guarenteed to stay the same between different versions. Bottom line: just don’t do it. If you don’t know what I’m talking about, you’re probably okay. Just don’t access or modify any attributes that start with a single underscore (you should never do this anyway from outside of a class).

  `atom_indices` None

    The indices of the atom(s) the Coordinate depends on in the Molecule the Coordinate depends on.

    This is guarenteed to work whether or not the Coordinate is orphaned. For each of the various possible Coordinate–Molecule relationships detailed in the Coordinate class documentation, the reason the method works is as follows: 1. If the Coordinate is not orphaned, then the Coordinate‘s atoms must not be

    > orphaned (the Coordinate constructor enforces this when sanity_checking_enabled is True). Thus, each of the atoms must be non-orphaned and thus have an index.

    2. If the Coordinate is orphaned and at least one atom is non-orphaned, all atoms must be non-orphaned (enforced by the Coordinate protocol). Thus, we can use the non-orphaned atoms’ indices.
    3. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is not None, the atoms must have the base_atom attribute set to the corresponding atom in the Coordinate‘s base_analog. Thus, the Atom‘s base_atom‘s index is used.
    4. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is None, then each atom must have a base_atom somewhere down the line that has a parent and thus an index; this atom’s index is used.

    Use this carefully. Don’t ever retrieve an atom’s position by its index in the parent molecule, since that atom may not be the same instance (or even in the same position) as the Coordinate‘s atom.

  `atoms` None

    List of the Atom instances that the Coordinate depends on. In the case of a CartesianCoordinate, for instance, this is trivially one Atom, but in the case of other coordinates it can be much more substantial. In the case of a NormalCoordinate, this is all the atoms in the parent Molecule.

    The presence of an atoms list is essential to establish an internal indexing scheme that can be converted to the indexing scheme of the parent molecule. Besides making the B tensor code much more managable, the use of an internal indexing scheme make Coordinate instances much more self-contained, making “orphaned” coordinates much more viable. Consider the following example:

        >>> from grendel.util.units import Degrees
        >>> from grendel.coordinates.bond_angle import BondAngle
        >>> ba = BondAngle(
        ...     Atom('O', [0.0, 0.0, 0.0]),
        ...     Atom('H', [0.0, 1.0, 0.0]),
        ...     Atom('H', [0.0, 0.0, 1.0]),
        ...     units=Degrees
        ... )
        >>> round(ba.value)
        90.

    If orphaned coordinates where not allowed to exist, we would have to create a Molecule instance containing those three atoms, construct an InternalRepresentation containing the BondAngle instance (which would need to be a valid, complete representation, a non-trivial task in the general case), pair that InternalRepresentation instance with the Molecule instance, get the right Coordinate instance from the InternalRepresentation corresponding to the BondAngle we want, and then get that coordinate’s value. If all of the coordinate’s complicated methods were not implemented in terms of the Coordinate’s own indexing scheme, it would have to have all of this structure in place just to get a value.

    Note

    Since all Coordinate`s depend on `Atom`s and `Atom`s are not immutible, a `Coordinate`s `value and other properties such as its b_vector can change even if the Coordinate itself cannot. The one way around this is to specify freeze_value as True in the Coordinate‘s constructor. If that is done, the value of the Coordinate will not change over the life of the instance, even if the positions of the constituant atoms does change (so if you use this, make sure you know what you are doing). This behavior is useful, for instance, in the use of CartesianRepresentation`s as “snapshots” of a `Molecule instance to be used for the parsing of a particular RepresentationDependentProperty.

  `base_analog` None

    Analogous Coordinate object on the base molecule, if self is a Coordinate on a displaced Molecule, or the Coordinate from which an orphaned displaced Coordinate was created, if the coordinate was created this way.

  `coordinate_symbol` = 'chi'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` None

    Every coordinate must define a reasonable default amount for a finite displacement of that kind of coordinate. This should be a class attribute.

  `generate_name`(one_based=True)
  `in_units`(new_units)
  `index` None
  `internal_indices_for`()
  `is_orphaned`()

    Whether or not the Coordinate instance has a parent Representation

  `iter_molecule_indices`()

    Default implementation for coordinates dependent on atoms directly (basically anything but a CartesianCoordinate or some sort of symmetrized cartesian coordinate).

  `molecule` None

    The molecule associated with the Coordinate.

    Note

    The molecule’s atoms’ positions may not correspond to the positions of the atoms the coordinate describes. See the class documentation for Coordinate for details.

  `molecule_indices` = None
  `molecule_indices_for`()
  `name` = None
  `orphaned_copy`(**kwargs)
  `parent` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `parent_representation` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `units` None

    The units in which the coordinate’s value is expressed.

  `value` None
  `value_for_molecule`(mol)
  `value_for_molecule_matrix`(mat)

    Get the value of the coordinate for the XYZ matrix mat, which is a (self.molecule.natoms) by 3 matrix. In other words, the matrix argument uses the parent Molecule‘s indexing scheme, not the Coordinate‘s own indexing scheme.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  `value_for_positions`(*pos)
  `value_with_units` None

class `Derivative`(coords)

  Encapsulates the concept of an (energy) derivative with respect to a coordinate. This may later be expanded (in a backwards compatible manner) to include other types of derivatives, e.g. dipole moment derivatives

  Attributes: |

  of : subclass of Differentiable
    The entity that the derivative is being taken of (usually the energy of the molecule, but can be anything that is a subclass of the abstract base class Differentiable
  value : float
    The value of the derivative, in the units given by units
  units : CompositeUnit or some class with a Unit metaclass
    The units of the derivative
  coords : list of Coordinate
    The coordinate(s) that the derivative is taken with respect to (multiple if the derivative is higher than first order)
  `coords` = None
  `molecule` None

    The Molecule object to which the coordinate

  `of` = None
  `order` None

    The order of the derivative. ‘1’ indicates first derivative, ‘2’ indicates second derivative, etc.

  `units` = None
  `value` = None

class `ComputableTensor`

  A tensor with elements that can be computed as needed. .. warning:

  > Using this class is a very bad idea. It makes development a nightmare. Don’t do it.

  `compute_function` = None
  `fill`()
  `hasitem`(item)

    Returns True if and only if the tensor has the item without having to compute it. Same as item in self.

  `is_sentinal_value`(test_val)
  `sentinal_value` = None

class `Coordinate`

  Abstract base class for a general coordinate of a Molecule.

  > Coordinate`s are the components in which `Molecule`s are represented. The most important thing about `Coordinate`s is that they are immutible, like Python’s `str and tuple classes.[#f1]_ Let me say that again a bit louder:

  > Note

  > All coordinates are immutable!

  > Coordinate instances are typically (though not always) associated with a Representation, accessible through the parent read-only attribute. Coordinate instances that do not have a parent associated with them are called “orphaned” coordinates, and can be identified using the is_orphaned() instance method. Even orphaned coordinates must have a Molecule associated with them in one way or another. This happens in one of three ways: 1. If the Coordinate is not orphaned, then parent‘s molecule attribute is used. Note

  > > that in this case, the Coordinate protocol requires the Coordinate‘s constituant atoms to have a parent molecule that is exactly the same instance as parent‘s molecule attribute. (If you aren’t doing something weird, this shouldn’t be an issue).

  > 2. If the Coordinate is orphaned, it still must be composed of one or more Atom instances, accessible through the atoms attribute. These Atom`s may themselves be orphaned, but if they are not, the first non-orphaned `Atom‘s parent is used. Note that if one Atom is non-orphaned, the Coordinate protocol requires that all of them must not be orphaned (i. e. the Coordinate constructor enforces this when sanity_checking_enabled is True)
  > 3. If the Coordinate is orphaned and all of its Atom`s are also orphaned (as is the case, for instance, with `Coordinate instances created for the purpose of finite difference B tensor computation), the Coordinate‘s base_analog attribute may be set to a Coordinate instance whose constituate Atom instances correspond to the derived Coordinate‘s atoms’ base_atom attributes. In this case, the base_analog‘s molecule attribute is used, though it should be utilized for index translation purposes only, since the positions of the atoms in the base molecule will not correspond to the positions of the Coordinate‘s atoms. (The base_analog, in turn, may be an orphaned coordinate of this third type, in which case that coordinate’s base_analog will be used, and so on recursively.)
  > 4. If the Coordinate is orphaned and no base_analog is given, then all of the atoms must have a base_atom that either has a parent_molecule or also has a base_atom defined (and so on so that a base_atom eventually has a parent_molecule somewhere up the line). In this case, the Coordinate protocol requires that all the atoms refer to the same Molecule obtained in this manner. Coordinates created in the course of analytic computation of B tensors fall into this catagory.

  > Because all Coordinate`s may be austensibly associated with a `Molecule instance in one way or another, there are two different ways to index various tensor properties of a Coordinate: the Molecule‘s indices (3 * natoms total indices) and the Coordinate‘s indexing scheme (3 * len(coord.atoms) total indices, where coord is a Coordinate instance). The internal indexing scheme makes a lot more sense in many instances, (see the documentation of Coordinate.atoms for a simple example), but for determining properties of the whole molecule, we need to use the Molecule‘s indexing scheme. All of this should be handled seemlessly behind the scenes, but it’s a good distinction to be aware of.

  > Coordinate has a number of methods that can be used to get the value of a Coordinate in a particular scenario. They hierarchically call each other to determine the value of the Coordinate. The basic scheme is as follows:

  value”]
    value_for_molecule [label=”value_for_molecule()”] value_for_molecule_matrix [label=”value_for_molecule_matrix()”,style=dotted]; value_for_molecule_matrix-> value_for_positions [style=dotted,label=”(only InternalCoordinate)”] value_for_positions -> value_for_xyz [style=dotted,label=”(only SimpleInternalCoordinate)”]; value_for_positions [label=”@classmethod
  value_for_positions()”,style=dotted];
    value_for_xyz [label=”@classmethod
  value_for_xyz()”,style=dotted];

    > }

    The reason for this relatively complex hierarchy is that there are instances in which I have needed each variety for some reason or another. Nodes with dotted borders must be implemented in the relevant subclasses: SimpleInternalCoordinate subclasses must implement value_for_xyz, InternalCoordinate subclasses must implement value_for_positions, and Coordinate subclasses must implement value_for_molecule_matrix().

    TODO: write this part

    Footnotes

    [2]

    Since Python doesn’t really have private attributes, you could in theory change some of the attributes of a Coordinate instance after it is created; the designation of “immutible” here merely means that the class is not guarenteed to work if you do. While it’s technically more of a “please don’t” than a “you can’t”, I for one will not be held responsible for your code not working if you do something like that, and the way these private attributes are used and changed is not guarenteed to stay the same between different versions. Bottom line: just don’t do it. If you don’t know what I’m talking about, you’re probably okay. Just don’t access or modify any attributes that start with a single underscore (you should never do this anyway from outside of a class).

  `atom_indices` None

    The indices of the atom(s) the Coordinate depends on in the Molecule the Coordinate depends on.

    This is guarenteed to work whether or not the Coordinate is orphaned. For each of the various possible Coordinate–Molecule relationships detailed in the Coordinate class documentation, the reason the method works is as follows: 1. If the Coordinate is not orphaned, then the Coordinate‘s atoms must not be

    > orphaned (the Coordinate constructor enforces this when sanity_checking_enabled is True). Thus, each of the atoms must be non-orphaned and thus have an index.

    2. If the Coordinate is orphaned and at least one atom is non-orphaned, all atoms must be non-orphaned (enforced by the Coordinate protocol). Thus, we can use the non-orphaned atoms’ indices.
    3. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is not None, the atoms must have the base_atom attribute set to the corresponding atom in the Coordinate‘s base_analog. Thus, the Atom‘s base_atom‘s index is used.
    4. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is None, then each atom must have a base_atom somewhere down the line that has a parent and thus an index; this atom’s index is used.

    Use this carefully. Don’t ever retrieve an atom’s position by its index in the parent molecule, since that atom may not be the same instance (or even in the same position) as the Coordinate‘s atom.

  `atoms` None

    List of the Atom instances that the Coordinate depends on. In the case of a CartesianCoordinate, for instance, this is trivially one Atom, but in the case of other coordinates it can be much more substantial. In the case of a NormalCoordinate, this is all the atoms in the parent Molecule.

    The presence of an atoms list is essential to establish an internal indexing scheme that can be converted to the indexing scheme of the parent molecule. Besides making the B tensor code much more managable, the use of an internal indexing scheme make Coordinate instances much more self-contained, making “orphaned” coordinates much more viable. Consider the following example:

        >>> from grendel.util.units import Degrees
        >>> from grendel.coordinates.bond_angle import BondAngle
        >>> ba = BondAngle(
        ...     Atom('O', [0.0, 0.0, 0.0]),
        ...     Atom('H', [0.0, 1.0, 0.0]),
        ...     Atom('H', [0.0, 0.0, 1.0]),
        ...     units=Degrees
        ... )
        >>> round(ba.value)
        90.

    If orphaned coordinates where not allowed to exist, we would have to create a Molecule instance containing those three atoms, construct an InternalRepresentation containing the BondAngle instance (which would need to be a valid, complete representation, a non-trivial task in the general case), pair that InternalRepresentation instance with the Molecule instance, get the right Coordinate instance from the InternalRepresentation corresponding to the BondAngle we want, and then get that coordinate’s value. If all of the coordinate’s complicated methods were not implemented in terms of the Coordinate’s own indexing scheme, it would have to have all of this structure in place just to get a value.

    Note

    Since all Coordinate`s depend on `Atom`s and `Atom`s are not immutible, a `Coordinate`s `value and other properties such as its b_vector can change even if the Coordinate itself cannot. The one way around this is to specify freeze_value as True in the Coordinate‘s constructor. If that is done, the value of the Coordinate will not change over the life of the instance, even if the positions of the constituant atoms does change (so if you use this, make sure you know what you are doing). This behavior is useful, for instance, in the use of CartesianRepresentation`s as “snapshots” of a `Molecule instance to be used for the parsing of a particular RepresentationDependentProperty.

  `base_analog` None

    Analogous Coordinate object on the base molecule, if self is a Coordinate on a displaced Molecule, or the Coordinate from which an orphaned displaced Coordinate was created, if the coordinate was created this way.

  `coordinate_symbol` = 'chi'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` None

    Every coordinate must define a reasonable default amount for a finite displacement of that kind of coordinate. This should be a class attribute.

  `generate_name`(one_based=True)
  `in_units`(new_units)
  `index` None
  `internal_indices_for`()
  `is_orphaned`()

    Whether or not the Coordinate instance has a parent Representation

  `iter_molecule_indices`()

    Default implementation for coordinates dependent on atoms directly (basically anything but a CartesianCoordinate or some sort of symmetrized cartesian coordinate).

  `molecule` None

    The molecule associated with the Coordinate.

    Note

    The molecule’s atoms’ positions may not correspond to the positions of the atoms the coordinate describes. See the class documentation for Coordinate for details.

  `molecule_indices` = None
  `molecule_indices_for`()
  `name` = None
  `orphaned_copy`(**kwargs)
  `parent` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `parent_representation` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `units` None

    The units in which the coordinate’s value is expressed.

  `value` None
  `value_for_molecule`(mol)
  `value_for_molecule_matrix`(mat)

    Get the value of the coordinate for the XYZ matrix mat, which is a (self.molecule.natoms) by 3 matrix. In other words, the matrix argument uses the parent Molecule‘s indexing scheme, not the Coordinate‘s own indexing scheme.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  `value_for_positions`(*pos)
  `value_with_units` None

class `DerivativeCollection`

  A collection of derivatives with indices that are coordinates in a given representation.

  `coordinate` = None
  `coordinates` None
  `coords` None
  `einsum_index` = None
  `first_dimension_different` = None
  `for_order`()

    Return the Tensor object corresponding to the `order`th order derivative.

  `has_order`(order)
  `representation` = None
  `secondary_representation` = None
  `tensor_kwargs` = None
  `tensors` = None
  `uncomputed` = None

class `DerivativeTensor`
  `collection` = None
  `compute_function` = None

class `MatrixFormatter`(**kwargs)
  `col_label_format` None
  `col_label_format_leader` = None
  `col_label_width` = None
  `float_digits` = 4
  `float_format` None
  `float_format_leader` = ' '
  `float_type_string` = 'g'
  `float_width` = 10
  `format`(matrix, labels=None)
  `label_format_leader` = '^'
  `label_overflow_character` = 'X'
  `label_width` = 10
  `line_width` = 120
  `name` = None
  `one_based` = True
  classmethod `quick_format`(matrix, labels=None, **kwargs)
  `row_label_format` None
  `row_label_format_leader` = None
  `row_label_width` = None
  `width_overflow_character` = '*'

class `NonstringIterable`

  An Iterable that is not an instance of basestring

class `Number`

  All numbers inherit from this class.

  If you just want to check if an argument x is a number, without caring what kind, use isinstance(x, Number).

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `RepresentationDependentTensor`
  `first_dimension_different` = None
  `formatted_string`(**kwargs)
  `in_representation`(new_rep)
  `permutational_symmetry` = None
  `representation` None
  `secondary_representation` None
  `value` None

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

class `TensorFormatter`(**kwargs)
  `format`(tensor, labels=None)
  `symmetric` = False

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`indent`(*fargs, **fkeywords)

  Alias for indented()

class `permutations`

  permutations(iterable[, r]) –> permutations object

  Return successive r-length permutations of elements in the iterable.

  permutations(range(3), 2) –> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)

  `next` None

    x.next() -> the next value, or raise StopIteration

`shortstr`(*fargs, **fkeywords)

  Alias for short_str()

`typechecked` None

  Type checking for functions and methods.

class `ComputationDetails`(**kwargs)

  Encapsulates specifics about how the calculation was/is to be carried out, such as level of theory, basis set, program, etc. Can be subclassed for specific programs which may require special detail setting methods.

  `available_pairs`(*keys)
  classmethod `from_details`(details)

    Effectively clones details. Used internally for making a details into a ComputationDetails subclass

  classmethod `is_compatible_details`(requested, details_computed_with)
  `is_subset_of`(other)
  `is_superset_of`(other)
  `keywordify`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `keywordify_if_available`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `required_details` = []

class `Coordinate`

  Abstract base class for a general coordinate of a Molecule.

  > Coordinate`s are the components in which `Molecule`s are represented. The most important thing about `Coordinate`s is that they are immutible, like Python’s `str and tuple classes.[#f1]_ Let me say that again a bit louder:

  > Note

  > All coordinates are immutable!

  > Coordinate instances are typically (though not always) associated with a Representation, accessible through the parent read-only attribute. Coordinate instances that do not have a parent associated with them are called “orphaned” coordinates, and can be identified using the is_orphaned() instance method. Even orphaned coordinates must have a Molecule associated with them in one way or another. This happens in one of three ways: 1. If the Coordinate is not orphaned, then parent‘s molecule attribute is used. Note

  > > that in this case, the Coordinate protocol requires the Coordinate‘s constituant atoms to have a parent molecule that is exactly the same instance as parent‘s molecule attribute. (If you aren’t doing something weird, this shouldn’t be an issue).

  > 2. If the Coordinate is orphaned, it still must be composed of one or more Atom instances, accessible through the atoms attribute. These Atom`s may themselves be orphaned, but if they are not, the first non-orphaned `Atom‘s parent is used. Note that if one Atom is non-orphaned, the Coordinate protocol requires that all of them must not be orphaned (i. e. the Coordinate constructor enforces this when sanity_checking_enabled is True)
  > 3. If the Coordinate is orphaned and all of its Atom`s are also orphaned (as is the case, for instance, with `Coordinate instances created for the purpose of finite difference B tensor computation), the Coordinate‘s base_analog attribute may be set to a Coordinate instance whose constituate Atom instances correspond to the derived Coordinate‘s atoms’ base_atom attributes. In this case, the base_analog‘s molecule attribute is used, though it should be utilized for index translation purposes only, since the positions of the atoms in the base molecule will not correspond to the positions of the Coordinate‘s atoms. (The base_analog, in turn, may be an orphaned coordinate of this third type, in which case that coordinate’s base_analog will be used, and so on recursively.)
  > 4. If the Coordinate is orphaned and no base_analog is given, then all of the atoms must have a base_atom that either has a parent_molecule or also has a base_atom defined (and so on so that a base_atom eventually has a parent_molecule somewhere up the line). In this case, the Coordinate protocol requires that all the atoms refer to the same Molecule obtained in this manner. Coordinates created in the course of analytic computation of B tensors fall into this catagory.

  > Because all Coordinate`s may be austensibly associated with a `Molecule instance in one way or another, there are two different ways to index various tensor properties of a Coordinate: the Molecule‘s indices (3 * natoms total indices) and the Coordinate‘s indexing scheme (3 * len(coord.atoms) total indices, where coord is a Coordinate instance). The internal indexing scheme makes a lot more sense in many instances, (see the documentation of Coordinate.atoms for a simple example), but for determining properties of the whole molecule, we need to use the Molecule‘s indexing scheme. All of this should be handled seemlessly behind the scenes, but it’s a good distinction to be aware of.

  > Coordinate has a number of methods that can be used to get the value of a Coordinate in a particular scenario. They hierarchically call each other to determine the value of the Coordinate. The basic scheme is as follows:

  value”]
    value_for_molecule [label=”value_for_molecule()”] value_for_molecule_matrix [label=”value_for_molecule_matrix()”,style=dotted]; value_for_molecule_matrix-> value_for_positions [style=dotted,label=”(only InternalCoordinate)”] value_for_positions -> value_for_xyz [style=dotted,label=”(only SimpleInternalCoordinate)”]; value_for_positions [label=”@classmethod
  value_for_positions()”,style=dotted];
    value_for_xyz [label=”@classmethod
  value_for_xyz()”,style=dotted];

    > }

    The reason for this relatively complex hierarchy is that there are instances in which I have needed each variety for some reason or another. Nodes with dotted borders must be implemented in the relevant subclasses: SimpleInternalCoordinate subclasses must implement value_for_xyz, InternalCoordinate subclasses must implement value_for_positions, and Coordinate subclasses must implement value_for_molecule_matrix().

    TODO: write this part

    Footnotes

    [3]

    Since Python doesn’t really have private attributes, you could in theory change some of the attributes of a Coordinate instance after it is created; the designation of “immutible” here merely means that the class is not guarenteed to work if you do. While it’s technically more of a “please don’t” than a “you can’t”, I for one will not be held responsible for your code not working if you do something like that, and the way these private attributes are used and changed is not guarenteed to stay the same between different versions. Bottom line: just don’t do it. If you don’t know what I’m talking about, you’re probably okay. Just don’t access or modify any attributes that start with a single underscore (you should never do this anyway from outside of a class).

  `atom_indices` None

    The indices of the atom(s) the Coordinate depends on in the Molecule the Coordinate depends on.

    This is guarenteed to work whether or not the Coordinate is orphaned. For each of the various possible Coordinate–Molecule relationships detailed in the Coordinate class documentation, the reason the method works is as follows: 1. If the Coordinate is not orphaned, then the Coordinate‘s atoms must not be

    > orphaned (the Coordinate constructor enforces this when sanity_checking_enabled is True). Thus, each of the atoms must be non-orphaned and thus have an index.

    2. If the Coordinate is orphaned and at least one atom is non-orphaned, all atoms must be non-orphaned (enforced by the Coordinate protocol). Thus, we can use the non-orphaned atoms’ indices.
    3. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is not None, the atoms must have the base_atom attribute set to the corresponding atom in the Coordinate‘s base_analog. Thus, the Atom‘s base_atom‘s index is used.
    4. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is None, then each atom must have a base_atom somewhere down the line that has a parent and thus an index; this atom’s index is used.

    Use this carefully. Don’t ever retrieve an atom’s position by its index in the parent molecule, since that atom may not be the same instance (or even in the same position) as the Coordinate‘s atom.

  `atoms` None

    List of the Atom instances that the Coordinate depends on. In the case of a CartesianCoordinate, for instance, this is trivially one Atom, but in the case of other coordinates it can be much more substantial. In the case of a NormalCoordinate, this is all the atoms in the parent Molecule.

    The presence of an atoms list is essential to establish an internal indexing scheme that can be converted to the indexing scheme of the parent molecule. Besides making the B tensor code much more managable, the use of an internal indexing scheme make Coordinate instances much more self-contained, making “orphaned” coordinates much more viable. Consider the following example:

        >>> from grendel.util.units import Degrees
        >>> from grendel.coordinates.bond_angle import BondAngle
        >>> ba = BondAngle(
        ...     Atom('O', [0.0, 0.0, 0.0]),
        ...     Atom('H', [0.0, 1.0, 0.0]),
        ...     Atom('H', [0.0, 0.0, 1.0]),
        ...     units=Degrees
        ... )
        >>> round(ba.value)
        90.

    If orphaned coordinates where not allowed to exist, we would have to create a Molecule instance containing those three atoms, construct an InternalRepresentation containing the BondAngle instance (which would need to be a valid, complete representation, a non-trivial task in the general case), pair that InternalRepresentation instance with the Molecule instance, get the right Coordinate instance from the InternalRepresentation corresponding to the BondAngle we want, and then get that coordinate’s value. If all of the coordinate’s complicated methods were not implemented in terms of the Coordinate’s own indexing scheme, it would have to have all of this structure in place just to get a value.

    Note

    Since all Coordinate`s depend on `Atom`s and `Atom`s are not immutible, a `Coordinate`s `value and other properties such as its b_vector can change even if the Coordinate itself cannot. The one way around this is to specify freeze_value as True in the Coordinate‘s constructor. If that is done, the value of the Coordinate will not change over the life of the instance, even if the positions of the constituant atoms does change (so if you use this, make sure you know what you are doing). This behavior is useful, for instance, in the use of CartesianRepresentation`s as “snapshots” of a `Molecule instance to be used for the parsing of a particular RepresentationDependentProperty.

  `base_analog` None

    Analogous Coordinate object on the base molecule, if self is a Coordinate on a displaced Molecule, or the Coordinate from which an orphaned displaced Coordinate was created, if the coordinate was created this way.

  `coordinate_symbol` = 'chi'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` None

    Every coordinate must define a reasonable default amount for a finite displacement of that kind of coordinate. This should be a class attribute.

  `generate_name`(one_based=True)
  `in_units`(new_units)
  `index` None
  `internal_indices_for`()
  `is_orphaned`()

    Whether or not the Coordinate instance has a parent Representation

  `iter_molecule_indices`()

    Default implementation for coordinates dependent on atoms directly (basically anything but a CartesianCoordinate or some sort of symmetrized cartesian coordinate).

  `molecule` None

    The molecule associated with the Coordinate.

    Note

    The molecule’s atoms’ positions may not correspond to the positions of the atoms the coordinate describes. See the class documentation for Coordinate for details.

  `molecule_indices` = None
  `molecule_indices_for`()
  `name` = None
  `orphaned_copy`(**kwargs)
  `parent` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `parent_representation` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `units` None

    The units in which the coordinate’s value is expressed.

  `value` None
  `value_for_molecule`(mol)
  `value_for_molecule_matrix`(mat)

    Get the value of the coordinate for the XYZ matrix mat, which is a (self.molecule.natoms) by 3 matrix. In other words, the matrix argument uses the parent Molecule‘s indexing scheme, not the Coordinate‘s own indexing scheme.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  `value_for_positions`(*pos)
  `value_with_units` None

class `Differentiable`

  Abstract base class for things that you are allowed to take derivatives of.

  `shape` None
  `value` None

    The value of the differentiable property. If this function is not overridden, assume that self can be added and subtracted, as well as multiplied by a float.

class `Displacement`

  Encapsulates a displacement from a base molecule.

  Attributes: |

  base_molecule : Molecule
    The Molecule object that the displacement is relative to.
  representation : Representation
    The Representation object that the displacements are values in.
  disp_vect : Vector
    The displacement amounts in the given representation. (e.g. disp_vect[i] corresponds to the amount of displacement of the i`th `Coordinate in representation)
  `base_molecule` = None
  `desired_values` = None
  `disp_vect` = None
  `displaced_molecule` None

    The displaced molecule object resulting from applying self to Molecule

  `displaced_representation` None

    The displaced molecule object resulting from applying self to Molecule

  classmethod `from_increments`(increments, rep, deltas=None)
  classmethod `get_default_deltas`(rep)
  `increments`(deltas=None)
  `max_iterations` = 35
  `representation` = None
  `tolerance` = 1e-12

class `DisplacementManager`

  A function (in the finite_difference.FiniteDifferenceFunction sense) that can get values for displacements of some base molecule.

  `base_molecule` None
  `deltas` = None
  `deltas_for_variables`(vars)
  `details` = None
  `differentiable` = None
  `displaced_molecules` None
  `displacement_for`(increments)
  `displacements` = None
  `output_type` = None
  `representation` = None
  `value_for_displacements`(pairs)
  `variables` = None

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `FiniteDifferenceFunction`
  `deltas_for_variables`(vars)

    The displacement amounts for each of the variables.

  `value_for_displacements`(pairs)

    Get a value for the displacement corresponding to the (variable, number of deltas) pairs given in the argument pairs

  `variables` None

    The list of FiniteDifferenceVariable instances on which the function depends.

class `FiniteDifferenceVariable`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

class `Iterable`

class `LegacyXMLResultGetter`(comparison_representation, *files)
  `can_get_property_for_molecule`(molecule, property, details=None)
  `files` = None
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property_for_molecule`(molecule, property, details=None, verbose=True)
  `properties` = None
  `properties_for_molecules` = None

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

`ReadOnlyAttribute` None

  A read-only attribute. See SpecialAttribute for initialization variables standard to all SpecialAttribute subclasses.

  Attributes: |

  error_text : str
    The text for the error raised when setting of the attribute is attempted. Defaults to “cannot set read-only attribute”

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `RepresentationDependentProperty`(molecule, units=None, details=None)

  A property whose value is dependent on a given representation of the molecule.

  `get_value`(*args, **kwargs)
  `molecule` None
  `representation` None
  `representation_getter` = None

class `SequenceOf`(types)
  `collection_type`

    alias of `Sequence`

`compatible_units`(unit1, unit2)

  Aliased as iscompatible()

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`indented`(instr, nspaces=4)

  Aliased as indent()

`typechecked` None

  Type checking for functions and methods.

class `CartesianRepresentation`

  A representations of a molecule in Cartesian coordinates. Since Atom objects already have Cartesian vectors associated with them, this class mostly consists of helper functions and convenience (accessor) functions that make CartesianRepresentation compatible with the parent Representation class.

  `add_atom`(atom)

    Add an atom to the representation by creating a CartesianCoordinate object cooresponding to the atom.

  `add_coordinate_copy`()

    Add a CartesianCoordinate to the representation.

  `atom`(number)

    Convenience method for accessing atoms. Returns self.molecule.atoms[number]

  `atom_coords`(atom_or_index)
  `atoms` None

    Convenience property for referencing the atoms list in the molecule associated with self.

  `copy_with_molecule`(molecule)
  `displaced_by`(disp, tol=None, maxiter=None)
  `frozen_copy`()
  `index`(atom_or_coordinate)

    Returns the index of the parameter atom in the representation self.

    Parameters: |

    atom_or_coordinate : Atom or CartesianCoordinate
      The atom or cartesian coordinate to obtain the index of. If an atom is passed in, the index of the X coordinate of the atom is returned.

    Raises: |

    IndexError
      If the parameter atom_or_coordinate is not found.
  `iter_atom_coords`(with_atom=False)
  `l_xyz` None

    Returns the value of the representation as a light vector

  `refresh_atom`()

    Renew the coordinates for an atom to coincide with the atom’s current position

  static `same_atom_indices`(index)
  `transform_forcefield`()
  `transform_tensor`()

class `DerivativeCollection`

  A collection of derivatives with indices that are coordinates in a given representation.

  `coordinate` = None
  `coordinates` None
  `coords` None
  `einsum_index` = None
  `first_dimension_different` = None
  `for_order`()

    Return the Tensor object corresponding to the `order`th order derivative.

  `has_order`(order)
  `representation` = None
  `secondary_representation` = None
  `tensor_kwargs` = None
  `tensors` = None
  `uncomputed` = None

class `DerivativeTensor`
  `collection` = None
  `compute_function` = None

class `DisplacementManager`

  A function (in the finite_difference.FiniteDifferenceFunction sense) that can get values for displacements of some base molecule.

  `base_molecule` None
  `deltas` = None
  `deltas_for_variables`(vars)
  `details` = None
  `differentiable` = None
  `displaced_molecules` None
  `displacement_for`(increments)
  `displacements` = None
  `output_type` = None
  `representation` = None
  `value_for_displacements`(pairs)
  `variables` = None

class `Energy`(molecule, units=None, details=None)

  The energy of a molecule.

  `default_units`

    alias of `Wavenumber`

class `FiniteDifferenceDerivative`(*args, **kwargs)

  An arbitrary finite difference derivative with respect to k FiniteDifferenceVariable instances (not necessarily distinct) of a FiniteDifferenceFunction of an arbitrary number of FiniteDifferenceVariable instances whose output is a Differentiable instance. Ideally, the derivative can be calculated to an arbitrary order of robustness in the displacement, though in practice not all orders may be implemented yet.

  `compute`()
  `formula` = None
  `formulas` = []
  `function` = None
  `generated_single_variable_formulas` = {}
  `needed_increments` None
  `orders` = None
  classmethod `precompute_single_variable`(max_derivative, max_order, forward=False)

    Save a little bit of time by prepopulating the single variable displacement formulas dictionary up to max_derivative and max_order. If forward is True, the forward formulas are precomputed instead of the central ones.

  `target_robustness` = None
  `value` None
  `variables` = None

class `FiniteDifferenceForceField`(max_analytic_order=0, property=<class 'grendel.chemistry.molecular_properties.Energy'>, deltas=None, details=None, run_now=False, queue=None, robustness=2, **kwargs)
  `all_computations` None
  `computation_queue` = None
  `computed_property` = None
  `displacement_manager` = None
  `fill`()
  `fill_order`(order)
  `filled_for_order` = None
  `for_order`()
  `max_analytic_order` = None
  `needed_computations` None
  `robustness` = None

class `ForceField`(representation, max_order, property=<class 'grendel.chemistry.molecular_properties.Energy'>, property_units=None)
  `base_molecule` None
  `for_order`()
  `in_representation`(representation)
  `max_order` = None
  `molecular_property` = None
  `property_units` = None

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

`PropertyDerivative`(*fargs, **fkeywords)

  Alias for MolecularPropertyDerivative()

class `RepresentationDependentTensor`
  `first_dimension_different` = None
  `formatted_string`(**kwargs)
  `in_representation`(new_rep)
  `permutational_symmetry` = None
  `representation` None
  `secondary_representation` None
  `value` None

class `permutations`

  permutations(iterable[, r]) –> permutations object

  Return successive r-length permutations of elements in the iterable.

  permutations(range(3), 2) –> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)

  `next` None

    x.next() -> the next value, or raise StopIteration

`symmetric_product`

  alias of `combinations_with_replacement`

`typechecked` None

  Type checking for functions and methods.

class `AngularUnit`

  General superclass for all angular units

  `default`

    alias of `Degree`

  `reference_unit`

    alias of `Degree`

class `CachedProperty`(func)

  Decorator for properties with cached return values. The decorator creates a property that stores the return value of the method call in a variable named _[func_name] (where [func_name] is the name of the function).

  Examples: |

      >>> class Factorializer(object):
      ...
      ...    n = None
      ...
      ...    def __init__(self, n):
      ...        self.n = n
      ...
      ...    @CachedProperty
      ...    def thirty_plus_n_fact(self):
      ...        ret_val = 1
      ...        for i in xrange(2, self.n + 31):
      ...            ret_val *= i
      ...        return ret_val
      ...
      >>> f = Factorializer(3000)
      >>> # Takes some time...
      >>> var = f.thirty_plus_n_fact
      >>> # Should take no time...
      >>> for i in xrange(100):
      ...     var = f.thirty_plus_n_fact
      ...
      >>> # Be careful... Remember to invalidate the cache when the appropriate variables are updated...
      >>> f.n = 2500
      >>> # Takes no time but gives the wrong answer:
      >>> var = f.thirty_plus_n_fact
      >>> # Invalidate the cache:
      >>> f._thirty_plus_n_fact = None
      >>> # This should take some time again, but now it will get the right answer
      >>> var = f.thirty_plus_n_fact

  `cached_var_name` = None
  `func` = None
  `name` = None

class `CartesianRepresentation`

  A representations of a molecule in Cartesian coordinates. Since Atom objects already have Cartesian vectors associated with them, this class mostly consists of helper functions and convenience (accessor) functions that make CartesianRepresentation compatible with the parent Representation class.

  `add_atom`(atom)

    Add an atom to the representation by creating a CartesianCoordinate object cooresponding to the atom.

  `add_coordinate_copy`()

    Add a CartesianCoordinate to the representation.

  `atom`(number)

    Convenience method for accessing atoms. Returns self.molecule.atoms[number]

  `atom_coords`(atom_or_index)
  `atoms` None

    Convenience property for referencing the atoms list in the molecule associated with self.

  `copy_with_molecule`(molecule)
  `displaced_by`(disp, tol=None, maxiter=None)
  `frozen_copy`()
  `index`(atom_or_coordinate)

    Returns the index of the parameter atom in the representation self.

    Parameters: |

    atom_or_coordinate : Atom or CartesianCoordinate
      The atom or cartesian coordinate to obtain the index of. If an atom is passed in, the index of the X coordinate of the atom is returned.

    Raises: |

    IndexError
      If the parameter atom_or_coordinate is not found.
  `iter_atom_coords`(with_atom=False)
  `l_xyz` None

    Returns the value of the representation as a light vector

  `refresh_atom`()

    Renew the coordinates for an atom to coincide with the atom’s current position

  static `same_atom_indices`(index)
  `transform_forcefield`()
  `transform_tensor`()

class `Coordinate`

  Abstract base class for a general coordinate of a Molecule.

  > Coordinate`s are the components in which `Molecule`s are represented. The most important thing about `Coordinate`s is that they are immutible, like Python’s `str and tuple classes.[#f1]_ Let me say that again a bit louder:

  > Note

  > All coordinates are immutable!

  > Coordinate instances are typically (though not always) associated with a Representation, accessible through the parent read-only attribute. Coordinate instances that do not have a parent associated with them are called “orphaned” coordinates, and can be identified using the is_orphaned() instance method. Even orphaned coordinates must have a Molecule associated with them in one way or another. This happens in one of three ways: 1. If the Coordinate is not orphaned, then parent‘s molecule attribute is used. Note

  > > that in this case, the Coordinate protocol requires the Coordinate‘s constituant atoms to have a parent molecule that is exactly the same instance as parent‘s molecule attribute. (If you aren’t doing something weird, this shouldn’t be an issue).

  > 2. If the Coordinate is orphaned, it still must be composed of one or more Atom instances, accessible through the atoms attribute. These Atom`s may themselves be orphaned, but if they are not, the first non-orphaned `Atom‘s parent is used. Note that if one Atom is non-orphaned, the Coordinate protocol requires that all of them must not be orphaned (i. e. the Coordinate constructor enforces this when sanity_checking_enabled is True)
  > 3. If the Coordinate is orphaned and all of its Atom`s are also orphaned (as is the case, for instance, with `Coordinate instances created for the purpose of finite difference B tensor computation), the Coordinate‘s base_analog attribute may be set to a Coordinate instance whose constituate Atom instances correspond to the derived Coordinate‘s atoms’ base_atom attributes. In this case, the base_analog‘s molecule attribute is used, though it should be utilized for index translation purposes only, since the positions of the atoms in the base molecule will not correspond to the positions of the Coordinate‘s atoms. (The base_analog, in turn, may be an orphaned coordinate of this third type, in which case that coordinate’s base_analog will be used, and so on recursively.)
  > 4. If the Coordinate is orphaned and no base_analog is given, then all of the atoms must have a base_atom that either has a parent_molecule or also has a base_atom defined (and so on so that a base_atom eventually has a parent_molecule somewhere up the line). In this case, the Coordinate protocol requires that all the atoms refer to the same Molecule obtained in this manner. Coordinates created in the course of analytic computation of B tensors fall into this catagory.

  > Because all Coordinate`s may be austensibly associated with a `Molecule instance in one way or another, there are two different ways to index various tensor properties of a Coordinate: the Molecule‘s indices (3 * natoms total indices) and the Coordinate‘s indexing scheme (3 * len(coord.atoms) total indices, where coord is a Coordinate instance). The internal indexing scheme makes a lot more sense in many instances, (see the documentation of Coordinate.atoms for a simple example), but for determining properties of the whole molecule, we need to use the Molecule‘s indexing scheme. All of this should be handled seemlessly behind the scenes, but it’s a good distinction to be aware of.

  > Coordinate has a number of methods that can be used to get the value of a Coordinate in a particular scenario. They hierarchically call each other to determine the value of the Coordinate. The basic scheme is as follows:

  value”]
    value_for_molecule [label=”value_for_molecule()”] value_for_molecule_matrix [label=”value_for_molecule_matrix()”,style=dotted]; value_for_molecule_matrix-> value_for_positions [style=dotted,label=”(only InternalCoordinate)”] value_for_positions -> value_for_xyz [style=dotted,label=”(only SimpleInternalCoordinate)”]; value_for_positions [label=”@classmethod
  value_for_positions()”,style=dotted];
    value_for_xyz [label=”@classmethod
  value_for_xyz()”,style=dotted];

    > }

    The reason for this relatively complex hierarchy is that there are instances in which I have needed each variety for some reason or another. Nodes with dotted borders must be implemented in the relevant subclasses: SimpleInternalCoordinate subclasses must implement value_for_xyz, InternalCoordinate subclasses must implement value_for_positions, and Coordinate subclasses must implement value_for_molecule_matrix().

    TODO: write this part

    Footnotes

    [4]

    Since Python doesn’t really have private attributes, you could in theory change some of the attributes of a Coordinate instance after it is created; the designation of “immutible” here merely means that the class is not guarenteed to work if you do. While it’s technically more of a “please don’t” than a “you can’t”, I for one will not be held responsible for your code not working if you do something like that, and the way these private attributes are used and changed is not guarenteed to stay the same between different versions. Bottom line: just don’t do it. If you don’t know what I’m talking about, you’re probably okay. Just don’t access or modify any attributes that start with a single underscore (you should never do this anyway from outside of a class).

  `atom_indices` None

    The indices of the atom(s) the Coordinate depends on in the Molecule the Coordinate depends on.

    This is guarenteed to work whether or not the Coordinate is orphaned. For each of the various possible Coordinate–Molecule relationships detailed in the Coordinate class documentation, the reason the method works is as follows: 1. If the Coordinate is not orphaned, then the Coordinate‘s atoms must not be

    > orphaned (the Coordinate constructor enforces this when sanity_checking_enabled is True). Thus, each of the atoms must be non-orphaned and thus have an index.

    2. If the Coordinate is orphaned and at least one atom is non-orphaned, all atoms must be non-orphaned (enforced by the Coordinate protocol). Thus, we can use the non-orphaned atoms’ indices.
    3. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is not None, the atoms must have the base_atom attribute set to the corresponding atom in the Coordinate‘s base_analog. Thus, the Atom‘s base_atom‘s index is used.
    4. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is None, then each atom must have a base_atom somewhere down the line that has a parent and thus an index; this atom’s index is used.

    Use this carefully. Don’t ever retrieve an atom’s position by its index in the parent molecule, since that atom may not be the same instance (or even in the same position) as the Coordinate‘s atom.

  `atoms` None

    List of the Atom instances that the Coordinate depends on. In the case of a CartesianCoordinate, for instance, this is trivially one Atom, but in the case of other coordinates it can be much more substantial. In the case of a NormalCoordinate, this is all the atoms in the parent Molecule.

    The presence of an atoms list is essential to establish an internal indexing scheme that can be converted to the indexing scheme of the parent molecule. Besides making the B tensor code much more managable, the use of an internal indexing scheme make Coordinate instances much more self-contained, making “orphaned” coordinates much more viable. Consider the following example:

        >>> from grendel.util.units import Degrees
        >>> from grendel.coordinates.bond_angle import BondAngle
        >>> ba = BondAngle(
        ...     Atom('O', [0.0, 0.0, 0.0]),
        ...     Atom('H', [0.0, 1.0, 0.0]),
        ...     Atom('H', [0.0, 0.0, 1.0]),
        ...     units=Degrees
        ... )
        >>> round(ba.value)
        90.

    If orphaned coordinates where not allowed to exist, we would have to create a Molecule instance containing those three atoms, construct an InternalRepresentation containing the BondAngle instance (which would need to be a valid, complete representation, a non-trivial task in the general case), pair that InternalRepresentation instance with the Molecule instance, get the right Coordinate instance from the InternalRepresentation corresponding to the BondAngle we want, and then get that coordinate’s value. If all of the coordinate’s complicated methods were not implemented in terms of the Coordinate’s own indexing scheme, it would have to have all of this structure in place just to get a value.

    Note

    Since all Coordinate`s depend on `Atom`s and `Atom`s are not immutible, a `Coordinate`s `value and other properties such as its b_vector can change even if the Coordinate itself cannot. The one way around this is to specify freeze_value as True in the Coordinate‘s constructor. If that is done, the value of the Coordinate will not change over the life of the instance, even if the positions of the constituant atoms does change (so if you use this, make sure you know what you are doing). This behavior is useful, for instance, in the use of CartesianRepresentation`s as “snapshots” of a `Molecule instance to be used for the parsing of a particular RepresentationDependentProperty.

  `base_analog` None

    Analogous Coordinate object on the base molecule, if self is a Coordinate on a displaced Molecule, or the Coordinate from which an orphaned displaced Coordinate was created, if the coordinate was created this way.

  `coordinate_symbol` = 'chi'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` None

    Every coordinate must define a reasonable default amount for a finite displacement of that kind of coordinate. This should be a class attribute.

  `generate_name`(one_based=True)
  `in_units`(new_units)
  `index` None
  `internal_indices_for`()
  `is_orphaned`()

    Whether or not the Coordinate instance has a parent Representation

  `iter_molecule_indices`()

    Default implementation for coordinates dependent on atoms directly (basically anything but a CartesianCoordinate or some sort of symmetrized cartesian coordinate).

  `molecule` None

    The molecule associated with the Coordinate.

    Note

    The molecule’s atoms’ positions may not correspond to the positions of the atoms the coordinate describes. See the class documentation for Coordinate for details.

  `molecule_indices` = None
  `molecule_indices_for`()
  `name` = None
  `orphaned_copy`(**kwargs)
  `parent` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `parent_representation` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `units` None

    The units in which the coordinate’s value is expressed.

  `value` None
  `value_for_molecule`(mol)
  `value_for_molecule_matrix`(mat)

    Get the value of the coordinate for the XYZ matrix mat, which is a (self.molecule.natoms) by 3 matrix. In other words, the matrix argument uses the parent Molecule‘s indexing scheme, not the Coordinate‘s own indexing scheme.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  `value_for_positions`(*pos)
  `value_with_units` None

class `Displacement`

  Encapsulates a displacement from a base molecule.

  Attributes: |

  base_molecule : Molecule
    The Molecule object that the displacement is relative to.
  representation : Representation
    The Representation object that the displacements are values in.
  disp_vect : Vector
    The displacement amounts in the given representation. (e.g. disp_vect[i] corresponds to the amount of displacement of the i`th `Coordinate in representation)
  `base_molecule` = None
  `desired_values` = None
  `disp_vect` = None
  `displaced_molecule` None

    The displaced molecule object resulting from applying self to Molecule

  `displaced_representation` None

    The displaced molecule object resulting from applying self to Molecule

  classmethod `from_increments`(increments, rep, deltas=None)
  classmethod `get_default_deltas`(rep)
  `increments`(deltas=None)
  `max_iterations` = 35
  `representation` = None
  `tolerance` = 1e-12

class `DisplacementGenerator`(*args, **kwargs)
  `Backward` = <object object at 0x9ad0b98>
  `Both` = <object object at 0x9ad0ba0>
  `Forward` = <object object at 0x9ad0b90>
  `coordinates` = None
  `direction` = None
  `displaced_molecules` = None
  `displacements` = None
  `npoints_for_coord` = None
  `ranges` = None
  `representation` = None
  `verbose` = False

class `FiniteDifferenceVariable`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

class `Iterable`

class `IterableOf`(types)
  `arg_type_okay`(arg)
  `collection_type`

    alias of `Iterable`

  `types` = None

exception `MaximumGeometryIterationsExceededError`

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

class `Number`

  All numbers inherit from this class.

  If you just want to check if an argument x is a number, without caring what kind, use isinstance(x, Number).

`Radians`

  alias of `Radian`

`ReadOnlyAttribute` None

  A read-only attribute. See SpecialAttribute for initialization variables standard to all SpecialAttribute subclasses.

  Attributes: |

  error_text : str
    The text for the error raised when setting of the attribute is attempted. Defaults to “cannot set read-only attribute”

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `Vector`

  Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to `numpy.ndarray`. Special functionality for vectors gets implemented here.

  Examples: |

  - Multiplication *

      >>> from grendel.gmath import Matrix, Vector
      >>> Matrix([1,2],[3,4]) * Vector([5,6])
      Vector([ 17.,  39.])

  - Cartesian components *

      >>> vtwo = Vector(1., 2.)
      >>> vthree = Vector(1.11, 2.22, 3.33)
      >>> vtwo[0]
      1.0
      >>> vtwo.x
      1.0
      >>> vtwo.y == vtwo[1]
      True
      >>> vthree[2] == vthree.z
      True
      >>> # Can also set:
      >>> vtwo.x = -1
      >>> vtwo.y = -2
      >>> vtwo
      Vector([-1., -2.])
      >>> vthree.x, vthree.z, vthree.y = 1, 3, 2
      >>> vthree
      Vector([ 1.,  2.,  3.])

  `column` None

    Return the column-vector version of self, which is currently implemented as a Matrix object. Note that matrix-vector multiplication will work without getting column first, so don’t use this unless you have a good reason to do so.

  `cross`(other)

    Returns cross product of self with other. Wrapper to numpy.cross

  `normalized`()

    Same as normalize(), but does not modify self

  `reshape`(newshape, order='C')

    Overrides the numpy.ndarray reshape function to make things make sense.

    Examples: |

        >>> v = Vector([1,2,3,4])
        >>> v.reshape((2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])
        >>> # `v` is unchanged:
        >>> v
        Vector([ 1.,  2.,  3.,  4.])
        >>> v.reshape((4,1))
        Matrix([[ 1.],
                [ 2.],
                [ 3.],
                [ 4.]])
        >>> import numpy as np
        >>> np.reshape(v, (2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])

  `x` None

    The x component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `y` None

    The y component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `z` None

    The z component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not three dimensional

`compatible_units`(unit1, unit2)

  Aliased as iscompatible()

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

class `product`

  product(*iterables) –> product object

  Cartesian product of input iterables. Equivalent to nested for-loops.

  For example, product(A, B) returns the same as: ((x,y) for x in A for y in B). The leftmost iterators are in the outermost for-loop, so the output tuples cycle in a manner similar to an odometer (with the rightmost element changing on every iteration).

  To compute the product of an iterable with itself, specify the number of repetitions with the optional repeat keyword argument. For example, product(A, repeat=4) means the same as product(A, A, A, A).

  product(‘ab’, range(3)) –> (‘a’,0) (‘a’,1) (‘a’,2) (‘b’,0) (‘b’,1) (‘b’,2) product((0,1), (0,1), (0,1)) –> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...

  `next` None

    x.next() -> the next value, or raise StopIteration

`strip_units` None
  Strips the units off of a unitized object
    (or, if the object is not Unitized, just return it). If convert_to is given, convert to these units if obj is Unitized. If assume_units is given, obj is assumed to have the units given by this argument if (and only if) it is not an instance of Unitized.

  Aliased as stripunits()

`typechecked` None

  Type checking for functions and methods.

`with_flexible_arguments`(required=None, optional=None, what_to_call_it=None)

  Allows the creation of functions with case insensative, alternately named keyword arguments.

  Examples: |

      >>> @with_flexible_arguments(
      ...     required=[
      ...         ('name', 'greet', 'name_to_greet'),
      ...         ('from_where', 'source')
      ...     ],
      ...     optional=[
      ...         ('greeting', 'hello_phrase', 'salutation'),
      ...         ('message',)
      ...     ]
      ... )
      ... def say_hello(name, from_where, greeting='Hello', message=''):
      ...     print(greeting + ', ' + name + ', from ' + from_where + '!' + message)
      ...
      >>> say_hello('moon', 'Earth')
      Hello, moon, from Earth!
      >>> say_hello('world', source='the moon')
      Hello, world, from the moon!
      >>> say_hello(source='France', name_to_greet='visitor', salutation='Bonjour')
      Bonjour, visitor, from France!
      >>> say_hello('earthlings', 'outer space', 'Greetings', message='  We come in peace!')
      Greetings, earthlings, from outer space!  We come in peace!

class `Coordinate`

  Abstract base class for a general coordinate of a Molecule.

  > Coordinate`s are the components in which `Molecule`s are represented. The most important thing about `Coordinate`s is that they are immutible, like Python’s `str and tuple classes.[#f1]_ Let me say that again a bit louder:

  > Note

  > All coordinates are immutable!

  > Coordinate instances are typically (though not always) associated with a Representation, accessible through the parent read-only attribute. Coordinate instances that do not have a parent associated with them are called “orphaned” coordinates, and can be identified using the is_orphaned() instance method. Even orphaned coordinates must have a Molecule associated with them in one way or another. This happens in one of three ways: 1. If the Coordinate is not orphaned, then parent‘s molecule attribute is used. Note

  > > that in this case, the Coordinate protocol requires the Coordinate‘s constituant atoms to have a parent molecule that is exactly the same instance as parent‘s molecule attribute. (If you aren’t doing something weird, this shouldn’t be an issue).

  > 2. If the Coordinate is orphaned, it still must be composed of one or more Atom instances, accessible through the atoms attribute. These Atom`s may themselves be orphaned, but if they are not, the first non-orphaned `Atom‘s parent is used. Note that if one Atom is non-orphaned, the Coordinate protocol requires that all of them must not be orphaned (i. e. the Coordinate constructor enforces this when sanity_checking_enabled is True)
  > 3. If the Coordinate is orphaned and all of its Atom`s are also orphaned (as is the case, for instance, with `Coordinate instances created for the purpose of finite difference B tensor computation), the Coordinate‘s base_analog attribute may be set to a Coordinate instance whose constituate Atom instances correspond to the derived Coordinate‘s atoms’ base_atom attributes. In this case, the base_analog‘s molecule attribute is used, though it should be utilized for index translation purposes only, since the positions of the atoms in the base molecule will not correspond to the positions of the Coordinate‘s atoms. (The base_analog, in turn, may be an orphaned coordinate of this third type, in which case that coordinate’s base_analog will be used, and so on recursively.)
  > 4. If the Coordinate is orphaned and no base_analog is given, then all of the atoms must have a base_atom that either has a parent_molecule or also has a base_atom defined (and so on so that a base_atom eventually has a parent_molecule somewhere up the line). In this case, the Coordinate protocol requires that all the atoms refer to the same Molecule obtained in this manner. Coordinates created in the course of analytic computation of B tensors fall into this catagory.

  > Because all Coordinate`s may be austensibly associated with a `Molecule instance in one way or another, there are two different ways to index various tensor properties of a Coordinate: the Molecule‘s indices (3 * natoms total indices) and the Coordinate‘s indexing scheme (3 * len(coord.atoms) total indices, where coord is a Coordinate instance). The internal indexing scheme makes a lot more sense in many instances, (see the documentation of Coordinate.atoms for a simple example), but for determining properties of the whole molecule, we need to use the Molecule‘s indexing scheme. All of this should be handled seemlessly behind the scenes, but it’s a good distinction to be aware of.

  > Coordinate has a number of methods that can be used to get the value of a Coordinate in a particular scenario. They hierarchically call each other to determine the value of the Coordinate. The basic scheme is as follows:

  value”]
    value_for_molecule [label=”value_for_molecule()”] value_for_molecule_matrix [label=”value_for_molecule_matrix()”,style=dotted]; value_for_molecule_matrix-> value_for_positions [style=dotted,label=”(only InternalCoordinate)”] value_for_positions -> value_for_xyz [style=dotted,label=”(only SimpleInternalCoordinate)”]; value_for_positions [label=”@classmethod
  value_for_positions()”,style=dotted];
    value_for_xyz [label=”@classmethod
  value_for_xyz()”,style=dotted];

    > }

    The reason for this relatively complex hierarchy is that there are instances in which I have needed each variety for some reason or another. Nodes with dotted borders must be implemented in the relevant subclasses: SimpleInternalCoordinate subclasses must implement value_for_xyz, InternalCoordinate subclasses must implement value_for_positions, and Coordinate subclasses must implement value_for_molecule_matrix().

    TODO: write this part

    Footnotes

    [5]

    Since Python doesn’t really have private attributes, you could in theory change some of the attributes of a Coordinate instance after it is created; the designation of “immutible” here merely means that the class is not guarenteed to work if you do. While it’s technically more of a “please don’t” than a “you can’t”, I for one will not be held responsible for your code not working if you do something like that, and the way these private attributes are used and changed is not guarenteed to stay the same between different versions. Bottom line: just don’t do it. If you don’t know what I’m talking about, you’re probably okay. Just don’t access or modify any attributes that start with a single underscore (you should never do this anyway from outside of a class).

  `atom_indices` None

    The indices of the atom(s) the Coordinate depends on in the Molecule the Coordinate depends on.

    This is guarenteed to work whether or not the Coordinate is orphaned. For each of the various possible Coordinate–Molecule relationships detailed in the Coordinate class documentation, the reason the method works is as follows: 1. If the Coordinate is not orphaned, then the Coordinate‘s atoms must not be

    > orphaned (the Coordinate constructor enforces this when sanity_checking_enabled is True). Thus, each of the atoms must be non-orphaned and thus have an index.

    2. If the Coordinate is orphaned and at least one atom is non-orphaned, all atoms must be non-orphaned (enforced by the Coordinate protocol). Thus, we can use the non-orphaned atoms’ indices.
    3. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is not None, the atoms must have the base_atom attribute set to the corresponding atom in the Coordinate‘s base_analog. Thus, the Atom‘s base_atom‘s index is used.
    4. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is None, then each atom must have a base_atom somewhere down the line that has a parent and thus an index; this atom’s index is used.

    Use this carefully. Don’t ever retrieve an atom’s position by its index in the parent molecule, since that atom may not be the same instance (or even in the same position) as the Coordinate‘s atom.

  `atoms` None

    List of the Atom instances that the Coordinate depends on. In the case of a CartesianCoordinate, for instance, this is trivially one Atom, but in the case of other coordinates it can be much more substantial. In the case of a NormalCoordinate, this is all the atoms in the parent Molecule.

    The presence of an atoms list is essential to establish an internal indexing scheme that can be converted to the indexing scheme of the parent molecule. Besides making the B tensor code much more managable, the use of an internal indexing scheme make Coordinate instances much more self-contained, making “orphaned” coordinates much more viable. Consider the following example:

        >>> from grendel.util.units import Degrees
        >>> from grendel.coordinates.bond_angle import BondAngle
        >>> ba = BondAngle(
        ...     Atom('O', [0.0, 0.0, 0.0]),
        ...     Atom('H', [0.0, 1.0, 0.0]),
        ...     Atom('H', [0.0, 0.0, 1.0]),
        ...     units=Degrees
        ... )
        >>> round(ba.value)
        90.

    If orphaned coordinates where not allowed to exist, we would have to create a Molecule instance containing those three atoms, construct an InternalRepresentation containing the BondAngle instance (which would need to be a valid, complete representation, a non-trivial task in the general case), pair that InternalRepresentation instance with the Molecule instance, get the right Coordinate instance from the InternalRepresentation corresponding to the BondAngle we want, and then get that coordinate’s value. If all of the coordinate’s complicated methods were not implemented in terms of the Coordinate’s own indexing scheme, it would have to have all of this structure in place just to get a value.

    Note

    Since all Coordinate`s depend on `Atom`s and `Atom`s are not immutible, a `Coordinate`s `value and other properties such as its b_vector can change even if the Coordinate itself cannot. The one way around this is to specify freeze_value as True in the Coordinate‘s constructor. If that is done, the value of the Coordinate will not change over the life of the instance, even if the positions of the constituant atoms does change (so if you use this, make sure you know what you are doing). This behavior is useful, for instance, in the use of CartesianRepresentation`s as “snapshots” of a `Molecule instance to be used for the parsing of a particular RepresentationDependentProperty.

  `base_analog` None

    Analogous Coordinate object on the base molecule, if self is a Coordinate on a displaced Molecule, or the Coordinate from which an orphaned displaced Coordinate was created, if the coordinate was created this way.

  `coordinate_symbol` = 'chi'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` None

    Every coordinate must define a reasonable default amount for a finite displacement of that kind of coordinate. This should be a class attribute.

  `generate_name`(one_based=True)
  `in_units`(new_units)
  `index` None
  `internal_indices_for`()
  `is_orphaned`()

    Whether or not the Coordinate instance has a parent Representation

  `iter_molecule_indices`()

    Default implementation for coordinates dependent on atoms directly (basically anything but a CartesianCoordinate or some sort of symmetrized cartesian coordinate).

  `molecule` None

    The molecule associated with the Coordinate.

    Note

    The molecule’s atoms’ positions may not correspond to the positions of the atoms the coordinate describes. See the class documentation for Coordinate for details.

  `molecule_indices` = None
  `molecule_indices_for`()
  `name` = None
  `orphaned_copy`(**kwargs)
  `parent` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `parent_representation` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `units` None

    The units in which the coordinate’s value is expressed.

  `value` None
  `value_for_molecule`(mol)
  `value_for_molecule_matrix`(mat)

    Get the value of the coordinate for the XYZ matrix mat, which is a (self.molecule.natoms) by 3 matrix. In other words, the matrix argument uses the parent Molecule‘s indexing scheme, not the Coordinate‘s own indexing scheme.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  `value_for_positions`(*pos)
  `value_with_units` None

class `CartesianCoordinate`

  A cartesian coordinate compatible with the Coordinate class. CartesianCoordinate objects are immutable. If you need a different cartesian coordinate, create a new CartesianCoordinate objects.

  Attributes: |

  atom : Atom
    The atom to which the cartesian coordinate refers
  direction : int
    The direction (x, y, or z) that the coordinate describes. (0 for x, 1 for y, 2 for z, which are also class constants)
  `atom` None

    The atom to which the cartesian coordinate refers.

  `atoms` None
  `copy_for_representation`(rep, **kwargs)
  `default_delta` = 0.01 Angstrom
  `direction` None

    The direction (x, y, or z) that the coordinate describes. (0 for X, 1 for Y, 2 for Z, which are also class constants)

  `generate_name`(one_based=True)
  `index` None

    The index in the parent representation. This allows for the retrieval of the value for the coordinate on a different molecule, for instance.

  `iter_molecule_indices`()
  `value_for_molecule_matrix`(mat)
  `value_for_positions`(*pos)

class `InternalCoordinate`

  General superclass for all types internal coordinates. Internal coordinates may only refer to one representation.

  `analytic_b_orders` = [1]
  `analytic_b_tensor_for_order`(order)

    Compute the analytic B tensor of a given order and return a tensor indexed by the coordinate’s own indexing scheme.

  `atoms` None
  `b_tensor_cache` = <grendel.util.containers.LRUDict instance at 0xd3e582c>
  `b_tensor_element`(*cart_coords_or_indices)

    Retrieve an element of the Coordinate’s B tensor using CartesianCoordinate instances and/or integer indices in the molecule’s indexing scheme.

  `b_tensor_finite_difference_delta` = 0.001 Angstrom
  `b_tensor_finite_difference_rigor` = 10
  `b_vector` None
  `b_vector_for_positions`(*pos)
  `bvector` None
  `cart_coords` None
  `cart_indices` None
  `copy_with_atoms`(atoms)
  `deltas_for_variables`(vars)
  `fill_b_tensor_analytically`()

    Fill the coordinate’s own _btensor attribute for a given order. (The _btensor attribute should be retrieved using the get_b_tensor() method, which calls this if the _btensor has not already been computed.) If the b tensor cannot be computed analytically at the given order, this method returns NotImplemented. Otherwise, it computes the B tensor to the given order and returns None. If the optional B argument is given, this Coordinate’s part of the Representation-based TensorCollection that B refers to is filled as well.

  `finite_difference_b_tensor`()

    Computes the B tensor for order order by finite difference of B tensors of order order-1, taking into account permutational symmetry. If use_parent_indices is False, a Tensor is returned that is indexed by the coordinate’s internal indices rather than the parent molecule’s atom indices. Otherwise, a DerivativeTensor is returned with its representation attribute set to the coordinate’s parent molecule’s cartesian_representation attribute.

  `finite_difference_b_tensor_element`(*cart_coords, **kwargs)
  `generate_name`(one_based=True)
  `get_b_tensor`(max_order)

    Get the coordinate’s b tensor as a Coordinate-based DerivativeCollection. If it has not already done so, the coordinate will fill in the b tensor up to max_order. The returned value uses the Coordinate‘s internal indexing scheme.

  `internal_indices_for_coordinates`(*cart_coords)
  `iter_cart_coords`(with_index=False)
  `max_b_tensor_cache_entries` = 10000000
  `value_for_displacements`(pairs)
  `variables` None

class `SimpleInternalCoordinate`

  Superclass for all types of simple (non-symmetry, non-normal) internal coordinates.

  Attributes: |

  atoms : list of Atom
    list of Atom objects that the coordinate refers to
  `analytic_b_orders` = [1]
  `atom_num`(i)

    Returns the number of the atom (as an index in self.molecule) that the i’th atom composing the coordinate self refers to.

  static `b_tensor_element_reindexed`(current_coord, *coords)
  classmethod `b_vector_for_positions`(*args)

    Returns the b vector corresponding to a coordinate with atoms in the positions given as arguments (assumed to be Vector or at least LightVector instances). Note that the returned value uses the indexing scheme corresponding to the order of the argument’s passed in, not the indexing scheme corresponding to a Molecule instance somewhere.

  `copy_for_representation`(rep, **kwargs)
  `copy_with_atoms`(atoms, **kwargs)
  `created_coord_maps` = {}
  `created_coords` = {}
  `get_coord`(ctype, *atoms)
  `value` None
  `value_for_molecule_matrix`(mat)
  classmethod `value_for_positions`(*posvects)

    Get the value of the coordinate position vectors xyz.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  classmethod `value_for_xyz`(xyz)

    Value for the xyz matrix constructed from the coordinates of the atoms for the coordinate. For instance, for a

  `xyz` None
  `xyz_delta` = 0.001

class `NormalCoordinate`
  `atoms` = None
  `b_vector` = None
  `coordinate_symbol` = 'q'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` = 0.001 Angstrom / AtomicMassUnit**(1/2)
  `frequency` = None
  `index` = None
  `value_for_molecule_matrix`(mat)
  classmethod `value_for_positions`(*pos)

class `Coordinate`

  Abstract base class for a general coordinate of a Molecule.

  > Coordinate`s are the components in which `Molecule`s are represented. The most important thing about `Coordinate`s is that they are immutible, like Python’s `str and tuple classes.[#f1]_ Let me say that again a bit louder:

  > Note

  > All coordinates are immutable!

  > Coordinate instances are typically (though not always) associated with a Representation, accessible through the parent read-only attribute. Coordinate instances that do not have a parent associated with them are called “orphaned” coordinates, and can be identified using the is_orphaned() instance method. Even orphaned coordinates must have a Molecule associated with them in one way or another. This happens in one of three ways: 1. If the Coordinate is not orphaned, then parent‘s molecule attribute is used. Note

  > > that in this case, the Coordinate protocol requires the Coordinate‘s constituant atoms to have a parent molecule that is exactly the same instance as parent‘s molecule attribute. (If you aren’t doing something weird, this shouldn’t be an issue).

  > 2. If the Coordinate is orphaned, it still must be composed of one or more Atom instances, accessible through the atoms attribute. These Atom`s may themselves be orphaned, but if they are not, the first non-orphaned `Atom‘s parent is used. Note that if one Atom is non-orphaned, the Coordinate protocol requires that all of them must not be orphaned (i. e. the Coordinate constructor enforces this when sanity_checking_enabled is True)
  > 3. If the Coordinate is orphaned and all of its Atom`s are also orphaned (as is the case, for instance, with `Coordinate instances created for the purpose of finite difference B tensor computation), the Coordinate‘s base_analog attribute may be set to a Coordinate instance whose constituate Atom instances correspond to the derived Coordinate‘s atoms’ base_atom attributes. In this case, the base_analog‘s molecule attribute is used, though it should be utilized for index translation purposes only, since the positions of the atoms in the base molecule will not correspond to the positions of the Coordinate‘s atoms. (The base_analog, in turn, may be an orphaned coordinate of this third type, in which case that coordinate’s base_analog will be used, and so on recursively.)
  > 4. If the Coordinate is orphaned and no base_analog is given, then all of the atoms must have a base_atom that either has a parent_molecule or also has a base_atom defined (and so on so that a base_atom eventually has a parent_molecule somewhere up the line). In this case, the Coordinate protocol requires that all the atoms refer to the same Molecule obtained in this manner. Coordinates created in the course of analytic computation of B tensors fall into this catagory.

  > Because all Coordinate`s may be austensibly associated with a `Molecule instance in one way or another, there are two different ways to index various tensor properties of a Coordinate: the Molecule‘s indices (3 * natoms total indices) and the Coordinate‘s indexing scheme (3 * len(coord.atoms) total indices, where coord is a Coordinate instance). The internal indexing scheme makes a lot more sense in many instances, (see the documentation of Coordinate.atoms for a simple example), but for determining properties of the whole molecule, we need to use the Molecule‘s indexing scheme. All of this should be handled seemlessly behind the scenes, but it’s a good distinction to be aware of.

  > Coordinate has a number of methods that can be used to get the value of a Coordinate in a particular scenario. They hierarchically call each other to determine the value of the Coordinate. The basic scheme is as follows:

  value”]
    value_for_molecule [label=”value_for_molecule()”] value_for_molecule_matrix [label=”value_for_molecule_matrix()”,style=dotted]; value_for_molecule_matrix-> value_for_positions [style=dotted,label=”(only InternalCoordinate)”] value_for_positions -> value_for_xyz [style=dotted,label=”(only SimpleInternalCoordinate)”]; value_for_positions [label=”@classmethod
  value_for_positions()”,style=dotted];
    value_for_xyz [label=”@classmethod
  value_for_xyz()”,style=dotted];

    > }

    The reason for this relatively complex hierarchy is that there are instances in which I have needed each variety for some reason or another. Nodes with dotted borders must be implemented in the relevant subclasses: SimpleInternalCoordinate subclasses must implement value_for_xyz, InternalCoordinate subclasses must implement value_for_positions, and Coordinate subclasses must implement value_for_molecule_matrix().

    TODO: write this part

    Footnotes

    [6]

    Since Python doesn’t really have private attributes, you could in theory change some of the attributes of a Coordinate instance after it is created; the designation of “immutible” here merely means that the class is not guarenteed to work if you do. While it’s technically more of a “please don’t” than a “you can’t”, I for one will not be held responsible for your code not working if you do something like that, and the way these private attributes are used and changed is not guarenteed to stay the same between different versions. Bottom line: just don’t do it. If you don’t know what I’m talking about, you’re probably okay. Just don’t access or modify any attributes that start with a single underscore (you should never do this anyway from outside of a class).

  `atom_indices` None

    The indices of the atom(s) the Coordinate depends on in the Molecule the Coordinate depends on.

    This is guarenteed to work whether or not the Coordinate is orphaned. For each of the various possible Coordinate–Molecule relationships detailed in the Coordinate class documentation, the reason the method works is as follows: 1. If the Coordinate is not orphaned, then the Coordinate‘s atoms must not be

    > orphaned (the Coordinate constructor enforces this when sanity_checking_enabled is True). Thus, each of the atoms must be non-orphaned and thus have an index.

    2. If the Coordinate is orphaned and at least one atom is non-orphaned, all atoms must be non-orphaned (enforced by the Coordinate protocol). Thus, we can use the non-orphaned atoms’ indices.
    3. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is not None, the atoms must have the base_atom attribute set to the corresponding atom in the Coordinate‘s base_analog. Thus, the Atom‘s base_atom‘s index is used.
    4. If the coordinate is orphaned and all of its atoms are orphaned and base_analog is None, then each atom must have a base_atom somewhere down the line that has a parent and thus an index; this atom’s index is used.

    Use this carefully. Don’t ever retrieve an atom’s position by its index in the parent molecule, since that atom may not be the same instance (or even in the same position) as the Coordinate‘s atom.

  `atoms` None

    List of the Atom instances that the Coordinate depends on. In the case of a CartesianCoordinate, for instance, this is trivially one Atom, but in the case of other coordinates it can be much more substantial. In the case of a NormalCoordinate, this is all the atoms in the parent Molecule.

    The presence of an atoms list is essential to establish an internal indexing scheme that can be converted to the indexing scheme of the parent molecule. Besides making the B tensor code much more managable, the use of an internal indexing scheme make Coordinate instances much more self-contained, making “orphaned” coordinates much more viable. Consider the following example:

        >>> from grendel.util.units import Degrees
        >>> from grendel.coordinates.bond_angle import BondAngle
        >>> ba = BondAngle(
        ...     Atom('O', [0.0, 0.0, 0.0]),
        ...     Atom('H', [0.0, 1.0, 0.0]),
        ...     Atom('H', [0.0, 0.0, 1.0]),
        ...     units=Degrees
        ... )
        >>> round(ba.value)
        90.

    If orphaned coordinates where not allowed to exist, we would have to create a Molecule instance containing those three atoms, construct an InternalRepresentation containing the BondAngle instance (which would need to be a valid, complete representation, a non-trivial task in the general case), pair that InternalRepresentation instance with the Molecule instance, get the right Coordinate instance from the InternalRepresentation corresponding to the BondAngle we want, and then get that coordinate’s value. If all of the coordinate’s complicated methods were not implemented in terms of the Coordinate’s own indexing scheme, it would have to have all of this structure in place just to get a value.

    Note

    Since all Coordinate`s depend on `Atom`s and `Atom`s are not immutible, a `Coordinate`s `value and other properties such as its b_vector can change even if the Coordinate itself cannot. The one way around this is to specify freeze_value as True in the Coordinate‘s constructor. If that is done, the value of the Coordinate will not change over the life of the instance, even if the positions of the constituant atoms does change (so if you use this, make sure you know what you are doing). This behavior is useful, for instance, in the use of CartesianRepresentation`s as “snapshots” of a `Molecule instance to be used for the parsing of a particular RepresentationDependentProperty.

  `base_analog` None

    Analogous Coordinate object on the base molecule, if self is a Coordinate on a displaced Molecule, or the Coordinate from which an orphaned displaced Coordinate was created, if the coordinate was created this way.

  `coordinate_symbol` = 'chi'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` None

    Every coordinate must define a reasonable default amount for a finite displacement of that kind of coordinate. This should be a class attribute.

  `generate_name`(one_based=True)
  `in_units`(new_units)
  `index` None
  `internal_indices_for`()
  `is_orphaned`()

    Whether or not the Coordinate instance has a parent Representation

  `iter_molecule_indices`()

    Default implementation for coordinates dependent on atoms directly (basically anything but a CartesianCoordinate or some sort of symmetrized cartesian coordinate).

  `molecule` None

    The molecule associated with the Coordinate.

    Note

    The molecule’s atoms’ positions may not correspond to the positions of the atoms the coordinate describes. See the class documentation for Coordinate for details.

  `molecule_indices` = None
  `molecule_indices_for`()
  `name` = None
  `orphaned_copy`(**kwargs)
  `parent` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `parent_representation` None

    The `InternalRepresentation` instance which the coordinate self is a part of.

  `units` None

    The units in which the coordinate’s value is expressed.

  `value` None
  `value_for_molecule`(mol)
  `value_for_molecule_matrix`(mat)

    Get the value of the coordinate for the XYZ matrix mat, which is a (self.molecule.natoms) by 3 matrix. In other words, the matrix argument uses the parent Molecule‘s indexing scheme, not the Coordinate‘s own indexing scheme.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  `value_for_positions`(*pos)
  `value_with_units` None

class `FunctionCoordinate`(function, subcoordinates, index=None, default_delta=None, **kwargs)

  A coordinate that is a function of one or more other Coordinate instances

  `atoms` = None
  `copy_for_representation`(rep, **kwargs)
  `default_delta` = None
  `function` = None
  `index` = None
  `subcoordinates` = None
  `value_for_molecule_matrix`(mat)
  `value_for_positions`(*pos)

class `InternalCoordinate`

  General superclass for all types internal coordinates. Internal coordinates may only refer to one representation.

  `analytic_b_orders` = [1]
  `analytic_b_tensor_for_order`(order)

    Compute the analytic B tensor of a given order and return a tensor indexed by the coordinate’s own indexing scheme.

  `atoms` None
  `b_tensor_cache` = <grendel.util.containers.LRUDict instance at 0xd3e582c>
  `b_tensor_element`(*cart_coords_or_indices)

    Retrieve an element of the Coordinate’s B tensor using CartesianCoordinate instances and/or integer indices in the molecule’s indexing scheme.

  `b_tensor_finite_difference_delta` = 0.001 Angstrom
  `b_tensor_finite_difference_rigor` = 10
  `b_vector` None
  `b_vector_for_positions`(*pos)
  `bvector` None
  `cart_coords` None
  `cart_indices` None
  `copy_with_atoms`(atoms)
  `deltas_for_variables`(vars)
  `fill_b_tensor_analytically`()

    Fill the coordinate’s own _btensor attribute for a given order. (The _btensor attribute should be retrieved using the get_b_tensor() method, which calls this if the _btensor has not already been computed.) If the b tensor cannot be computed analytically at the given order, this method returns NotImplemented. Otherwise, it computes the B tensor to the given order and returns None. If the optional B argument is given, this Coordinate’s part of the Representation-based TensorCollection that B refers to is filled as well.

  `finite_difference_b_tensor`()

    Computes the B tensor for order order by finite difference of B tensors of order order-1, taking into account permutational symmetry. If use_parent_indices is False, a Tensor is returned that is indexed by the coordinate’s internal indices rather than the parent molecule’s atom indices. Otherwise, a DerivativeTensor is returned with its representation attribute set to the coordinate’s parent molecule’s cartesian_representation attribute.

  `finite_difference_b_tensor_element`(*cart_coords, **kwargs)
  `generate_name`(one_based=True)
  `get_b_tensor`(max_order)

    Get the coordinate’s b tensor as a Coordinate-based DerivativeCollection. If it has not already done so, the coordinate will fill in the b tensor up to max_order. The returned value uses the Coordinate‘s internal indexing scheme.

  `internal_indices_for_coordinates`(*cart_coords)
  `iter_cart_coords`(with_index=False)
  `max_b_tensor_cache_entries` = 10000000
  `value_for_displacements`(pairs)
  `variables` None

class `InternalFunctionCoordinate`(b_vector_same_function=True, b_vector_function=None, b_vector_takes_coords=False, b_tensor_same_function=True, b_tensor_function=None, b_tensor_takes_coords=False, value_takes_coords=False, **kwargs)
  `analytic_b_tensor_for_order`(order)
  `b_tensor_function` = None
  `b_tensor_same_function` = None
  `b_tensor_takes_coords` = None
  `b_vector_for_positions`(*pos)
  `b_vector_function` = None
  `b_vector_same_function` = None
  `b_vector_takes_coords` = None
  `copy_with_atoms`(atoms, **kwargs)
  `value_takes_coords` = None

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

class `Iterable`

`Radians`

  alias of `Radian`

class `SimpleInternalCoordinate`

  Superclass for all types of simple (non-symmetry, non-normal) internal coordinates.

  Attributes: |

  atoms : list of Atom
    list of Atom objects that the coordinate refers to
  `analytic_b_orders` = [1]
  `atom_num`(i)

    Returns the number of the atom (as an index in self.molecule) that the i’th atom composing the coordinate self refers to.

  static `b_tensor_element_reindexed`(current_coord, *coords)
  classmethod `b_vector_for_positions`(*args)

    Returns the b vector corresponding to a coordinate with atoms in the positions given as arguments (assumed to be Vector or at least LightVector instances). Note that the returned value uses the indexing scheme corresponding to the order of the argument’s passed in, not the indexing scheme corresponding to a Molecule instance somewhere.

  `copy_for_representation`(rep, **kwargs)
  `copy_with_atoms`(atoms, **kwargs)
  `created_coord_maps` = {}
  `created_coords` = {}
  `get_coord`(ctype, *atoms)
  `value` None
  `value_for_molecule_matrix`(mat)
  classmethod `value_for_positions`(*posvects)

    Get the value of the coordinate position vectors xyz.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  classmethod `value_for_xyz`(xyz)

    Value for the xyz matrix constructed from the coordinates of the atoms for the coordinate. For instance, for a

  `xyz` None
  `xyz_delta` = 0.001

class `SumOfInternalCoordinates`(subcoordinates, coefficients=None, **kwargs)
  `coefficients` = []
  `compute_sum`(*items)
  `generate_name`(one_based=True)

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

class `ValueWithUnits`(value, units)

  A class for encapsulating a physical constant and it’s units.

  units : CompositeUnit or a class with Unit as its metaclass
    The units in which the value of self is to be interpreted
  `convert_to`(units)
  `in_units`(units)
  `units` = None
  `value` None

class `Vector`

  Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to `numpy.ndarray`. Special functionality for vectors gets implemented here.

  Examples: |

  - Multiplication *

      >>> from grendel.gmath import Matrix, Vector
      >>> Matrix([1,2],[3,4]) * Vector([5,6])
      Vector([ 17.,  39.])

  - Cartesian components *

      >>> vtwo = Vector(1., 2.)
      >>> vthree = Vector(1.11, 2.22, 3.33)
      >>> vtwo[0]
      1.0
      >>> vtwo.x
      1.0
      >>> vtwo.y == vtwo[1]
      True
      >>> vthree[2] == vthree.z
      True
      >>> # Can also set:
      >>> vtwo.x = -1
      >>> vtwo.y = -2
      >>> vtwo
      Vector([-1., -2.])
      >>> vthree.x, vthree.z, vthree.y = 1, 3, 2
      >>> vthree
      Vector([ 1.,  2.,  3.])

  `column` None

    Return the column-vector version of self, which is currently implemented as a Matrix object. Note that matrix-vector multiplication will work without getting column first, so don’t use this unless you have a good reason to do so.

  `cross`(other)

    Returns cross product of self with other. Wrapper to numpy.cross

  `normalized`()

    Same as normalize(), but does not modify self

  `reshape`(newshape, order='C')

    Overrides the numpy.ndarray reshape function to make things make sense.

    Examples: |

        >>> v = Vector([1,2,3,4])
        >>> v.reshape((2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])
        >>> # `v` is unchanged:
        >>> v
        Vector([ 1.,  2.,  3.,  4.])
        >>> v.reshape((4,1))
        Matrix([[ 1.],
                [ 2.],
                [ 3.],
                [ 4.]])
        >>> import numpy as np
        >>> np.reshape(v, (2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])

  `x` None

    The x component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `y` None

    The y component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `z` None

    The z component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not three dimensional

`grouper`(n, iterable, fillvalue=None)

  group(3, ‘ABCDEFG’, ‘x’) –> ABC DEF Gxx

`ismethod`(object)

  Return true if the object is an instance method.

  Instance method objects provide these attributes:
    __doc__ documentation string __name__ name with which this method was defined im_class class object in which this method belongs im_func function object containing implementation of method im_self instance to which this method is bound, or None

`isunit`(unit)

  Aliased as is_unit()

class `partial`

  partial(func, *args, **keywords) - new function with partial application of the given arguments and keywords.

  `args` None

    tuple of arguments to future partial calls

  `func` None

    function object to use in future partial calls

  `keywords` None

    dictionary of keyword arguments to future partial calls

class `product`

  product(*iterables) –> product object

  Cartesian product of input iterables. Equivalent to nested for-loops.

  For example, product(A, B) returns the same as: ((x,y) for x in A for y in B). The leftmost iterators are in the outermost for-loop, so the output tuples cycle in a manner similar to an odometer (with the rightmost element changing on every iteration).

  To compute the product of an iterable with itself, specify the number of repetitions with the optional repeat keyword argument. For example, product(A, repeat=4) means the same as product(A, A, A, A).

  product(‘ab’, range(3)) –> (‘a’,0) (‘a’,1) (‘a’,2) (‘b’,0) (‘b’,1) (‘b’,2) product((0,1), (0,1), (0,1)) –> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...

  `next` None

    x.next() -> the next value, or raise StopIteration

`strip_units` None
  Strips the units off of a unitized object
    (or, if the object is not Unitized, just return it). If convert_to is given, convert to these units if obj is Unitized. If assume_units is given, obj is assumed to have the units given by this argument if (and only if) it is not an instance of Unitized.

  Aliased as stripunits()

`Angstroms`

  alias of `Angstrom`

class `Atom`

  Encapsulates an atom. Molecules are made up of Atoms.

  Attributes: |

  position : Vector
    The atom’s Cartesian coordinates [x y z] as a `Vector` object.
  parent_molecule : Molecule
    Reference back to the parent molecule of the atom. (Not set in initializer, but set when the atom gets included in a Molecule). Note that for purposes of pickling and copying this may become a weakref in the future. Do not implement behavior that depends on it being a strong reference.
  zmat_label : str
    Used in the construction of a z-matrix to differentiate atoms of the same Element. Currently not used anywhere else, and not set when any other Atom construction method is used.
  `base_atom` = None
  `cart_coords` None
  `cart_indices` None
  `cartesian_units` = None
  `convert_units`(new_units)
  `displace`()
  `displaced`(disp_vect)

    Creates an orphaned copy of atom and displaces it by disp_vect

  `element` None

    The `Element` object corresponding to self. Updated transparently using the `symbol` property

  `full_symbol` = None
  `in_units`(new_units)
  `index` = None
  `is_orphaned`()
  `isotope` None

    The isotope of the element that self is composed of. Defaults to element.principal_isotope

  `iter_cart_coords`(with_index=False)
  `mass` None

    The atom’s mass as a float (in AMU). Automatically retrieved from the element and isotope attributes.

  `parent` None

    Alias for the parent_molecule attribute.

  `parent_molecule` = None
  `pos` None

    Alias for self.position. pos is also an alias for self.position

  `position` = None
  `same_coordinate_tolerance` = 1e-06
  `symbol` None

    The atomic symbol from the periodic table (as a `str` object) , with correct capitalization. Updating this property transparently updates the `Element` object associated with `self`.

  `x` None
  `xyz` None

    Alias for self.position. pos is also an alias for self.position

  `y` None
  `z` None
  `zmat_label` = None

class `BondAngle`
  `analytic_b_orders` = <object object at 0x9ad0b00>
  `analytic_b_tensor_for_order`(order)
  classmethod `b_vector_for_positions`(*args)
  `coordinate_symbol` = 'phi'
  `default_delta` = 0.02 Radian
  `terminal_atoms` None
  classmethod `value_for_xyz`(xyz)

class `BondLength`
  `analytic_b_orders` = <object object at 0x9ad0b00>
  `analytic_b_tensor_for_order`(order)
  classmethod `b_vector_for_positions`(*args)
  `coordinate_symbol` = 'R'
  `default_delta` = 0.01 Angstrom
  classmethod `value_for_xyz`(xyz)

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `InternalCartesian`
  `default_delta` = 0.01 Angstrom

class `InternalCartesianX`
  `analytic_b_orders` = [1]
  classmethod `b_vector_for_positions`(*args)
  classmethod `value_for_xyz`(xyz)

class `InternalCartesianY`
  `analytic_b_orders` = []
  classmethod `b_vector_for_positions`(*args)
  classmethod `value_for_xyz`(xyz)

class `InternalCartesianZ`
  `analytic_b_orders` = [1]
  classmethod `b_vector_for_positions`(*args)
  classmethod `value_for_xyz`(xyz)

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

class `IterableOf`(types)
  `arg_type_okay`(arg)
  `collection_type`

    alias of `Iterable`

  `types` = None

class `LightVector`
  `is_cartesian`()

    Returns True if the vector is Cartesian (i.e. if the vector is two or three dimensional).

  `is_zero_vector`(cutoff=None)

    Alias for Tensor.is_zero()

  static `l_add`(a, b)
  `l_cross`(other)

    Returns cross product of self with other. Wrapper to numpy.cross

  `l_normalized`()

    Same as l_normalize(), but does not modify self

    Aliased as normalized()

  static `l_sub`(a, b)
  `magnitude`()

    The magnitude of the vector.

    Aliased as norm()

  `norm`(*fargs, **fkeywords)

    Alias for magnitude()

  `normalize`()

    Performs an in-place normalization of self.

    Examples: |

        >>> Vector(2.0, 0.0, 0.0).normalize()
        Vector([ 1.,  0.,  0.])
        >>> Vector(0.5, 0.5, 0.5).normalize()
        Vector([ 0.57735027,  0.57735027,  0.57735027])
        >>> v = Vector(-0.5, 0.5, -0.5).normalize()
        >>> v
        Vector([-0.57735027,  0.57735027, -0.57735027])
        >>> v.magnitude()
        1.0

  `normalized`(*fargs, **fkeywords)

    Alias for l_normalized()

  `size`()

    The number of entries in the vector

class `Matrix`

  > Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to

  `numpy.ndarray`. Special functionality for vectors gets implemented here.

  `I` None
  `col_iter` None
  `cols` None
  `columns` None
  classmethod `diagonal`(iterable)
  `eigensystem`()

    Wrapper to numpy.eigh and numpy.eig for symmetric and non-symmetric matrices, respectively. Note that the eigenvectors are column vectors in the returned matrix.

  classmethod `identity`(n)
  `is_hermitian`()
  `is_square`()
  `is_symmetric`()
  `ncols` None

    Number of columns that self has

  `nrows` None

    Number of rows that self has

  `row_iter` None
  `rows` None
  `sqrt_matrix`()
  `symmetrized`()
  `transformed`(other)

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

class `SimpleInternalCoordinate`

  Superclass for all types of simple (non-symmetry, non-normal) internal coordinates.

  Attributes: |

  atoms : list of Atom
    list of Atom objects that the coordinate refers to
  `analytic_b_orders` = [1]
  `atom_num`(i)

    Returns the number of the atom (as an index in self.molecule) that the i’th atom composing the coordinate self refers to.

  static `b_tensor_element_reindexed`(current_coord, *coords)
  classmethod `b_vector_for_positions`(*args)

    Returns the b vector corresponding to a coordinate with atoms in the positions given as arguments (assumed to be Vector or at least LightVector instances). Note that the returned value uses the indexing scheme corresponding to the order of the argument’s passed in, not the indexing scheme corresponding to a Molecule instance somewhere.

  `copy_for_representation`(rep, **kwargs)
  `copy_with_atoms`(atoms, **kwargs)
  `created_coord_maps` = {}
  `created_coords` = {}
  `get_coord`(ctype, *atoms)
  `value` None
  `value_for_molecule_matrix`(mat)
  classmethod `value_for_positions`(*posvects)

    Get the value of the coordinate position vectors xyz.

    Note

    For angular coordinates, this always returns a value in Radians. value, value_with_units, and value_for_molecule, however, return values in self.units

  classmethod `value_for_xyz`(xyz)

    Value for the xyz matrix constructed from the coordinates of the atoms for the coordinate. For instance, for a

  `xyz` None
  `xyz_delta` = 0.001

class `Vector`

  Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to `numpy.ndarray`. Special functionality for vectors gets implemented here.

  Examples: |

  - Multiplication *

      >>> from grendel.gmath import Matrix, Vector
      >>> Matrix([1,2],[3,4]) * Vector([5,6])
      Vector([ 17.,  39.])

  - Cartesian components *

      >>> vtwo = Vector(1., 2.)
      >>> vthree = Vector(1.11, 2.22, 3.33)
      >>> vtwo[0]
      1.0
      >>> vtwo.x
      1.0
      >>> vtwo.y == vtwo[1]
      True
      >>> vthree[2] == vthree.z
      True
      >>> # Can also set:
      >>> vtwo.x = -1
      >>> vtwo.y = -2
      >>> vtwo
      Vector([-1., -2.])
      >>> vthree.x, vthree.z, vthree.y = 1, 3, 2
      >>> vthree
      Vector([ 1.,  2.,  3.])

  `column` None

    Return the column-vector version of self, which is currently implemented as a Matrix object. Note that matrix-vector multiplication will work without getting column first, so don’t use this unless you have a good reason to do so.

  `cross`(other)

    Returns cross product of self with other. Wrapper to numpy.cross

  `normalized`()

    Same as normalize(), but does not modify self

  `reshape`(newshape, order='C')

    Overrides the numpy.ndarray reshape function to make things make sense.

    Examples: |

        >>> v = Vector([1,2,3,4])
        >>> v.reshape((2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])
        >>> # `v` is unchanged:
        >>> v
        Vector([ 1.,  2.,  3.,  4.])
        >>> v.reshape((4,1))
        Matrix([[ 1.],
                [ 2.],
                [ 3.],
                [ 4.]])
        >>> import numpy as np
        >>> np.reshape(v, (2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])

  `x` None

    The x component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `y` None

    The y component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `z` None

    The z component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not three dimensional

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`generate_fixed_fragment_coords`(a, b, c, *others)

  TODO Document this

`isunit`(unit)

  Aliased as is_unit()

`overloaded` None

  Overload a function the Pythonic (at least, Python 2) way.

  Types can be specified using the overloaded instance decorator method overload_with (which is aliased as overload, submethod, and subfunction).

  Examples: |

      >>> @overloaded
      ... def test():
      ...     raise TypeError
      ...
      >>> @test.overload_with(int, int)
      ... def test(a, b=5):
      ...     return a+b
      ...
      >>> @test.overload_with(str)
      ... def test(string, *args, **kwargs):
      ...     return string + (' ' if len(args) else '') + ', '.join(list(args) + kwargs.keys())
      ...
      >>> @test.overload_with(list, func=callable)
      ... def test(lst, func, *args):
      ...     for item in lst:
      ...         if func(item, *args):
      ...             return item
      ...
      >>> test(1, 3)
      4
      >>> test(17)
      22
      >>> test("Hello")
      'Hello'
      >>> test("Hello", "World")
      'Hello World'
      >>> test("Hello", "Earth", "Mars", "Jupiter")
      'Hello Earth, Mars, Jupiter'
      >>> test([1, 2, 3], lambda x: x**2 % 2 == 0)
      2
      >>> test([1, 2, 3], lambda x, y: x**2 % y == 0, 1)
      1
      >>> test(3.14159, 3.234)
      Traceback (most recent call last):
          ...
      TypeError: invalid function signature test(float, float).
        Available signatures are:
          test(a: int, b: int=5)
              Not valid signature because: argument 'a' is not of the correct type
          test(string: str, *args, **kwargs)
              Not valid signature because: argument 'string' is not of the correct type
          test(lst: list, func: <something for which callable(func) returns True>, *args)
              Not valid signature because: argument 'lst' is not of the correct type
      >>> # giving multiple values for a keyword argument means there is no match.  For instance:
      >>> test('Hello', 'World', string='this is wrong')
      Traceback (most recent call last):
          ...
      TypeError: invalid function signature test(str, str, string=str).
        Available signatures are:
          test(a: int, b: int=5)
              Not valid signature because: argument 'a' is not of the correct type
          test(string: str, *args, **kwargs)
              Not valid signature because: got multiple values for keyword argument 'string'
          test(lst: list, func: <something for which callable(func) returns True>, *args)
              Not valid signature because: argument 'lst' is not of the correct type
      >>> # Methods in classes
      >>> class Foo(object):
      ...     @overloaded
      ...     def bar(self, *args, **kwargs): pass
      ...
      ...     @bar.overload_with(a=int, b=int)
      ...     def bar(self, a, b):
      ...         if not hasattr(self, 'total'):
      ...             self.total = 0
      ...         self.total += a + b
      ...         return a + b
      ...
      >>> foo = Foo()
      >>> foo.bar(1,2)
      3
      >>> foo.bar(4,5)
      9
      >>> foo.total
      12
      >>> Foo.bar(foo, 7, 8)
      15
      >>> foo.total
      27

class `BondAngle`
  `analytic_b_orders` = <object object at 0x9ad0b00>
  `analytic_b_tensor_for_order`(order)
  classmethod `b_vector_for_positions`(*args)
  `coordinate_symbol` = 'phi'
  `default_delta` = 0.02 Radian
  `terminal_atoms` None
  classmethod `value_for_xyz`(xyz)

class `BondLength`
  `analytic_b_orders` = <object object at 0x9ad0b00>
  `analytic_b_tensor_for_order`(order)
  classmethod `b_vector_for_positions`(*args)
  `coordinate_symbol` = 'R'
  `default_delta` = 0.01 Angstrom
  classmethod `value_for_xyz`(xyz)

class `Torsion`
  `analytic_b_orders` = <object object at 0x9ad0b00>
  `analytic_b_tensor_for_order`(order)
  classmethod `b_vector_for_positions`(*args)
  `coordinate_symbol` = 'tau'
  `default_delta` = 0.02 Radian
  classmethod `noncanonical_value_for_xyz`(xyz)
  `preferred_range` = [-3.141592653589793, 3.141592653589793]
  `terminal_atoms` None

class `CartesianRepresentation`

  A representations of a molecule in Cartesian coordinates. Since Atom objects already have Cartesian vectors associated with them, this class mostly consists of helper functions and convenience (accessor) functions that make CartesianRepresentation compatible with the parent Representation class.

  `add_atom`(atom)

    Add an atom to the representation by creating a CartesianCoordinate object cooresponding to the atom.

  `add_coordinate_copy`()

    Add a CartesianCoordinate to the representation.

  `atom`(number)

    Convenience method for accessing atoms. Returns self.molecule.atoms[number]

  `atom_coords`(atom_or_index)
  `atoms` None

    Convenience property for referencing the atoms list in the molecule associated with self.

  `copy_with_molecule`(molecule)
  `displaced_by`(disp, tol=None, maxiter=None)
  `frozen_copy`()
  `index`(atom_or_coordinate)

    Returns the index of the parameter atom in the representation self.

    Parameters: |

    atom_or_coordinate : Atom or CartesianCoordinate
      The atom or cartesian coordinate to obtain the index of. If an atom is passed in, the index of the X coordinate of the atom is returned.

    Raises: |

    IndexError
      If the parameter atom_or_coordinate is not found.
  `iter_atom_coords`(with_atom=False)
  `l_xyz` None

    Returns the value of the representation as a light vector

  `refresh_atom`()

    Renew the coordinates for an atom to coincide with the atom’s current position

  static `same_atom_indices`(index)
  `transform_forcefield`()
  `transform_tensor`()

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

`AMU`

  alias of `AtomicMassUnit`

`Angstroms`

  alias of `Angstrom`

`Attojoules`

  alias of `AttoJoule`

class `Bohr`

`Centimeters`

  alias of `CentiMeter`

class `DerivativeTensor`
  `collection` = None
  `compute_function` = None

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `ForceField`(representation, max_order, property=<class 'grendel.chemistry.molecular_properties.Energy'>, property_units=None)
  `base_molecule` None
  `for_order`()
  `in_representation`(representation)
  `max_order` = None
  `molecular_property` = None
  `property_units` = None

`Hartrees`

  alias of `Hartree`

class `Hertz`

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

`Joules`

  alias of `Joule`

`Kilogram`

  alias of `KiloGram`

class `Matrix`

  > Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to

  `numpy.ndarray`. Special functionality for vectors gets implemented here.

  `I` None
  `col_iter` None
  `cols` None
  `columns` None
  classmethod `diagonal`(iterable)
  `eigensystem`()

    Wrapper to numpy.eigh and numpy.eig for symmetric and non-symmetric matrices, respectively. Note that the eigenvectors are column vectors in the returned matrix.

  classmethod `identity`(n)
  `is_hermitian`()
  `is_square`()
  `is_symmetric`()
  `ncols` None

    Number of columns that self has

  `nrows` None

    Number of rows that self has

  `row_iter` None
  `rows` None
  `sqrt_matrix`()
  `symmetrized`()
  `transformed`(other)

class `Meter`

class `NormalCoordinate`
  `atoms` = None
  `b_vector` = None
  `coordinate_symbol` = 'q'
  `copy_for_representation`(rep, **kwargs)
  `default_delta` = 0.001 Angstrom / AtomicMassUnit**(1/2)
  `frequency` = None
  `index` = None
  `value_for_molecule_matrix`(mat)
  classmethod `value_for_positions`(*pos)

class `NormalRepresentation`
  `add_coordinate_copy`(coordinate)
  `b_matrix` None
  static `convert_to_wavenumbers`(tensor, energy_units)
  `copy_with_molecule`(molecule)
  `displaced_by`(disp, tol=None, maxiter=None)

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `Second`
  classmethod `to`(other)

class `Vector`

  Encapsulates a vector. Most functionality gets passed up to Tensor, which in turn passes things up to `numpy.ndarray`. Special functionality for vectors gets implemented here.

  Examples: |

  - Multiplication *

      >>> from grendel.gmath import Matrix, Vector
      >>> Matrix([1,2],[3,4]) * Vector([5,6])
      Vector([ 17.,  39.])

  - Cartesian components *

      >>> vtwo = Vector(1., 2.)
      >>> vthree = Vector(1.11, 2.22, 3.33)
      >>> vtwo[0]
      1.0
      >>> vtwo.x
      1.0
      >>> vtwo.y == vtwo[1]
      True
      >>> vthree[2] == vthree.z
      True
      >>> # Can also set:
      >>> vtwo.x = -1
      >>> vtwo.y = -2
      >>> vtwo
      Vector([-1., -2.])
      >>> vthree.x, vthree.z, vthree.y = 1, 3, 2
      >>> vthree
      Vector([ 1.,  2.,  3.])

  `column` None

    Return the column-vector version of self, which is currently implemented as a Matrix object. Note that matrix-vector multiplication will work without getting column first, so don’t use this unless you have a good reason to do so.

  `cross`(other)

    Returns cross product of self with other. Wrapper to numpy.cross

  `normalized`()

    Same as normalize(), but does not modify self

  `reshape`(newshape, order='C')

    Overrides the numpy.ndarray reshape function to make things make sense.

    Examples: |

        >>> v = Vector([1,2,3,4])
        >>> v.reshape((2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])
        >>> # `v` is unchanged:
        >>> v
        Vector([ 1.,  2.,  3.,  4.])
        >>> v.reshape((4,1))
        Matrix([[ 1.],
                [ 2.],
                [ 3.],
                [ 4.]])
        >>> import numpy as np
        >>> np.reshape(v, (2,2))
        Matrix([[ 1.,  2.],
                [ 3.,  4.]])

  `x` None

    The x component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `y` None

    The y component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not cartesian (i.e. if it is not two or three dimensional)
  `z` None

    The z component of a cartesian vector

    Raises: |

    IndexError
      If the vector is not three dimensional

`Wavenumbers`

  alias of `Wavenumber`

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`deepcopy`(x, memo=None, _nil=[])

  Deep copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`prod`(seq)

  Because NumPy’s prod function uses 32-bit integer arithmetic with silent handling of overflows, results are wrong if the correct answer would exceed the limits of a signed 32-bit integer. When operating on a sequence of integers, the prod function that we define here uses large integer arithmetic and thus always gives correct results.

class `product`

  product(*iterables) –> product object

  Cartesian product of input iterables. Equivalent to nested for-loops.

  For example, product(A, B) returns the same as: ((x,y) for x in A for y in B). The leftmost iterators are in the outermost for-loop, so the output tuples cycle in a manner similar to an odometer (with the rightmost element changing on every iteration).

  To compute the product of an iterable with itself, specify the number of repetitions with the optional repeat keyword argument. For example, product(A, repeat=4) means the same as product(A, A, A, A).

  product(‘ab’, range(3)) –> (‘a’,0) (‘a’,1) (‘a’,2) (‘b’,0) (‘b’,1) (‘b’,2) product((0,1), (0,1), (0,1)) –> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...

  `next` None

    x.next() -> the next value, or raise StopIteration

`typechecked` None

  Type checking for functions and methods.

class `AtomicMassUnit`

class `Element`(symbol, atomic_number, isotopes)

  Encapsulates an element. Contains attributes that are constant for a given element.

  `atomic_number` = None
  `principal_isotope` None

    The most abundant isotope. This contains the default mass for the element.

  `symbol` = None

`MASS_UNIT`

  alias of `AtomicMassUnit`

class `Atom`

  Encapsulates an atom. Molecules are made up of Atoms.

  Attributes: |

  position : Vector
    The atom’s Cartesian coordinates [x y z] as a `Vector` object.
  parent_molecule : Molecule
    Reference back to the parent molecule of the atom. (Not set in initializer, but set when the atom gets included in a Molecule). Note that for purposes of pickling and copying this may become a weakref in the future. Do not implement behavior that depends on it being a strong reference.
  zmat_label : str
    Used in the construction of a z-matrix to differentiate atoms of the same Element. Currently not used anywhere else, and not set when any other Atom construction method is used.
  `base_atom` = None
  `cart_coords` None
  `cart_indices` None
  `cartesian_units` = None
  `convert_units`(new_units)
  `displace`()
  `displaced`(disp_vect)

    Creates an orphaned copy of atom and displaces it by disp_vect

  `element` None

    The `Element` object corresponding to self. Updated transparently using the `symbol` property

  `full_symbol` = None
  `in_units`(new_units)
  `index` = None
  `is_orphaned`()
  `isotope` None

    The isotope of the element that self is composed of. Defaults to element.principal_isotope

  `iter_cart_coords`(with_index=False)
  `mass` None

    The atom’s mass as a float (in AMU). Automatically retrieved from the element and isotope attributes.

  `parent` None

    Alias for the parent_molecule attribute.

  `parent_molecule` = None
  `pos` None

    Alias for self.position. pos is also an alias for self.position

  `position` = None
  `same_coordinate_tolerance` = 1e-06
  `symbol` None

    The atomic symbol from the periodic table (as a `str` object) , with correct capitalization. Updating this property transparently updates the `Element` object associated with `self`.

  `x` None
  `xyz` None

    Alias for self.position. pos is also an alias for self.position

  `y` None
  `z` None
  `zmat_label` = None

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

exception `InvalidZMatrixException`(line)

  Raised if a line of a z-matrix has the wrong number of entries.

exception `InvalidXYZFormatError`

  Raised if an invalid string in the XYZ format is passed into the Molecule class constructor

class `Element`(symbol, atomic_number, isotopes)

  Encapsulates an element. Contains attributes that are constant for a given element.

  `atomic_number` = None
  `principal_isotope` None

    The most abundant isotope. This contains the default mass for the element.

  `symbol` = None

class `Isotope`(mass, abundance, element)

  Struct for containing the information about an isotope. For abundance, `None` means trace abundance

  `abundance` = None
  `element` = None
  `is_principal`()
  `mass` = None
  `spin` = None
  `symbol` None

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `Differentiable`

  Abstract base class for things that you are allowed to take derivatives of.

  `shape` None
  `value` None

    The value of the differentiable property. If this function is not overridden, assume that self can be added and subtracted, as well as multiplied by a float.

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `Energy`(molecule, units=None, details=None)

  The energy of a molecule.

  `default_units`

    alias of `Wavenumber`

class `EnergyUnit`

  General superclass for all energy units

  `default`

    alias of `Wavenumber`

  `reference_unit`

    alias of `Joule`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

class `MatrixProperty`(molecule, units=None, details=None)

  A property whose value is a matrix.

  `from_groups`(groups, units)

    Placeholder implementation to satisfy abstract class requirements. Everything is already taken care of in MatrixProperty.from_sequence

  `from_sequence`(seq, units)

    Default implementation for matrix properties; only works if seq is a MatrixRegexSequence

class `MatrixRegexSequence`(*args, **kwargs)

  Special subclass of RegexSequence that make parsing matrices easier.

  `get_matrix`()
  `transpose` = None

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

class `Number`

  All numbers inherit from this class.

  If you just want to check if an argument x is a number, without caring what kind, use isinstance(x, Number).

class `OrbitalEnergies`(molecule, units=None, details=None)
  `default_units`

    alias of `Wavenumber`

class `PartiallyConstructed`(cls_to_construct, *args, **kwargs)
  Allow classes to be “partially constructed” by wrapping the class’s __init__
    and __new__ with a method that sets given attributes or appends certain keyword arguments to the initialzation call.
  `counter` = 2
  `with_args`(*args)
  `with_attributes`(**kwargs)

    Append some attributes to be set after the initialization is performed. Note that these override anything done in the class’s __init__, so don’t do anything stupid.

  `with_kwargs`(**kwargs)

class `ScalarProperty`(molecule, units=None, details=None)

  A property whose value is a scalar

  `from_groups`(groups, units)

    By default, just get the last group matched.

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

class `TensorProperty`(molecule, units=None, details=None)

  A property whose value is an n-dimensional tensor

class `Unitized`

  Abstract base class for things with units. It requires its subclasses to implement the properties ‘value’ and ‘units’. Unitized subclasses are also expected have __mul__, __div__, __truediv__, __pow__, __add__, __sub__, __neg__, __pos__, and __abs__ handle units correctly, when implemented in the given subclass.

  `in_units`(new_units)
  `units` None
  `value` None

exception `ValueNotAvailableError`

  Raised when a MolecularProperty is requested but not available for whatever reason.

class `ValueWithUnits`(value, units)

  A class for encapsulating a physical constant and it’s units.

  units : CompositeUnit or a class with Unit as its metaclass
    The units in which the value of self is to be interpreted
  `convert_to`(units)
  `in_units`(units)
  `units` = None
  `value` None

class `VectorProperty`(molecule, units=None, details=None)

  A property whose value is a vector.

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

`classname`(class_or_str_or_obj)

  Convenience method for getting the typename as a string from the <type ‘Something’> string sent back by str(type(obj))

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`isunit`(unit)

  Aliased as is_unit()

class `partial`

  partial(func, *args, **keywords) - new function with partial application of the given arguments and keywords.

  `args` None

    tuple of arguments to future partial calls

  `func` None

    function object to use in future partial calls

  `keywords` None

    dictionary of keyword arguments to future partial calls

`typechecked` None

  Type checking for functions and methods.

`with_attributes`(**kwargs)

  Decorator allowing the assignment of attributes to a function.

exception `ArgTypeError`

  Convenience error to raise when an argument is not of the right types.

class `CartesianRepresentation`

  A representations of a molecule in Cartesian coordinates. Since Atom objects already have Cartesian vectors associated with them, this class mostly consists of helper functions and convenience (accessor) functions that make CartesianRepresentation compatible with the parent Representation class.

  `add_atom`(atom)

    Add an atom to the representation by creating a CartesianCoordinate object cooresponding to the atom.

  `add_coordinate_copy`()

    Add a CartesianCoordinate to the representation.

  `atom`(number)

    Convenience method for accessing atoms. Returns self.molecule.atoms[number]

  `atom_coords`(atom_or_index)
  `atoms` None

    Convenience property for referencing the atoms list in the molecule associated with self.

  `copy_with_molecule`(molecule)
  `displaced_by`(disp, tol=None, maxiter=None)
  `frozen_copy`()
  `index`(atom_or_coordinate)

    Returns the index of the parameter atom in the representation self.

    Parameters: |

    atom_or_coordinate : Atom or CartesianCoordinate
      The atom or cartesian coordinate to obtain the index of. If an atom is passed in, the index of the X coordinate of the atom is returned.

    Raises: |

    IndexError
      If the parameter atom_or_coordinate is not found.
  `iter_atom_coords`(with_atom=False)
  `l_xyz` None

    Returns the value of the representation as a light vector

  `refresh_atom`()

    Renew the coordinates for an atom to coincide with the atom’s current position

  static `same_atom_indices`(index)
  `transform_forcefield`()
  `transform_tensor`()

class `DerivativeProperty`(*args, **kwargs)
  `from_groups`(groups, units)

    Placeholder implementation to satisfy abstract class requirements. Everything is already taken care of in from_sequence

  `from_sequence`(seq, units)

    Expects a MatrixRegexSequence which returns a Nx3 matrix

  `known_subclasses` = {'_EnergyDerivative2': <class 'abc._EnergyDerivative2'>, '_EnergyDerivative1': <class 'abc._EnergyDerivative1'>}
  `order` = None
  classmethod `with_respect_to`(rep)

class `Energy`(molecule, units=None, details=None)

  The energy of a molecule.

  `default_units`

    alias of `Wavenumber`

`EnergyGradient`

  alias of `_PartiallyConstructed___EnergyDerivative1_0`

`EnergyHessian`

  alias of `_PartiallyConstructed___EnergyDerivative2_1`

`Forces`

  alias of `_PartiallyConstructed___EnergyDerivative1_0`

`Gradient`

  alias of `_PartiallyConstructed___EnergyDerivative1_0`

`Hessian`

  alias of `_PartiallyConstructed___EnergyDerivative2_1`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

class `MatrixRegexSequence`(*args, **kwargs)

  Special subclass of RegexSequence that make parsing matrices easier.

  `get_matrix`()
  `transpose` = None

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

`MolecularPropertyDerivative`(prop, representation=<class 'grendel.representations.cartesian_representation.CartesianRepresentation'>, order=1)
  Factory for creating MolecularProperty subclasses that represent the nth derivative

    of a MolecularProperty with respect to some set of coordinates.

    Several possibilities for representation: If it’s a Representation subclass, then we want that representation of the molecule in question (used when requesting the derivative). If it’s a representation instance, then we want the Derivative with respect to that specific representation (raises an error if it is not compatible). If it’s an arbitrary callable, then the callable is called with the contents of the file and should return a representation, which the (typically parsed-from-a-file) derivative is considered to be with respect to. The default is CartesianRepresentation.

    Derivative properties can be automatically or manually transformed to other representations.

  Aliased as PropertyDerivative()

class `PartiallyConstructed`(cls_to_construct, *args, **kwargs)
  Allow classes to be “partially constructed” by wrapping the class’s __init__
    and __new__ with a method that sets given attributes or appends certain keyword arguments to the initialzation call.
  `counter` = 2
  `with_args`(*args)
  `with_attributes`(**kwargs)

    Append some attributes to be set after the initialization is performed. Note that these override anything done in the class’s __init__, so don’t do anything stupid.

  `with_kwargs`(**kwargs)

`PropertyDerivative`(*fargs, **fkeywords)

  Alias for MolecularPropertyDerivative()

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `RepresentationDependentProperty`(molecule, units=None, details=None)

  A property whose value is dependent on a given representation of the molecule.

  `get_value`(*args, **kwargs)
  `molecule` None
  `representation` None
  `representation_getter` = None

class `RepresentationDependentTensor`
  `first_dimension_different` = None
  `formatted_string`(**kwargs)
  `in_representation`(new_rep)
  `permutational_symmetry` = None
  `representation` None
  `secondary_representation` None
  `value` None

class `TensorProperty`(molecule, units=None, details=None)

  A property whose value is an n-dimensional tensor

`function_alias`(alias, function)

  Alias a function as something else. Set the documentation of the new method to “Alias for <function>()” and add “Aliased as <alias>()” to the documentation of function. Not inteded to be used as a decorator.

  Examples: |

      >>> def foo(a, b, c):
      ...     '''Print a test message.'''
      ...     print "testing {0}, {1}, {2}".format(a, b, c)
      ...
      >>> foo(1, 2, 3)
      testing 1, 2, 3
      >>> bar = function_alias('bar', foo)
      >>> bar(4, 5, 6)
      testing 4, 5, 6
      >>> print bar.__doc__
      Alias for `foo()`
      >>> print foo.__doc__
      Print a test message.

      Aliased as `bar()`
      >>> baz = function_alias('baz', foo)
      >>> baz(7, 8, 9)
      testing 7, 8, 9
      >>> print foo.__doc__
      Print a test message.

      Aliased as `baz()`, `bar()`

  Inside a class

      >>> class FooBar(object):
      ...     def testfunc(self, *args):
      ...         '''Print out the args.'''
      ...         print "testing " + ', '.join(str(a) for a in args)
      ...     another_name = function_alias('another_name', testfunc)
      ...     test_func = function_alias('test_func', testfunc)
      ...
      >>> f = FooBar()
      >>> f.test_func(1, 2, 3, 4)
      testing 1, 2, 3, 4
      >>> print FooBar.test_func.__doc__
      Alias for `testfunc()`
      >>> print FooBar.testfunc.__doc__
      Print out the args.

      Aliased as `test_func()`, `another_name()`

`raises_error`(callable_obj, *args, **kwargs)

  Returns True if a call of callable with args raises an error, and False if not. Note that the callable will get called, so don’t do anything that takes a long time or changes things in a way you don’t want them to be changed. If the optional keyword argument ‘error’ is given as either an Exception subclass or an Iterable, raises_error returns True if the call of callable raises the error given or one of the errors given in the list. (The keyword argument can also be named ‘errors’). Any other keyword arguments are passed through to callable.

  Technical note: As per the Python manual, only exceptions that subclass from Exception (and not BaseException directly) will be recognized. According to the python users manual, you should never implement a user exception that subclasses from BaseException directly.

  Examples: |

      >>> raises_error(int, "5")
      False
      >>> raises_error(int, "0x5ab7", 0)
      False
      >>> raises_error(lambda x: int(x), "5")
      False
      >>> raises_error(int, "abc")
      True
      >>> raises_error(int, "abc", error = ValueError)
      True
      >>> raises_error(int, "abc", error = BufferError)
      False
      >>> raises_error(int, "abc", error = (BufferError, EnvironmentError))
      False
      >>> raises_error(int, "abc", error = [BufferError, ValueError])
      True
      >>> raises_error(float, "abc")
      True
      >>> # Use raises_error to see what errors raises_error raises
      ... # Raise a type error if the first argument is not a callable (i.e. 17(25) doesn't make sense to Python)
      ... raises_error(raises_error, 17, 25, error = TypeError)
      True
      >>> # Raise a TypeError if the error keyword argument is not a subclass of Exception
      ... raises_error(lambda x: raises_error(int, x, error = "hello world"), 25, error = TypeError)
      True
      >>> raises_error(lambda x: raises_error(int, x, error = BaseException), 25, error = TypeError)
      True

exception `GroupTheoryError`

  Raised when something that’s not allowed in group theory is done.

class `PointGroup`(molecule, ops)

  Encapsulates a point group.

  `classes` = []
  `element_for`(op)

    Returns the element that is the same as op in the group self. This allows us to avoid duplication. When self._generate_elements is True, this adds op to self.operations if no operation is found that is the same as op (this should pretty much only be used by the internal PointGroup._close_group() private method. If you come up with another use for it, use it with care!) Otherwise, if an equivalent of op is not found, a GroupTheoryError is raised.

  `element_with_matrix`(mat)

    Returns the element that has the matrix mat in the group self. Raises a GroupTheoryError indicating the group is not closed if no such element is found.

  `identity_element` = None
  `improper_rotations` = None
  `inversion` = None
  `molecule` = None
  `name` = None
  `num_C_n_axes`(n)

    Returns the number of (unique) axes of order n in the point group

  `operations` = []
  `reflections` = None
  `ring_angle_tolerance` = 0.03490658503988659
  `rotations` = None
  `symmetry_tolerance` = 0.0001

class `ConjugacyClass`(*initial_elements)
  `add_element`(el)

    Adds an element to the conjugacy class (if it has not already been added)

  `elements` = []
  `first_element` = None
  `order` None

class `SymmetryOperation`

  The abstract superclass for elements of point groups.

  Attributes: |

  name : str
    An attempt at creating a human-readable name for the operation.
  `conjugacy_class` = None
  `inverse` = None
  classmethod `is_perpendicular`(v1, v2)
  classmethod `is_same_axis`(a1, a2, parallel_only=False)

    True if the axes a1 and a2 are parallel or antiparallel. Note that normalized versions of a1 and a2 are used, so normalizing before passing in will just slow things down. If parallel_only is True (it is False by default), this method only returns True if the two axes are parallel, not anti_parallel.

  classmethod `is_same_matrix`(m1, m2)

    True if (a1-a2).norm() < SymmetryOperation.same_operation_tolerance (See ~pyobj:grendel.gmath.tensor.Tensor.norm for description of what is meant by norm here)

  `matrix` None

    The Matrix that transforms the molecule according to the symmetry operation self

  `molecule` None

    The Molecule that the operation acts on

  `name` = None
  `perpendicular_tolerance` = 0.017453292519943295
  `point_group` = None
  `same_axis_tolerance` = 0.0001
  `same_operation_tolerance` = 0.0001
  `zero_vector_cutoff` = 1e-05

class `IdentityOperation`(point_group=None)

  The identity (E) element of a point group.

  `matrix` None

class `Rotation`(n, axis, exponent=1, point_group=None)

  A rotation (C_n^m) element of a point group.

  Attributes: |

  n : int
    The order of the rotation (e.g. for a C_3 operation, `n`=3)
  axis : Vector
    The axis about which the operation occurs
  exponent : int
    The number of times the operation is applied. (e.g. for C_3, exponent = 1, for C_3^2, exponent = 2, etc.)
  classmethod `about_axis`(molecule, axis, max_order)
  `axis` = None
  `exponent` = None
  classmethod `from_matrix`(matrix)
  `matrix` None
  `n` = None
  `theta` None

    The angle of rotation, in Radians

class `Reflection`(axis, point_group=None)

  A reflection (sigma) element of a point group.

  `axis` = None
  `is_dihedral`()

    Whether or not the reflection is a sigma_d

  `is_principal_reflection`()
  `matrix` None
  `principal_reflection` = False
  classmethod `with_normal`(molecule, axis)

class `Inversion`(point_group=None)

  An inversion (i) element of a point group.

  classmethod `exists_for_molecule`(molecule)
  `matrix` None

class `ImproperRotation`(n, axis, exponent=1, point_group=None)

  An improper rotation (S_n^m) element of a point group.

  Attributes: |

  n : int
    The order of the rotation (e.g. for a S_3 operation, `n`=3)
  axis : Vector
    The axis about which the operation occurs
  exponent : int
    The number of times the operation is applied. (e.g. for S_5, exponent = 1, for S_5^4, exponent = 4, etc.)
  classmethod `about_axis`(molecule, axis, max_ring)
  `axis` = None
  `exponent` = None
  `matrix` None
  `n` = None

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

exception `ArgTypeError`

  Convenience error to raise when an argument is not of the right types.

class `CartesianRepresentation`

  A representations of a molecule in Cartesian coordinates. Since Atom objects already have Cartesian vectors associated with them, this class mostly consists of helper functions and convenience (accessor) functions that make CartesianRepresentation compatible with the parent Representation class.

  `add_atom`(atom)

    Add an atom to the representation by creating a CartesianCoordinate object cooresponding to the atom.

  `add_coordinate_copy`()

    Add a CartesianCoordinate to the representation.

  `atom`(number)

    Convenience method for accessing atoms. Returns self.molecule.atoms[number]

  `atom_coords`(atom_or_index)
  `atoms` None

    Convenience property for referencing the atoms list in the molecule associated with self.

  `copy_with_molecule`(molecule)
  `displaced_by`(disp, tol=None, maxiter=None)
  `frozen_copy`()
  `index`(atom_or_coordinate)

    Returns the index of the parameter atom in the representation self.

    Parameters: |

    atom_or_coordinate : Atom or CartesianCoordinate
      The atom or cartesian coordinate to obtain the index of. If an atom is passed in, the index of the X coordinate of the atom is returned.

    Raises: |

    IndexError
      If the parameter atom_or_coordinate is not found.
  `iter_atom_coords`(with_atom=False)
  `l_xyz` None

    Returns the value of the representation as a light vector

  `refresh_atom`()

    Renew the coordinates for an atom to coincide with the atom’s current position

  static `same_atom_indices`(index)
  `transform_forcefield`()
  `transform_tensor`()

class `Computation`

  Base class for all classes encapsulating runs of external programs

  `additional_safe_directory_characters` = '+'
  `already_run`()

    Checks to see if an identical input file with an identical name has already been run in the computation’s directory to produce an output file of some sort (if that output file has errors, you probably don’t want to rerun the exact same input file, so this doesn’t do that by default. If you need to do that, call Computation.run() with the force_rerun argument set to True).

  `always_create_missing` = False
  `attribute_aliases` = {'Theory': ['Method', 'LevelOfTheory']}
  `completed` None

    True if and only if the calculation has finished running. (regardless of success or failure). Setting completed to True triggers the output parser.

  `details` = None
  `directory` = None
  `directory_template` = None
  `get_energy`(details=None)
  `get_property`(prop_class, details=None)
  `get_results`()
  `has_energy`(details=None)
  `has_property`(prop_class, details=None)
  `input_generator` = None
  `molecule` = None
  `needed_properties` None

    The types of the properties in the self.properties list.

  `needs_property`(prop)
  `output_parser` = None
  `properties` = []
  `queued` = False
  `run`(force_rerun=False, lock=None)
  `runner` = None
  classmethod `standardize_attribute`(attr)

    Convert strings to standard form for attributes. Strings with spaces, underscore_joined_strings, Uppercase_Underscore_Strings, and lowerCamelCase strings are all converted to UpperCamelCase.

    Examples: |

        >>> Computation.standardize_attribute("basis_set")
        'BasisSet'
        >>> Computation.standardize_attribute("basis set")
        'BasisSet'
        >>> Computation.standardize_attribute("basis!Set")
        'BasisSet'
        >>> # Only _ and space serve as CamelCase separators:
        >>> Computation.standardize_attribute("basis!set")
        'Basisset'
        >>> Computation.standardize_attribute("Level___of!*theory")
        'LevelOftheory'
        >>> # "Accidental" caps are not fixed...
        >>> Computation.standardize_attribute("Level___of!*tHEory")
        'LevelOftHEory'
        >>> #All caps gets translated into title case
        >>> Computation.standardize_attribute("Level&$#of__THEORY")
        'LevelofTheory'

  `start`()
  `started` = False
  `task_description`()

class `ComputationDetails`(**kwargs)

  Encapsulates specifics about how the calculation was/is to be carried out, such as level of theory, basis set, program, etc. Can be subclassed for specific programs which may require special detail setting methods.

  `available_pairs`(*keys)
  classmethod `from_details`(details)

    Effectively clones details. Used internally for making a details into a ComputationDetails subclass

  classmethod `is_compatible_details`(requested, details_computed_with)
  `is_subset_of`(other)
  `is_superset_of`(other)
  `keywordify`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `keywordify_if_available`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `required_details` = []

exception `ComputationFailureError`

  Thrown when a computation fails for one reason or another

class `ComputationResultGetter`
  `add_computation`(comp)
  `can_get_property`(*fargs, **fkeywords)

    Alias for can_get_property_for_molecule()

  `can_get_property_for_molecule`(molecule, property, details=None)

    Aliased as has_property(), can_get_property()

  `computation_kwargs` = None
  `computations` = None
  `directory_series` = {}
  `get_computation_for_property`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property`(*fargs, **fkeywords)

    Alias for can_get_property_for_molecule()

  `has_property_for_molecule`(molecule, property, details=None, verbose=False)
  `known_result_getters` = {}
  `use_directory_series` = None

exception `ComputationUnavailableError`

  Raised when a computation can’t be generated either because a compatible input template can’t be found or a valid output parser can’t be found

class `DerivativeProperty`(*args, **kwargs)
  `from_groups`(groups, units)

    Placeholder implementation to satisfy abstract class requirements. Everything is already taken care of in from_sequence

  `from_sequence`(seq, units)

    Expects a MatrixRegexSequence which returns a Nx3 matrix

  `known_subclasses` = {'_EnergyDerivative2': <class 'abc._EnergyDerivative2'>, '_EnergyDerivative1': <class 'abc._EnergyDerivative1'>}
  `order` = None
  classmethod `with_respect_to`(rep)

class `Differentiable`

  Abstract base class for things that you are allowed to take derivatives of.

  `shape` None
  `value` None

    The value of the differentiable property. If this function is not overridden, assume that self can be added and subtracted, as well as multiplied by a float.

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `Energy`(molecule, units=None, details=None)

  The energy of a molecule.

  `default_units`

    alias of `Wavenumber`

`EnergyGradient`

  alias of `_PartiallyConstructed___EnergyDerivative1_0`

`EnergyHessian`

  alias of `_PartiallyConstructed___EnergyDerivative2_1`

class `EnergyUnit`

  General superclass for all energy units

  `default`

    alias of `Wavenumber`

  `reference_unit`

    alias of `Joule`

`Forces`

  alias of `_PartiallyConstructed___EnergyDerivative1_0`

`Gradient`

  alias of `_PartiallyConstructed___EnergyDerivative1_0`

`Hessian`

  alias of `_PartiallyConstructed___EnergyDerivative2_1`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

class `InputGenerator`(computation)

  Abstract base class for classes that generate input files.

  `computation` = None
  `generate`(filename)
  `generated` = None
  `needed_properties` None
  `validate`()

    Determine if we will be able to generate an input.

class `InternalRepresentation`

  An internal coordinate representations of a molecule. TODO: More thoroughly document what this means.

  `BEND_NAMES` = ['bend', 'angle']
  `STRE_NAMES` = ['str', 'stre', 'bond']
  `TORS_NAMES` = ['tors']
  `a_matrix` None

    The El’yashevich–Wilson B matrix pseudoinverse, with the Sayvetz conditions used to generate the inverse mass external conditions.

  `add_coordinate_copy`()
  `b_matrix` None

    The El’yashevich–Wilson B matrix for the molecule in the representation.

  `b_tensor`(cartesian_representation=None)
  `copy_with_molecule`(molecule)
  `default_units` = {<class 'grendel.util.units.unit.DistanceUnit'>: Angstrom, <class 'grendel.util.units.unit.AngularUnit'>: Degree}
  `displaced_by`(disp, tol=None, maxiter=None)
  `g_matrix` None
  `is_valid`()
  `transform_forcefield`(ff, to_representation)
  `transform_tensor`(tensor, to_representation)
  `validate`()
  `zero_eigenvalue` = 1e-08

class `Iterable`

class `MatrixProperty`(molecule, units=None, details=None)

  A property whose value is a matrix.

  `from_groups`(groups, units)

    Placeholder implementation to satisfy abstract class requirements. Everything is already taken care of in MatrixProperty.from_sequence

  `from_sequence`(seq, units)

    Default implementation for matrix properties; only works if seq is a MatrixRegexSequence

class `MatrixRegexSequence`(*args, **kwargs)

  Special subclass of RegexSequence that make parsing matrices easier.

  `get_matrix`()
  `transpose` = None

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

`MolecularPropertyDerivative`(prop, representation=<class 'grendel.representations.cartesian_representation.CartesianRepresentation'>, order=1)
  Factory for creating MolecularProperty subclasses that represent the nth derivative

    of a MolecularProperty with respect to some set of coordinates.

    Several possibilities for representation: If it’s a Representation subclass, then we want that representation of the molecule in question (used when requesting the derivative). If it’s a representation instance, then we want the Derivative with respect to that specific representation (raises an error if it is not compatible). If it’s an arbitrary callable, then the callable is called with the contents of the file and should return a representation, which the (typically parsed-from-a-file) derivative is considered to be with respect to. The default is CartesianRepresentation.

    Derivative properties can be automatically or manually transformed to other representations.

  Aliased as PropertyDerivative()

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

class `Number`

  All numbers inherit from this class.

  If you just want to check if an argument x is a number, without caring what kind, use isinstance(x, Number).

class `OrbitalEnergies`(molecule, units=None, details=None)
  `default_units`

    alias of `Wavenumber`

class `OutputParser`(computation, property_parsers=None)

  Abstract base class for classes that parse the output file for a computation.

  `computation` = None
  `molecule` None
  `needed_indices` None
  `needed_properties` None
  `parse_file`(file)
  `property_parsers` = None
  `reset`()
  `valid_parsers` = None
  `validate`()

class `PackageInterface`(input_generator, runner, output_parser)

  Container for the various custom classes needed to run a calculation in a given software package.

  `computation_class`

    alias of `Computation`

  `details_class`

    alias of `ComputationDetails`

  `input_generator` = None
  classmethod `load_package`(name, input_generator=None, output_parser=None, runner=None, details_class=None, computation_class=None)

    Load a package with the given name to be used for computations. Optionally, specify specific subclasses to use for certain things.

  `output_parser` = None
  `runner` = None

class `PartiallyConstructed`(cls_to_construct, *args, **kwargs)
  Allow classes to be “partially constructed” by wrapping the class’s __init__
    and __new__ with a method that sets given attributes or appends certain keyword arguments to the initialzation call.
  `counter` = 2
  `with_args`(*args)
  `with_attributes`(**kwargs)

    Append some attributes to be set after the initialization is performed. Note that these override anything done in the class’s __init__, so don’t do anything stupid.

  `with_kwargs`(**kwargs)

`PropertyDerivative`(*fargs, **fkeywords)

  Alias for MolecularPropertyDerivative()

class `Representation`

  Superclass of all the representations types.

  Attributes:

  molecule : Molecule

    The Molecule object represented by self.

  coords : list of Coordinate

    The coordinates that make up the representation

  `add_coordinate_copy`(coordinate)
  `coords` = None
  `copy_with_molecule`(molecule)

    Make a copy of self that is the same in every way except for the molecule attribute. New Coordinate objects are created using the Coordinate.copy_for_representation() method for each element of self.coords. This is an abstract method that must be implemented by all Representation subclasses.

  `displaced_by`(disp, tol=None, maxiter=None)

    Apply the Displacement instance disp to the molecule and current representation, generating a new molecule and a new representation (which start as a deepcopy and the return value of Representation.copy_with_molecule, respectively) with the displacement applied. This is an abstract method that must be implemented by all Representation subclasses.

  `molecule` = None
  `units` = None
  `value` None
  `value_for_matrix`(*fargs, **fkeywords)

    Alias for values_for_matrix()

  `value_for_molecule`(*fargs, **fkeywords)

    Alias for values_for_molecule()

  `values` None
  `values_for_matrix`(mat)

    Aliased as value_for_matrix()

  `values_for_molecule`(mol)

    Aliased as value_for_molecule()

class `RepresentationDependentProperty`(molecule, units=None, details=None)

  A property whose value is dependent on a given representation of the molecule.

  `get_value`(*args, **kwargs)
  `molecule` None
  `representation` None
  `representation_getter` = None

class `RepresentationDependentTensor`
  `first_dimension_different` = None
  `formatted_string`(**kwargs)
  `in_representation`(new_rep)
  `permutational_symmetry` = None
  `representation` None
  `secondary_representation` None
  `value` None

class `Runner`(input_file=None, output_file=None, **kwargs)

  Abstract base class for classes that run a computation (or an equivalent task, such as submit a job to a PBS queue). Not all Computation objects need a runner; for instance XML-parsed computations are constructed in an already-run state.

  `command_sequence` = None
  `default_input_filename` = 'input.dat'
  `default_output_filename` = 'output.dat'
  `environment` = None
  `input_file` = None
  `output_file` = None
  `process` = None
  `run`()

    Run in a blocking manner. Default implementation calls wait() on the process returned by start(). Overload it if this doesn’t make sense.

  `start`()
  `stderr` = None
  `stdin` = None
  `stdout` = None
  `validate`()

    Determine if we will be able to run. Raise a ComputationUnavailableError if running will cause a crash

  `working_directory` = None

class `ScalarProperty`(molecule, units=None, details=None)

  A property whose value is a scalar

  `from_groups`(groups, units)

    By default, just get the last group matched.

`TemporaryFile`(mode='w+b', bufsize=-1, suffix='', prefix='tmp', dir=None)

  Create and return a temporary file. Arguments: ‘prefix’, ‘suffix’, ‘dir’ – as for mkstemp. ‘mode’ – the mode argument to os.fdopen (default “w+b”). ‘bufsize’ – the buffer size argument to os.fdopen (default -1). The file is created as mkstemp() would do it.

  Returns an object with a file-like interface. The file has no name, and will cease to exist when it is closed.

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

class `TensorProperty`(molecule, units=None, details=None)

  A property whose value is an n-dimensional tensor

class `Unitized`

  Abstract base class for things with units. It requires its subclasses to implement the properties ‘value’ and ‘units’. Unitized subclasses are also expected have __mul__, __div__, __truediv__, __pow__, __add__, __sub__, __neg__, __pos__, and __abs__ handle units correctly, when implemented in the given subclass.

  `in_units`(new_units)
  `units` None
  `value` None

exception `ValueNotAvailableError`

  Raised when a MolecularProperty is requested but not available for whatever reason.

class `ValueWithUnits`(value, units)

  A class for encapsulating a physical constant and it’s units.

  units : CompositeUnit or a class with Unit as its metaclass
    The units in which the value of self is to be interpreted
  `convert_to`(units)
  `in_units`(units)
  `units` = None
  `value` None

class `VectorProperty`(molecule, units=None, details=None)

  A property whose value is a vector.

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

class `acquired_lock`(lock)

  Execute code with a lock acquired before the block of code and released afterwards

`classname`(class_or_str_or_obj)

  Convenience method for getting the typename as a string from the <type ‘Something’> string sent back by str(type(obj))

`full_path`(path)

`function_alias`(alias, function)

  Alias a function as something else. Set the documentation of the new method to “Alias for <function>()” and add “Aliased as <alias>()” to the documentation of function. Not inteded to be used as a decorator.

  Examples: |

      >>> def foo(a, b, c):
      ...     '''Print a test message.'''
      ...     print "testing {0}, {1}, {2}".format(a, b, c)
      ...
      >>> foo(1, 2, 3)
      testing 1, 2, 3
      >>> bar = function_alias('bar', foo)
      >>> bar(4, 5, 6)
      testing 4, 5, 6
      >>> print bar.__doc__
      Alias for `foo()`
      >>> print foo.__doc__
      Print a test message.

      Aliased as `bar()`
      >>> baz = function_alias('baz', foo)
      >>> baz(7, 8, 9)
      testing 7, 8, 9
      >>> print foo.__doc__
      Print a test message.

      Aliased as `baz()`, `bar()`

  Inside a class

      >>> class FooBar(object):
      ...     def testfunc(self, *args):
      ...         '''Print out the args.'''
      ...         print "testing " + ', '.join(str(a) for a in args)
      ...     another_name = function_alias('another_name', testfunc)
      ...     test_func = function_alias('test_func', testfunc)
      ...
      >>> f = FooBar()
      >>> f.test_func(1, 2, 3, 4)
      testing 1, 2, 3, 4
      >>> print FooBar.test_func.__doc__
      Alias for `testfunc()`
      >>> print FooBar.testfunc.__doc__
      Print out the args.

      Aliased as `test_func()`, `another_name()`

`grouper`(n, iterable, fillvalue=None)

  group(3, ‘ABCDEFG’, ‘x’) –> ABC DEF Gxx

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`indent`(*fargs, **fkeywords)

  Alias for indented()

class `islice`

  islice(iterable, [start,] stop [, step]) –> islice object

  Return an iterator whose next() method returns selected values from an iterable. If start is specified, will skip all preceding elements; otherwise, start defaults to zero. Step defaults to one. If specified as another value, step determines how many values are skipped between successive calls. Works like a slice() on a list but returns an iterator.

  `next` None

    x.next() -> the next value, or raise StopIteration

`isunit`(unit)

  Aliased as is_unit()

`make_safe_identifier`(instr, replace_with='_')

class `partial`

  partial(func, *args, **keywords) - new function with partial application of the given arguments and keywords.

  `args` None

    tuple of arguments to future partial calls

  `func` None

    function object to use in future partial calls

  `keywords` None

    dictionary of keyword arguments to future partial calls

`pop_kwarg`(kwarg_dict, *args)

  Utility function for getting the value of a keyword argument that can be named multiple things and popping that value off of the kwarg dictionary. If the None of the keywords given are found in kwarg_dict, None is

  > returned.

  > See Also: |

  > get_multikwarg

`raises_error`(callable_obj, *args, **kwargs)

  Returns True if a call of callable with args raises an error, and False if not. Note that the callable will get called, so don’t do anything that takes a long time or changes things in a way you don’t want them to be changed. If the optional keyword argument ‘error’ is given as either an Exception subclass or an Iterable, raises_error returns True if the call of callable raises the error given or one of the errors given in the list. (The keyword argument can also be named ‘errors’). Any other keyword arguments are passed through to callable.

  Technical note: As per the Python manual, only exceptions that subclass from Exception (and not BaseException directly) will be recognized. According to the python users manual, you should never implement a user exception that subclasses from BaseException directly.

  Examples: |

      >>> raises_error(int, "5")
      False
      >>> raises_error(int, "0x5ab7", 0)
      False
      >>> raises_error(lambda x: int(x), "5")
      False
      >>> raises_error(int, "abc")
      True
      >>> raises_error(int, "abc", error = ValueError)
      True
      >>> raises_error(int, "abc", error = BufferError)
      False
      >>> raises_error(int, "abc", error = (BufferError, EnvironmentError))
      False
      >>> raises_error(int, "abc", error = [BufferError, ValueError])
      True
      >>> raises_error(float, "abc")
      True
      >>> # Use raises_error to see what errors raises_error raises
      ... # Raise a type error if the first argument is not a callable (i.e. 17(25) doesn't make sense to Python)
      ... raises_error(raises_error, 17, 25, error = TypeError)
      True
      >>> # Raise a TypeError if the error keyword argument is not a subclass of Exception
      ... raises_error(lambda x: raises_error(int, x, error = "hello world"), 25, error = TypeError)
      True
      >>> raises_error(lambda x: raises_error(int, x, error = BaseException), 25, error = TypeError)
      True

`typechecked` None

  Type checking for functions and methods.

`warn`()

  Issue a warning, or maybe ignore it or raise an exception.

`with_attributes`(**kwargs)

  Decorator allowing the assignment of attributes to a function.

`with_flexible_arguments`(required=None, optional=None, what_to_call_it=None)

  Allows the creation of functions with case insensative, alternately named keyword arguments.

  Examples: |

      >>> @with_flexible_arguments(
      ...     required=[
      ...         ('name', 'greet', 'name_to_greet'),
      ...         ('from_where', 'source')
      ...     ],
      ...     optional=[
      ...         ('greeting', 'hello_phrase', 'salutation'),
      ...         ('message',)
      ...     ]
      ... )
      ... def say_hello(name, from_where, greeting='Hello', message=''):
      ...     print(greeting + ', ' + name + ', from ' + from_where + '!' + message)
      ...
      >>> say_hello('moon', 'Earth')
      Hello, moon, from Earth!
      >>> say_hello('world', source='the moon')
      Hello, world, from the moon!
      >>> say_hello(source='France', name_to_greet='visitor', salutation='Bonjour')
      Bonjour, visitor, from France!
      >>> say_hello('earthlings', 'outer space', 'Greetings', message='  We come in peace!')
      Greetings, earthlings, from outer space!  We come in peace!

class `working_directory`(dir, permissions=0, create=False)

  Change to a certain working directory for the execution of a block of code, then change back upon (any kind of) exit.

class `ComputationDetails`(**kwargs)

  Encapsulates specifics about how the calculation was/is to be carried out, such as level of theory, basis set, program, etc. Can be subclassed for specific programs which may require special detail setting methods.

  `available_pairs`(*keys)
  classmethod `from_details`(details)

    Effectively clones details. Used internally for making a details into a ComputationDetails subclass

  classmethod `is_compatible_details`(requested, details_computed_with)
  `is_subset_of`(other)
  `is_superset_of`(other)
  `keywordify`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `keywordify_if_available`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `required_details` = []

`Methods` None

  Simple container for keyword-like objects (“sentinal values”). Can also be used as a container for sub-keywords via instance objects. Sub-keywords are case-insensative. Keywords cannot be assigned values using the value attribute (note that this means you can’t create a sub-keyword called ‘value’).

  Warning

  Since there is exactly one instance of every unique keyword (with two keywords that differ by capitalization not being unique), storing a value can have some unexpected consequences. For instance:

      >>> Hello = Keyword('Hello')
      >>> foo = Hello.World
      >>> foo.value = "good bye"
      >>> # ...some time later...
      >>> Hello.WORLD.value = "good night"
      >>> foo.value
      'good night'

  Note

  Since value, parent, _parent, parents, _name, and any of the double-underscore methods inherited from object are already attributes of Keyword objects, you can’t make sub-keywords with these names. Everything else is fair game.

  Examples: |

      >>> Hello = Keyword('Hello')
      >>> Hello.World
      Hello.World
      >>> # Any future changes in case simply refer back to the original
      >>> Hello.WoRlD
      Hello.World
      >>> # But, of course, not for the first level
      >>> hEllO.World
      Traceback (most recent call last):
         ...
      NameError: name 'hEllO' is not defined
      >>> # Multiple levels can be created at once
      >>> Hello.there.world
      Hello.there.world
      >>> Hello.there == Hello.ThErE
      True
      >>> Hello.there == Hello.ThErE.world
      False
      >>> Hello.there.WORLD == Hello.ThErE.world
      True
      >>> Hello.There.World.value = "Hello World"
      >>> Hello.THERE.WORLD.value
      'Hello World'

`Bases` None

  Simple container for keyword-like objects (“sentinal values”). Can also be used as a container for sub-keywords via instance objects. Sub-keywords are case-insensative. Keywords cannot be assigned values using the value attribute (note that this means you can’t create a sub-keyword called ‘value’).

  Warning

  Since there is exactly one instance of every unique keyword (with two keywords that differ by capitalization not being unique), storing a value can have some unexpected consequences. For instance:

      >>> Hello = Keyword('Hello')
      >>> foo = Hello.World
      >>> foo.value = "good bye"
      >>> # ...some time later...
      >>> Hello.WORLD.value = "good night"
      >>> foo.value
      'good night'

  Note

  Since value, parent, _parent, parents, _name, and any of the double-underscore methods inherited from object are already attributes of Keyword objects, you can’t make sub-keywords with these names. Everything else is fair game.

  Examples: |

      >>> Hello = Keyword('Hello')
      >>> Hello.World
      Hello.World
      >>> # Any future changes in case simply refer back to the original
      >>> Hello.WoRlD
      Hello.World
      >>> # But, of course, not for the first level
      >>> hEllO.World
      Traceback (most recent call last):
         ...
      NameError: name 'hEllO' is not defined
      >>> # Multiple levels can be created at once
      >>> Hello.there.world
      Hello.there.world
      >>> Hello.there == Hello.ThErE
      True
      >>> Hello.there == Hello.ThErE.world
      False
      >>> Hello.there.WORLD == Hello.ThErE.world
      True
      >>> Hello.There.World.value = "Hello World"
      >>> Hello.THERE.WORLD.value
      'Hello World'

`Basis` None

  Simple container for keyword-like objects (“sentinal values”). Can also be used as a container for sub-keywords via instance objects. Sub-keywords are case-insensative. Keywords cannot be assigned values using the value attribute (note that this means you can’t create a sub-keyword called ‘value’).

  Warning

  Since there is exactly one instance of every unique keyword (with two keywords that differ by capitalization not being unique), storing a value can have some unexpected consequences. For instance:

      >>> Hello = Keyword('Hello')
      >>> foo = Hello.World
      >>> foo.value = "good bye"
      >>> # ...some time later...
      >>> Hello.WORLD.value = "good night"
      >>> foo.value
      'good night'

  Note

  Since value, parent, _parent, parents, _name, and any of the double-underscore methods inherited from object are already attributes of Keyword objects, you can’t make sub-keywords with these names. Everything else is fair game.

  Examples: |

      >>> Hello = Keyword('Hello')
      >>> Hello.World
      Hello.World
      >>> # Any future changes in case simply refer back to the original
      >>> Hello.WoRlD
      Hello.World
      >>> # But, of course, not for the first level
      >>> hEllO.World
      Traceback (most recent call last):
         ...
      NameError: name 'hEllO' is not defined
      >>> # Multiple levels can be created at once
      >>> Hello.there.world
      Hello.there.world
      >>> Hello.there == Hello.ThErE
      True
      >>> Hello.there == Hello.ThErE.world
      False
      >>> Hello.there.WORLD == Hello.ThErE.world
      True
      >>> Hello.There.World.value = "Hello World"
      >>> Hello.THERE.WORLD.value
      'Hello World'

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `Computation`

  Base class for all classes encapsulating runs of external programs

  `additional_safe_directory_characters` = '+'
  `already_run`()

    Checks to see if an identical input file with an identical name has already been run in the computation’s directory to produce an output file of some sort (if that output file has errors, you probably don’t want to rerun the exact same input file, so this doesn’t do that by default. If you need to do that, call Computation.run() with the force_rerun argument set to True).

  `always_create_missing` = False
  `attribute_aliases` = {'Theory': ['Method', 'LevelOfTheory']}
  `completed` None

    True if and only if the calculation has finished running. (regardless of success or failure). Setting completed to True triggers the output parser.

  `details` = None
  `directory` = None
  `directory_template` = None
  `get_energy`(details=None)
  `get_property`(prop_class, details=None)
  `get_results`()
  `has_energy`(details=None)
  `has_property`(prop_class, details=None)
  `input_generator` = None
  `molecule` = None
  `needed_properties` None

    The types of the properties in the self.properties list.

  `needs_property`(prop)
  `output_parser` = None
  `properties` = []
  `queued` = False
  `run`(force_rerun=False, lock=None)
  `runner` = None
  classmethod `standardize_attribute`(attr)

    Convert strings to standard form for attributes. Strings with spaces, underscore_joined_strings, Uppercase_Underscore_Strings, and lowerCamelCase strings are all converted to UpperCamelCase.

    Examples: |

        >>> Computation.standardize_attribute("basis_set")
        'BasisSet'
        >>> Computation.standardize_attribute("basis set")
        'BasisSet'
        >>> Computation.standardize_attribute("basis!Set")
        'BasisSet'
        >>> # Only _ and space serve as CamelCase separators:
        >>> Computation.standardize_attribute("basis!set")
        'Basisset'
        >>> Computation.standardize_attribute("Level___of!*theory")
        'LevelOftheory'
        >>> # "Accidental" caps are not fixed...
        >>> Computation.standardize_attribute("Level___of!*tHEory")
        'LevelOftHEory'
        >>> #All caps gets translated into title case
        >>> Computation.standardize_attribute("Level&$#of__THEORY")
        'LevelofTheory'

  `start`()
  `started` = False
  `task_description`()

class `ComputationOptimizationResultGetter`
  `can_get_property_for_molecule`(molecule, property, details=None)
  `computations` = None
  `get_optimized_property_for_molecule`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_optimized_property_for_molecule`(molecule, property, details=None, verbose=False)
  `has_property_for_molecule`(molecule, property, details=None, verbose=False)

class `ComputationResultGetter`
  `add_computation`(comp)
  `can_get_property`(*fargs, **fkeywords)

    Alias for can_get_property_for_molecule()

  `can_get_property_for_molecule`(molecule, property, details=None)

    Aliased as has_property(), can_get_property()

  `computation_kwargs` = None
  `computations` = None
  `directory_series` = {}
  `get_computation_for_property`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property`(*fargs, **fkeywords)

    Alias for can_get_property_for_molecule()

  `has_property_for_molecule`(molecule, property, details=None, verbose=False)
  `known_result_getters` = {}
  `use_directory_series` = None

exception `ComputationUnavailableError`

  Raised when a computation can’t be generated either because a compatible input template can’t be found or a valid output parser can’t be found

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `OptimizationResultGetter`
  `can_optimize_property_for_molecule`(molecule, property, details=None)
  `get_optimized_property_for_molecule`(molecule, property, details=None)
  `has_optimized_property_for_molecule`(molecule, property, details=None, verbose=False)
  `known_optimizers` = {}

class `ResultGetter`

  Abstract base class for all classes that encapsulate a method of retrieving a (set of) properties of a molecule from a computational chemistry package. An instance of a ResultGetter object should know how to turn a request for a given molecular property into a Computation object (which, in turn, houses MolecularProperty objects for one or more Molecule objects). ResultGetter objects generate Computation objects. Any ResultGetter subclass should always check for an available computation on (exactly) the same molecule that already has the result available.

  `can_get_property_for_molecule`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property_for_molecule`(molecule, property, details=None, verbose=False)

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`function_alias`(alias, function)

  Alias a function as something else. Set the documentation of the new method to “Alias for <function>()” and add “Aliased as <alias>()” to the documentation of function. Not inteded to be used as a decorator.

  Examples: |

      >>> def foo(a, b, c):
      ...     '''Print a test message.'''
      ...     print "testing {0}, {1}, {2}".format(a, b, c)
      ...
      >>> foo(1, 2, 3)
      testing 1, 2, 3
      >>> bar = function_alias('bar', foo)
      >>> bar(4, 5, 6)
      testing 4, 5, 6
      >>> print bar.__doc__
      Alias for `foo()`
      >>> print foo.__doc__
      Print a test message.

      Aliased as `bar()`
      >>> baz = function_alias('baz', foo)
      >>> baz(7, 8, 9)
      testing 7, 8, 9
      >>> print foo.__doc__
      Print a test message.

      Aliased as `baz()`, `bar()`

  Inside a class

      >>> class FooBar(object):
      ...     def testfunc(self, *args):
      ...         '''Print out the args.'''
      ...         print "testing " + ', '.join(str(a) for a in args)
      ...     another_name = function_alias('another_name', testfunc)
      ...     test_func = function_alias('test_func', testfunc)
      ...
      >>> f = FooBar()
      >>> f.test_func(1, 2, 3, 4)
      testing 1, 2, 3, 4
      >>> print FooBar.test_func.__doc__
      Alias for `testfunc()`
      >>> print FooBar.testfunc.__doc__
      Print out the args.

      Aliased as `test_func()`, `another_name()`

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `ComputationDetails`(**kwargs)

  Encapsulates specifics about how the calculation was/is to be carried out, such as level of theory, basis set, program, etc. Can be subclassed for specific programs which may require special detail setting methods.

  `available_pairs`(*keys)
  classmethod `from_details`(details)

    Effectively clones details. Used internally for making a details into a ComputationDetails subclass

  classmethod `is_compatible_details`(requested, details_computed_with)
  `is_subset_of`(other)
  `is_superset_of`(other)
  `keywordify`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `keywordify_if_available`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `required_details` = []

exception `ComputationUnavailableError`

  Raised when a computation can’t be generated either because a compatible input template can’t be found or a valid output parser can’t be found

class `DetailSpecificObject`

  Superclass for classes that are compatible with specific ComputationDetail objects or any ComputationDetail object more specifically specifice than the details variable.

  `compatible_with_details`(details)
  `details` = None
  `unsupported_details` = None

class `Differentiable`

  Abstract base class for things that you are allowed to take derivatives of.

  `shape` None
  `value` None

    The value of the differentiable property. If this function is not overridden, assume that self can be added and subtracted, as well as multiplied by a float.

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `Energy`(molecule, units=None, details=None)

  The energy of a molecule.

  `default_units`

    alias of `Wavenumber`

class `EnergyUnit`

  General superclass for all energy units

  `default`

    alias of `Wavenumber`

  `reference_unit`

    alias of `Joule`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

class `InputGenerator`(computation)

  Abstract base class for classes that generate input files.

  `computation` = None
  `generate`(filename)
  `generated` = None
  `needed_properties` None
  `validate`()

    Determine if we will be able to generate an input.

class `InputGeneratorFactory`

  A collection of convenience methods for generating InputGenerator classes

  `generated_number` = 0
  classmethod `template_based_class`(filename, required_details=None, property=<object object at 0x9ad0b00>, class_name=None)

class `Iterable`

class `Keyword`(name, parent=None)

  Simple container for keyword-like objects (“sentinal values”). Can also be used as a container for sub-keywords via instance objects. Sub-keywords are case-insensative. Keywords cannot be assigned values using the value attribute (note that this means you can’t create a sub-keyword called ‘value’).

  Warning

  Since there is exactly one instance of every unique keyword (with two keywords that differ by capitalization not being unique), storing a value can have some unexpected consequences. For instance:

      >>> Hello = Keyword('Hello')
      >>> foo = Hello.World
      >>> foo.value = "good bye"
      >>> # ...some time later...
      >>> Hello.WORLD.value = "good night"
      >>> foo.value
      'good night'

  Note

  Since value, parent, _parent, parents, _name, and any of the double-underscore methods inherited from object are already attributes of Keyword objects, you can’t make sub-keywords with these names. Everything else is fair game.

  Examples: |

      >>> Hello = Keyword('Hello')
      >>> Hello.World
      Hello.World
      >>> # Any future changes in case simply refer back to the original
      >>> Hello.WoRlD
      Hello.World
      >>> # But, of course, not for the first level
      >>> hEllO.World
      Traceback (most recent call last):
         ...
      NameError: name 'hEllO' is not defined
      >>> # Multiple levels can be created at once
      >>> Hello.there.world
      Hello.there.world
      >>> Hello.there == Hello.ThErE
      True
      >>> Hello.there == Hello.ThErE.world
      False
      >>> Hello.there.WORLD == Hello.ThErE.world
      True
      >>> Hello.There.World.value = "Hello World"
      >>> Hello.THERE.WORLD.value
      'Hello World'

  `parent` None

    The keyword immediately preceding self in the heirarchical keyword notation. For instance:

        >>> Hello = Keyword('Hello')
        >>> Hello.World.parent
        Hello
        >>> Hello.There.World.parent
        Hello.There

  `parents` None

    list of all parent keywords, ordered from immediate parent to most distant

  `value` = None

class `MatrixProperty`(molecule, units=None, details=None)

  A property whose value is a matrix.

  `from_groups`(groups, units)

    Placeholder implementation to satisfy abstract class requirements. Everything is already taken care of in MatrixProperty.from_sequence

  `from_sequence`(seq, units)

    Default implementation for matrix properties; only works if seq is a MatrixRegexSequence

class `MatrixRegexSequence`(*args, **kwargs)

  Special subclass of RegexSequence that make parsing matrices easier.

  `get_matrix`()
  `transpose` = None

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `Molecule`

  Encapsulates all of the functionality and attributes of a Molecule itself.

  Signatures :
    - `Molecule(xyz_string)`
    - `Molecule(atoms)`
    - `Molecule(atom_names, cart_mat)`

  Parameters: |

  xyz_string : str
    a string in the format of a standard .xyz file
  atoms : list of Atom
    a list of Atom objects
  atom_names : list of str
    a list of atomic symbols corresponding to the rows of the cart_mat parameter
  cart_mat : Matrix
    an Nx3 Matrix of positions

  Other Parameters:

  description : str
    optional keyword argument that works with all forms. See the description attribute

  Attributes: |

  atoms : list of Atom internal_representations : list of InternalRepresentation normal_representation : NormalRepresentation cartesian_representation : CartesianRepresentation description : str

  Examples: |

  Constructor

      >>> Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])
      >>> Molecule([
      ...     Atom('H', [0,0,0]),
      ...     Atom('H', [0,0,0.75])
      ... ])
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  0.75000000 ] )
      ])
      >>> Molecule(['H','C'], Matrix([[0,0,0],[1,0.5,0]]))
      Molecule([
          Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('C', [  1.00000000,  0.50000000,  0.00000000 ] )
      ])
      >>> mol = Molecule("""
      ...     5
      ...
      ...     C        0.000000        0.000000        0.000000
      ...     H        0.000000        0.000000        1.089000
      ...     H        1.026719        0.000000       -0.363000
      ...     H       -0.513360       -0.889165       -0.363000
      ...     H       -0.513360        0.889165       -0.363000
      ... """)
      >>> mol
      Molecule([
          Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] ),
          Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] ),
          Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] ),
          Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] ),
          Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )
      ])

  Iteration

      >>> from __future__ import print_function
      >>> for atom in mol:
      ...     print(repr(atom))
      ...
      Atom('C', [  0.00000000,  0.00000000,  0.00000000 ] )
      Atom('H', [  0.00000000,  0.00000000,  1.08900000 ] )
      Atom('H', [  1.02671900,  0.00000000, -0.36300000 ] )
      Atom('H', [ -0.51336000, -0.88916500, -0.36300000 ] )
      Atom('H', [ -0.51336000,  0.88916500, -0.36300000 ] )

  `A_e` = None
  `B_e` = None
  `C_e` = None
  `a` None

    The first principal axis of rotation, a. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  classmethod `acene`(length, rx=2.42260241888759, rcc_cross=1.41, rcc_side=1.398821025, rch=1.0800004490739805)
  `atoms` = None
  `b` None

    The second principal axis of rotation, b. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `c` None

    The third principal axis of rotation, c. The positive phase is always chosen.

    Note

    This property depends directly on Molecule.principal_axes(), which is cached. See discussion of caching in A_e

  `can_get_energy`(details=None)
  `can_get_property`(property, details=None)
  `cartesian_representation` None

    The current default cartesian representation associated with the molecule. If the molecule has multiple cartesian representations, the first in the list self.cartesian_representations is returned. The setter for this property pushes the cartesian representation onto the front of the list.

    Note

    The setter does not check for uniqueness (unless it’s exactly the same object as another CartesianRepresentation). Thus, you should check to make sure the CartesianRepresentation you are assigning to the molecule is not already part of the molecule’s list of representations (to the degree of accuracy required for your particular application) before assigning. Repeatedly failing to do this check could cause runaway memory usage.

  `cartesian_units` = None
  `center_of_mass`()

    Returns a Vector giving the center of mass of the molecule in the current Cartesian representation. The units of the returned value are self.cartesian_units. .. note:

        This result of this method is cached, and the cached value gets flushed in
        `update_cartesian_representation()`.  If you change an atom's position
        (or mass) and forget to call `update_cartesian_representation()`, you may
        get some funny results for this method or any methods that depend on it,
        including `recenter()`, `reorient()`, and `principal_moments_of_inertia()`.  You
        can detect whether caching is causing problems by setting the environment variable
        `GRENDEL_NO_CACHE` to 1 and rerunning your tests.  If tests that were failing
        subsequently succeed, you probably forgot to call `update_cartesian_representation()`
        somewhere, or you were assuming that it was automatically called somewhere when
        in fact it was not getting called.

  `computations` = None
  `convert_units`(new_units)
  `default_charge` = 0
  `default_multiplicity` = 1
  `description` = None
  `displace`()
  `displacement` = None
  `displacement_description`(eq_name='eq', divider='_', delta_name='', one_based=True, include_zeros=False)
  classmethod `from_identifier`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  classmethod `from_z_matrix`(*args, **kwargs)

    TODO Document this more

    Signatures :
      - Molecule.from_z_matrix(atom1, atom2, ...)
      - Molecule.from_z_matrix(atoms, create_representation = False)

    Examples: |

        >>> Molecule.from_z_matrix("""
        ... O
        ... H1 O 1.0
        ... H2 O 1.0 H1 90.0
        ... """)
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...    [
        ...       ['H'],
        ...       ['O', 1, 0.9],
        ...       ['O', 2, 1.4, 1, 105.0],
        ...       ['H', 3, 0.9, 2, 105.0, 1, 120.0]
        ...   ]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] ),
            Atom('O', [  0.00000000,  1.35229616,  1.26234666 ] ),
            Atom('H', [ -0.75286467,  1.46479616,  1.74249095 ] )
        ])
        >>> Molecule.from_z_matrix(
        ...       ['H'],
        ...       ['O', 1, 0.9]
        ... )
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('O', [  0.00000000,  0.00000000,  0.90000000 ] )
        ])

  classmethod `get`(*args, **kwargs)

    Create a Molecule object using only the name, SMILES, InChIKey, etc.

    The easiest way to call Molecule.from_identifier() is to give it a single argument that is one of the following properties: * smiles * stdinchikey * stdinchi * ncicadd_identifier # (for FICTS, FICuS, uuuuu) * hashisy * cas_number * chemspider_id # input must be chemspider_id=1234567 * opsin_name * cir_name (These are resolved in roughly this order.) Visit the NIH CIR documentation for (some) explaination of what these identifiers are: http://cactus.nci.nih.gov/chemical/structure/documentation

    Molecule.from_identifier() can be called with any (single) keyword argument in the grendel.util.web_getter.input_identifiers list. In this form, there must be only

    This can also be called using an argument that is the value of a property and a second argument that is a list of fields to search for that property in.

    Note: Molecule.get() is a very useful alias for this.

    Examples: |

    TODO

  `get_computation_for_property`(property, details=None)
  `get_energy`(details=None, run_computation=False)
  `get_optimized_geometry`(details=None, property=None)
  `get_property`(property, details=None, run_computation=False)
  `get_stub`()
  `global_result_getters` = []
  `has_energy`()
  `has_property`(property, details=None)
  `has_same_elements`(other)

    Returns True if the elements of self correspond directly to the elements of other (i.e. self.atoms[0].element == other.atoms[0].element and self.atoms[1].element == other.atoms[1].element and ...)

  `has_same_geometry`()

    Returns True if all of the elements are the same (including isotope and nuclear spin) and the reoriented() versions of self and other have no atoms whose pairwise position difference has a magnitude greater than tol (which defaults to 1e-8 Angstroms)

    Examples: |

        >>> mol = Molecule('''
        ...     O 1.5 0.0 0.0
        ...     H 0.2 0.0 0.0
        ... ''')
        >>> m1 = Molecule('''
        ...     O 0.0 1.5 0.0
        ...     H 0.0 0.2 0.0
        ... ''')
        >>> m2 = Molecule('''
        ...     O 0.00000 0.00000 0.200000
        ...     H 0.00000 0.00000 1.500001
        ... ''')
        >>> m3 = Molecule('''
        ...     H 0.0  0.0 0.0
        ...     H 0.0 -1.3 0.0
        ... ''')
        >>> mol.has_same_geometry(m1)
        True
        >>> m1.has_same_geometry(m2)
        False
        >>> m1.has_same_geometry(m2, 1e-5)
        True
        >>> m2.has_same_geometry(mol, 1e-5)
        True
        >>> m1.has_same_geometry(m3)
        False

  `has_symmetry`()

    True if op is a valid symmetry operation on self Each coordinate of the transformed atoms must differ from the original by less than

  `index`(atom)

    Returns the index of atom in the atoms array of the molecule

    Note

    This method returns a cached property Atom.index. If you reorder the atoms in a molecule, be sure and flush this cache by setting atom._index to None for all of the atoms in the reordered molecule.

    Raises: |

    IndexError : if atom is not found in self

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> h2o = SampleMolecules['water']
        >>> atom1 = h2o[0]
        >>> atom2 = h2o[1]
        >>> atom3 = h2o[2]
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ),
            Atom('H', [  0.00000000,  0.75873400, -0.47261400 ] ),
            Atom('H', [  0.00000000, -0.75873400, -0.47261400 ] )
        ])
        >>> h2o.index(atom2)
        1
        >>> h2o.index(atom1)
        0
        >>> # It must be exactly the same instance to avoid raising an index error
        >>> h2o.index(Atom('O', [  0.00000000,  0.00000000,  0.11815400 ] ))
        Traceback (most recent call last):
            ...
        IndexError: ...

  `inertial_system`()

    Returns a tuple of the principal moments of inertia vector and the principal axes matrix.

    mol.inertial_system()

    Computes the principal moments of inertia and the principal axes.

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Returns: |

    A tuple with types (Vector, Matrix) containing the principal moments of inertia and the principal axes, respectively. These should be aligned (i.e. ret_val[0][1] corresponds to the vector ret_val[1][1])

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> i = hnco.inertial_system()
        >>> i[0]
        Vector([  0.60187342,  45.48378728,  46.0856607 ])
        >>> i[1]
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])
        >>> j = hnco.inertial_system()
        >>> i == j
        True
        >>> hnco.A_e
        28.0085955528 Wavenumber
        >>> hnco.B_e
        0.370629408869 Wavenumber
        >>> hnco.C_e
        0.365789031483 Wavenumber
        >>> hnco.a
        Vector([ 0.        ,  0.09870438,  0.9951168 ])
        >>> hnco.b
        Vector([ 0.        , -0.9951168 ,  0.09870438])
        >>> hnco.c
        Vector([ 1.,  0.,  0.])

  `internal_representation` None

    The first internal representations (of type InternalRepresentation), or None if it does not exist yet.

  `internal_representations` = None
  `inverse_mass_matrix` = None
  `inverse_sqrt_mass_matrix` = None
  `is_centered`(tol=1e-08 Angstrom, cartesian_representation=None)

    True if the center of mass is at the origin. This actually computes the vector from the origin to the center of mass and then determines if the magnitude of that vector is less than tol.

    Parameters: |

    tol : float or ValueWithUnits
      The maximum ‘off-centeredness’ that will be tolerated and still return True. If a float is given, the units are assumed to be DistanceUnit.default
    cartesian_representation : Representation or None
      Determine if the molecule is centered when represented in cartesian_representation. If None, just use the molecule’s current cartesian representation.
  `is_linear`(tol=None)

    True if the molecule is linear to within tol. All diatomics should return True.

    If tol is a ValueWithUnits and tol.units is an AngularUnit, then this method returns True only if all angles in the molecule are within tol of 180 Degrees. If tol.units is a unit-compatible with a moment of inertia (i.e. MassUnit * DistanceUnit**2 ), then this method returns True if the smallest principal moment of inertia is less than tol and the difference between the two largest principal moments of inertia is less than tol. If no units are given (i.e. tol is a float or other float-compatible unit), tol is assumed to have units of AngularUnit.default and the method proceeds as if tol.units was an AngularUnit subclass.

    Parameters: |

    tol : float or ValueWithUnits
      The linearity tolerance.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> SampleMolecules['water'].is_linear()
        False
        >>> SampleMolecules['CO2'].is_linear()
        True
        >>> SampleMolecules['Benzene'].is_linear()
        False

  `largest_difference_with`(other)
  classmethod `linear_alkane`(length, rCC=1.52999192202 Angstrom, rCH=1.09001479402 Angstrom, aCCC=109.472109383 Degree, aCCH=109.470735728 Degree)
  `linear_cutoff` = 5.0 Degree
  `mass` None
  `natoms` None
  `ninternals` None
  `normal_representation` = None
  `pmi`()

    The principal moments of inertia, as a Vector

    > Note

    > This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    > Note

    > This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    > Examples: |

    >     >>> hnco = Molecule.from_z_matrix("""
    >     ... N
    >     ... C N 1.2145
    >     ... O C 1.1634 N 172.22
    >     ... H N 1.0030 C 123.34 O 180.0
    >     ... """
    >     ... )
    >     >>> hnco.principal_moments_of_inertia()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])
    >     >>> hnco.pmi()
    >     Vector([  0.60187342,  45.48378728,  46.0856607 ])

    > See Also: |

    > principal_axes, inertial_system, A_e, B_e, C_e

    Aliased as principal_moments_of_inertia()

  `point_group` None
  `position` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `principal_axes`()

    The principal axes as column vectors in a Matrix. The Vector object mol.principal_axes()[:,i] corresponds to the i`th moment of inertia, `mol.principal_moments_of_inertia()[i].

    mol.principal_axes()

    Note

    This funtion mol.recenter() if the molecule is not centered, so any CartesianRepresentations that are not both frozen and referenced elsewhere (e.g. in a RepresentationDependentProperty) will be lost forever.

    Note

    This method is cached. See discussion of the consequences of caching in Molecule.center_of_mass()

    Examples: |

        >>> hnco = Molecule.from_z_matrix("""
        ... N
        ... C N 1.2145
        ... O C 1.1634 N 172.22
        ... H N 1.0030 C 123.34 O 180.0
        ... """
        ... )
        >>> hnco.principal_axes()
        Matrix([[ 0.        ,  0.        ,  1.        ],
                [ 0.09870438, -0.9951168 ,  0.        ],
                [ 0.9951168 ,  0.09870438,  0.        ]])

    See Also: |

    principal_moments_of_inertia, inertial_system, A_e, B_e, C_e

  `principal_moments_of_inertia`(*fargs, **fkeywords)

    Alias for pmi()

  `recenter`()

    Recenters the molecule about the center of mass This modifies the molecule in place.

    Examples: |

        >>> m = Molecule([Atom("O", [1.1, 1.3, 1.7])])
        >>> m
        Molecule([
            Atom('O', [  1.10000000,  1.30000000,  1.70000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m = Molecule(['H','H'], Matrix([[0,0,0],[1,0.0,0]]))
        >>> m
        Molecule([
            Atom('H', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  1.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> m.recenter()
        >>> m
        Molecule([
            Atom('H', [ -0.50000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.50000000,  0.00000000,  0.00000000 ] )
        ])

  `recentered`()

    Same as recenter, but makes returns a copy. self is not modified.

    Examples: |

        >>> foo = Molecule([Atom("O", [1.3, 1.7, 2.0])])
        >>> bar = foo.recentered()
        >>> foo.recenter()
        >>> foo
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] )
        ])
        >>> foo == bar
        True
        >>> foo is bar
        False

  `reorient`(representation='II')

    Reorient the molecule to align the x, y, and z axes with the principal axes of rotation.

    Parameters: |

    representation : str, optional
      Must be one of “I”, “II”, or “III”. “I” means {x,y,z} = {b,c,a}. “II” (the default) means {x,y,z} = {c,a,b}. “III” means {x,y,z} = {a,b,c}

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = SampleMolecules['quantum water']
        >>> h2o.principal_axes()
        Matrix([[-0.        ,  0.        ,  1.        ],
                [-0.53654222, -0.84387348,  0.        ],
                [-0.84387348,  0.53654222,  0.        ]])
        >>> h2o.reorient()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> # using abs to get rid of phase factor
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  0.,  1.],
                [ 1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> h2o.reorient("I")
        >>> from grendel.gmath import chopped
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 0.,  1.,  0.],
                [ 0.,  0.,  1.],
                [ 1.,  0.,  0.]])
        >>> h2o.reorient("III")
        >>> abs(chopped(h2o.principal_axes()))
        Matrix([[ 1.,  0.,  0.],
                [ 0.,  1.,  0.],
                [ 0.,  0.,  1.]])

  `reoriented`(representation='II')

    Same as reorient, but makes returns a copy. self is not modified.

    Examples: |

        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> from grendel.gmath import chopped
        >>> h2o = Molecule([
        ...    Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
        ...    Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
        ...    Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ... ])
        >>> new = h2o.reoriented()
        >>> # Use chopped to get rid of very small numerical artifacts...
        >>> chopped(new.principal_axes())
        Matrix([[ 0.,  0.,  1.],
                [-1.,  0.,  0.],
                [ 0.,  1.,  0.]])
        >>> new is h2o
        False
        >>> # original molecule is unchanged...
        >>> h2o
        Molecule([
            Atom('O', [  0.00000000,  0.00000000,  0.00000000 ] ),
            Atom('H', [  0.00000000,  0.00000000,  1.00000000 ] ),
            Atom('H', [  0.00000000, -1.00000000, -0.00000000 ] )
        ])

  `result_getters` = None
  `rotate`(axis, angle)

    Rotates the molecule about axis (a Vector) by angle

  `rotated`(axis, angle)
  `update_cartesian_representation`()
  `use_result_getter`(rg)
  `write_xyz`(filename, overwrite=False, format_str='%-3s %12.8f %12.8f %12.8f')

    Writes the Molecule to the standard xyz format.

    See `Molecule.xyz_string() for more details.

    See Also: |

    xyz_string

  `xyz` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_mat` None

    The molecule’s position as a natoms x 3 Matrix. The ordering of rows is (as expected) the same as the ordering of the Molecule.atoms list attribute. Aliased to xyz_mat and position (the latter to be “consistant-ish” with the naming in Atom.

  `xyz_string`(format_str='%-3s %12.8f %12.8f %12.8f', header=True)

    The molecule, represented as a string in standard xyz format.

    The first line will always be the number of atoms. The second line (which is a comment in the xyz specification) is filled by the description first line of the description attribute.

    Parameters: |

    format_str : str, optional
      The format to apply to the lines of the xyz output. The default is “%-3s %12.8f %12.8f %12.8f”, which should be fine for most purposes.
    header : bool, optional
      Whether or not to include the standard two-line header which is part of the standard xyz format (defaults to True)

    Examples: |

        >>> from __future__ import print_function
        >>> from grendel.chemistry import SampleMolecules, init_sample_molecules
        >>> init_sample_molecules()
        >>> print(SampleMolecules['water'].xyz_string())
        3
        CCSD(T)/aug-cc-pVTZ Water
        O     0.00000000   0.00000000   0.11815400
        H     0.00000000   0.75873400  -0.47261400
        H     0.00000000  -0.75873400  -0.47261400
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f"))
        1

        Atom:  O, x: 1.0, y: 0.50, z: 1.500
        >>> print(Molecule("O 1.0 0.5 1.5").xyz_string("Atom: %2s, x: %3.1f, y: %4.2f, z: %5.3f", False))
        Atom:  O, x: 1.0, y: 0.50, z: 1.500

class `Number`

  All numbers inherit from this class.

  If you just want to check if an argument x is a number, without caring what kind, use isinstance(x, Number).

class `OrbitalEnergies`(molecule, units=None, details=None)
  `default_units`

    alias of `Wavenumber`

class `PartiallyConstructed`(cls_to_construct, *args, **kwargs)
  Allow classes to be “partially constructed” by wrapping the class’s __init__
    and __new__ with a method that sets given attributes or appends certain keyword arguments to the initialzation call.
  `counter` = 2
  `with_args`(*args)
  `with_attributes`(**kwargs)

    Append some attributes to be set after the initialization is performed. Note that these override anything done in the class’s __init__, so don’t do anything stupid.

  `with_kwargs`(**kwargs)

class `PropertyGenerator`(filename, property, details=None, unsupported_details=None)

  Contains the filename of a template that generates the input file for the computation of a molecular property, optionally with a set of specific details for which the template is valid. This class is mostly to mirror the OutputParser and PropertyParser from the output side of things.

  `details` = None
  `filename` = None
  `property` = None

class `ScalarProperty`(molecule, units=None, details=None)

  A property whose value is a scalar

  `from_groups`(groups, units)

    By default, just get the last group matched.

class `TemplateInputGenerator`(computation)

  The simplest form of a generator. Takes a Mako-style template file, passes in the Computation object in as the argument “computation”, and runs the Mako templete engine.

  `generate`(filename)
  `property_generators` = []
  `validate`()

class `Tensor`

  Mostly a wrapper for the NumPy ndarray class. This gives us a place to put tensor-related functionality that we need but is not available in NumPy.

  `I` None
  `copy_shape`(**kwargs)

    Copy all properties of the tensor except for the data.

  `diagonal` None
  `flatten`(order='C')

    Same as numpy.ndarray.flatten, but modified to return a Vector object

    Examples: |

        >>> t = Tensor([[[1,2],[3,4]],[[5,6],[7,8]]])
        >>> t
        Tensor([[[ 1.,  2.],
                [ 3.,  4.]],

               [[ 5.,  6.],
                [ 7.,  8.]]])
        >>> t.flatten()
        Vector([ 1.,  2.,  3., ...,  6.,  7.,  8.])

  `formatted_string`(**kwargs)
  `in_units`(other_units)
  `index_range_set` = None
  `index_ranges` None

    List of pointers to IndexRange objects over which the tensor is defined.

  `indices` = None
  `is_antisymmetric`(cutoff=1e-10)
  `is_square`()
  `is_symmetric`(cutoff=1e-10)
  `is_zero`(cutoff=None)

    Returns True if all elements of self have absolute values less than cutoff, which defaults to Tensor.zero_cutoff .. note:

        `Tensor.zero_cutoff` is treated as a pseudo-class attribute for Tensor instances, meaning individual
         instances can also set a `zero_cutoff` attribute which will take precidence over the class-level
         default.

  `iter_vectors`(with_indices=False)
  `linearly_transformed`(transmat, backwards=False)
  `max_abs`()
  `name` = None
  `reindexed`(new_indices, dimensions=None, reverse=False)
  static `remove_phase_factor`(*args, **kwargs)

    Given any number of Tensor objects that are the same up to a phase factor, return a list of Tensor objects that have been. Copies are only made if necessary. The chosen phase is the one that makes the first non-zero element (in the numpy.nditer(tensor) iterator, using the cutoff keyword argument or Tensor.zero_cutoff if one is not given) positive.

  `same_tensor_cutoff` = 1e-08
  `units` = None
  `value` None

    Allows conformance with the Unitized protocol.

  `zero_cutoff` = 1e-08
  `zero_structure`(max_width=120, row_label_width=5, one_based=True, positive_char='+', zero_char='0', one_char='1', negative_char='-', cutoff=1e-10)

class `TensorProperty`(molecule, units=None, details=None)

  A property whose value is an n-dimensional tensor

class `Unitized`

  Abstract base class for things with units. It requires its subclasses to implement the properties ‘value’ and ‘units’. Unitized subclasses are also expected have __mul__, __div__, __truediv__, __pow__, __add__, __sub__, __neg__, __pos__, and __abs__ handle units correctly, when implemented in the given subclass.

  `in_units`(new_units)
  `units` None
  `value` None

exception `ValueNotAvailableError`

  Raised when a MolecularProperty is requested but not available for whatever reason.

class `ValueWithUnits`(value, units)

  A class for encapsulating a physical constant and it’s units.

  units : CompositeUnit or a class with Unit as its metaclass
    The units in which the value of self is to be interpreted
  `convert_to`(units)
  `in_units`(units)
  `units` = None
  `value` None

class `VectorProperty`(molecule, units=None, details=None)

  A property whose value is a vector.

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

`camel_to_lower`(instr, divider='_')

  Converts a CamalCase string to a lower_case_string_with_underscores If the divider argument is given, it is used instead of underscores to join words.

  Examples: |

`classname`(class_or_str_or_obj)

  Convenience method for getting the typename as a string from the <type ‘Something’> string sent back by str(type(obj))

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`isunit`(unit)

  Aliased as is_unit()

class `partial`

  partial(func, *args, **keywords) - new function with partial application of the given arguments and keywords.

  `args` None

    tuple of arguments to future partial calls

  `func` None

    function object to use in future partial calls

  `keywords` None

    dictionary of keyword arguments to future partial calls

`typechecked` None

  Type checking for functions and methods.

`warn`()

  Issue a warning, or maybe ignore it or raise an exception.

`with_attributes`(**kwargs)

  Decorator allowing the assignment of attributes to a function.

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `CachedProperty`(func)

  Decorator for properties with cached return values. The decorator creates a property that stores the return value of the method call in a variable named _[func_name] (where [func_name] is the name of the function).

  Examples: |

      >>> class Factorializer(object):
      ...
      ...    n = None
      ...
      ...    def __init__(self, n):
      ...        self.n = n
      ...
      ...    @CachedProperty
      ...    def thirty_plus_n_fact(self):
      ...        ret_val = 1
      ...        for i in xrange(2, self.n + 31):
      ...            ret_val *= i
      ...        return ret_val
      ...
      >>> f = Factorializer(3000)
      >>> # Takes some time...
      >>> var = f.thirty_plus_n_fact
      >>> # Should take no time...
      >>> for i in xrange(100):
      ...     var = f.thirty_plus_n_fact
      ...
      >>> # Be careful... Remember to invalidate the cache when the appropriate variables are updated...
      >>> f.n = 2500
      >>> # Takes no time but gives the wrong answer:
      >>> var = f.thirty_plus_n_fact
      >>> # Invalidate the cache:
      >>> f._thirty_plus_n_fact = None
      >>> # This should take some time again, but now it will get the right answer
      >>> var = f.thirty_plus_n_fact

  `cached_var_name` = None
  `func` = None
  `name` = None

class `ComputationDetails`(**kwargs)

  Encapsulates specifics about how the calculation was/is to be carried out, such as level of theory, basis set, program, etc. Can be subclassed for specific programs which may require special detail setting methods.

  `available_pairs`(*keys)
  classmethod `from_details`(details)

    Effectively clones details. Used internally for making a details into a ComputationDetails subclass

  classmethod `is_compatible_details`(requested, details_computed_with)
  `is_subset_of`(other)
  `is_superset_of`(other)
  `keywordify`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `keywordify_if_available`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `required_details` = []

exception `ComputationUnavailableError`

  Raised when a computation can’t be generated either because a compatible input template can’t be found or a valid output parser can’t be found

class `DetailSpecificObject`

  Superclass for classes that are compatible with specific ComputationDetail objects or any ComputationDetail object more specifically specifice than the details variable.

  `compatible_with_details`(details)
  `details` = None
  `unsupported_details` = None

class `Iterable`

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `OptimizedGeometryParser`(geometry_getter, **kwargs)
  `get_optimized_geometry`(file_contents)
  `get_value_for_molecule`(property, file_contents)

class `OutputParser`(computation, property_parsers=None)

  Abstract base class for classes that parse the output file for a computation.

  `computation` = None
  `molecule` None
  `needed_indices` None
  `needed_properties` None
  `parse_file`(file)
  `property_parsers` = None
  `reset`()
  `valid_parsers` = None
  `validate`()

exception `OutputParsingError`

class `PropertyParser`(property, details, units, getter=None, sequence=None, unsupported_details=None, custom_from=None)

  Encapsulates a molecular property and the code to parse it from an output file.

  `custom_from` = None
  `get_value_for_molecule`(property, file_contents)
  `getter` = None
  `parse_line`(line)
  `property` = None
  `reset`()
  `sequence` = None
  `units` = None

class `RepresentationDependentPropertyParser`(representation_getter, **kwargs)
  `get_value_and_representation`(property, file_contents)
    ..note ::
      This method ignores property.units
  `get_value_for_molecule`(property, file_contents)
  `representation_getter` = None

class `RepresentationDependentTensor`
  `first_dimension_different` = None
  `formatted_string`(**kwargs)
  `in_representation`(new_rep)
  `permutational_symmetry` = None
  `representation` None
  `secondary_representation` None
  `value` None

class `ScalarProperty`(molecule, units=None, details=None)

  A property whose value is a scalar

  `from_groups`(groups, units)

    By default, just get the last group matched.

`classname`(class_or_str_or_obj)

  Convenience method for getting the typename as a string from the <type ‘Something’> string sent back by str(type(obj))

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`deepcopy`(x, memo=None, _nil=[])

  Deep copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`isunit`(unit)

  Aliased as is_unit()

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `Queue`

  Abstract base class for queues of computations to be run.

  `computations` None

    A decorator indicating abstract properties.

    Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract properties are overridden. The abstract properties can be called using any of the normal ‘super’ call mechanisms.

    Usage:

    > class C:

    >   __metaclass__ = ABCMeta @abstractproperty def my_abstract_property(self):

    >   > ...

    This defines a read-only property; you can also define a read-write abstract property using the ‘long’ form of property declaration:

    > class C:
    >   __metaclass__ = ABCMeta def getx(self): ... def setx(self, value): ... x = abstractproperty(getx, setx)

  `enqueue`(*c)

    Add computation(s) to the queue.

  `is_finished`()

    True if all the computations on the queue are finished

  `is_started`()

    True if the queue has been started (i. e. if any of the computations have been started)

  `quiet` = False
  `run`()

    Run the queue. (Abstract method) This runs the whole queue and blocks until the run is complete. See also start

  `start`()

    Start the queue in the background and return to execution. Beware that if Python exits, the queue’s processes will be orphaned. This mode of running may not be supported by all queue types.

  `verbose` = False

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

class `abstractproperty`

  A decorator indicating abstract properties.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract properties are overridden. The abstract properties can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractproperty def my_abstract_property(self):

  >   > ...

  This defines a read-only property; you can also define a read-write abstract property using the ‘long’ form of property declaration:

  > class C:
  >   __metaclass__ = ABCMeta def getx(self): ... def setx(self, value): ... x = abstractproperty(getx, setx)

class `LocalParallelQueue`(nthreads, *computations)
  `computations` = None
  `counter` = None
  `enqueue`(*computations)
  `finish`()
  `is_finished`()
  `is_started`()
  `nthreads` = None
  `queue_manager` = None
  `run`()
  `start`()

    Run the queue in a non-blocking manner. Calling start multiple times has no effect, but also raises no warning

  `wait`()
  `waiting` = None

class `LocalSerialQueue`(*computations)

  The simplest possible queue. Runs one job at a time on the local machine.

class `ABCMeta`

  Metaclass for defining Abstract Base Classes (ABCs).

  Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

  `register`(subclass)

    Register a virtual subclass of an ABC.

class `Computation`

  Base class for all classes encapsulating runs of external programs

  `additional_safe_directory_characters` = '+'
  `already_run`()

    Checks to see if an identical input file with an identical name has already been run in the computation’s directory to produce an output file of some sort (if that output file has errors, you probably don’t want to rerun the exact same input file, so this doesn’t do that by default. If you need to do that, call Computation.run() with the force_rerun argument set to True).

  `always_create_missing` = False
  `attribute_aliases` = {'Theory': ['Method', 'LevelOfTheory']}
  `completed` None

    True if and only if the calculation has finished running. (regardless of success or failure). Setting completed to True triggers the output parser.

  `details` = None
  `directory` = None
  `directory_template` = None
  `get_energy`(details=None)
  `get_property`(prop_class, details=None)
  `get_results`()
  `has_energy`(details=None)
  `has_property`(prop_class, details=None)
  `input_generator` = None
  `molecule` = None
  `needed_properties` None

    The types of the properties in the self.properties list.

  `needs_property`(prop)
  `output_parser` = None
  `properties` = []
  `queued` = False
  `run`(force_rerun=False, lock=None)
  `runner` = None
  classmethod `standardize_attribute`(attr)

    Convert strings to standard form for attributes. Strings with spaces, underscore_joined_strings, Uppercase_Underscore_Strings, and lowerCamelCase strings are all converted to UpperCamelCase.

    Examples: |

        >>> Computation.standardize_attribute("basis_set")
        'BasisSet'
        >>> Computation.standardize_attribute("basis set")
        'BasisSet'
        >>> Computation.standardize_attribute("basis!Set")
        'BasisSet'
        >>> # Only _ and space serve as CamelCase separators:
        >>> Computation.standardize_attribute("basis!set")
        'Basisset'
        >>> Computation.standardize_attribute("Level___of!*theory")
        'LevelOftheory'
        >>> # "Accidental" caps are not fixed...
        >>> Computation.standardize_attribute("Level___of!*tHEory")
        'LevelOftHEory'
        >>> #All caps gets translated into title case
        >>> Computation.standardize_attribute("Level&$#of__THEORY")
        'LevelofTheory'

  `start`()
  `started` = False
  `task_description`()

class `ComputationOptimizationResultGetter`
  `can_get_property_for_molecule`(molecule, property, details=None)
  `computations` = None
  `get_optimized_property_for_molecule`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_optimized_property_for_molecule`(molecule, property, details=None, verbose=False)
  `has_property_for_molecule`(molecule, property, details=None, verbose=False)

class `ComputationResultGetter`
  `add_computation`(comp)
  `can_get_property`(*fargs, **fkeywords)

    Alias for can_get_property_for_molecule()

  `can_get_property_for_molecule`(molecule, property, details=None)

    Aliased as has_property(), can_get_property()

  `computation_kwargs` = None
  `computations` = None
  `directory_series` = {}
  `get_computation_for_property`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property`(*fargs, **fkeywords)

    Alias for can_get_property_for_molecule()

  `has_property_for_molecule`(molecule, property, details=None, verbose=False)
  `known_result_getters` = {}
  `use_directory_series` = None

exception `ComputationUnavailableError`

  Raised when a computation can’t be generated either because a compatible input template can’t be found or a valid output parser can’t be found

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `OptimizationResultGetter`
  `can_optimize_property_for_molecule`(molecule, property, details=None)
  `get_optimized_property_for_molecule`(molecule, property, details=None)
  `has_optimized_property_for_molecule`(molecule, property, details=None, verbose=False)
  `known_optimizers` = {}

class `ResultGetter`

  Abstract base class for all classes that encapsulate a method of retrieving a (set of) properties of a molecule from a computational chemistry package. An instance of a ResultGetter object should know how to turn a request for a given molecular property into a Computation object (which, in turn, houses MolecularProperty objects for one or more Molecule objects). ResultGetter objects generate Computation objects. Any ResultGetter subclass should always check for an available computation on (exactly) the same molecule that already has the result available.

  `can_get_property_for_molecule`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property_for_molecule`(molecule, property, details=None, verbose=False)

`abstractmethod`(funcobj)

  A decorator indicating abstract methods.

  Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms.

  Usage:

  > class C:

  >   __metaclass__ = ABCMeta @abstractmethod def my_abstract_method(self, ...):

  >   > ...

`copy`(x)

  Shallow copy operation on arbitrary Python objects.

  See the module’s __doc__ string for more info.

`function_alias`(alias, function)

  Alias a function as something else. Set the documentation of the new method to “Alias for <function>()” and add “Aliased as <alias>()” to the documentation of function. Not inteded to be used as a decorator.

  Examples: |

      >>> def foo(a, b, c):
      ...     '''Print a test message.'''
      ...     print "testing {0}, {1}, {2}".format(a, b, c)
      ...
      >>> foo(1, 2, 3)
      testing 1, 2, 3
      >>> bar = function_alias('bar', foo)
      >>> bar(4, 5, 6)
      testing 4, 5, 6
      >>> print bar.__doc__
      Alias for `foo()`
      >>> print foo.__doc__
      Print a test message.

      Aliased as `bar()`
      >>> baz = function_alias('baz', foo)
      >>> baz(7, 8, 9)
      testing 7, 8, 9
      >>> print foo.__doc__
      Print a test message.

      Aliased as `baz()`, `bar()`

  Inside a class

      >>> class FooBar(object):
      ...     def testfunc(self, *args):
      ...         '''Print out the args.'''
      ...         print "testing " + ', '.join(str(a) for a in args)
      ...     another_name = function_alias('another_name', testfunc)
      ...     test_func = function_alias('test_func', testfunc)
      ...
      >>> f = FooBar()
      >>> f.test_func(1, 2, 3, 4)
      testing 1, 2, 3, 4
      >>> print FooBar.test_func.__doc__
      Alias for `testfunc()`
      >>> print FooBar.testfunc.__doc__
      Print out the args.

      Aliased as `test_func()`, `another_name()`

class `Runner`(input_file=None, output_file=None, **kwargs)

  Abstract base class for classes that run a computation (or an equivalent task, such as submit a job to a PBS queue). Not all Computation objects need a runner; for instance XML-parsed computations are constructed in an already-run state.

  `command_sequence` = None
  `default_input_filename` = 'input.dat'
  `default_output_filename` = 'output.dat'
  `environment` = None
  `input_file` = None
  `output_file` = None
  `process` = None
  `run`()

    Run in a blocking manner. Default implementation calls wait() on the process returned by start(). Overload it if this doesn’t make sense.

  `start`()
  `stderr` = None
  `stdin` = None
  `stdout` = None
  `validate`()

    Determine if we will be able to run. Raise a ComputationUnavailableError if running will cause a crash

  `working_directory` = None

`AMU`

  alias of `AtomicMassUnit`

`AMUs`

  alias of `AtomicMassUnit`

class `Angstrom`
  classmethod `to`(other)

`Angstroms`

  alias of `Angstrom`

class `AngularUnit`

  General superclass for all angular units

  `default`

    alias of `Degree`

  `reference_unit`

    alias of `Degree`

class `AtomicMassUnit`

`AtomicMassUnits`

  alias of `AtomicMassUnit`

`AtomicUnitOfCharge`

  alias of `AtomicUnitOfElectricCharge`

`AtomicUnitOfDistance`

  alias of `Bohr`

class `AtomicUnitOfElectricCharge`

`AtomicUnitOfEnergy`

  alias of `Hartree`

class `AtomicUnitOfMass`

class `AtomicUnitOfTime`

`AtomicUnitsOfCharge`

  alias of `AtomicUnitOfElectricCharge`

`AtomicUnitsOfDistance`

  alias of `Bohr`

`AtomicUnitsOfElectricCharge`

  alias of `AtomicUnitOfElectricCharge`

`AtomicUnitsOfEnergy`

  alias of `Hartree`

`AtomicUnitsOfMass`

  alias of `AtomicUnitOfMass`

`AtomicUnitsOfTime`

  alias of `AtomicUnitOfTime`

class `AttoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`AttoAMUs`

  alias of `AttoAMU`

class `AttoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`AttoAtomicUnitsOfCharge`

  alias of `AttoAtomicUnitOfCharge`

`AttoAtomicUnitsOfDistance`

  alias of `AttoAtomicUnitOfDistance`

`AttoAtomicUnitsOfEnergy`

  alias of `AttoAtomicUnitOfEnergy`

class `AttoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

class `AttoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec8c>

`Attoangstrom`

  alias of `AttoAngstrom`

`Attoangstroms`

  alias of `AttoAngstrom`

`Attobohr`

  alias of `AttoBohr`

`Attobohrs`

  alias of `AttoBohr`

`Attocenturies`

  alias of `AttoCentury`

`Attocentury`

  alias of `AttoCentury`

`Attocoulomb`

  alias of `AttoCoulomb`

`Attocoulombs`

  alias of `AttoCoulomb`

`Attoday`

  alias of `AttoDay`

`Attodays`

  alias of `AttoDay`

`Attodecade`

  alias of `AttoDecade`

`Attodecades`

  alias of `AttoDecade`

`Attodegree`

  alias of `AttoDegree`

`Attodegrees`

  alias of `AttoDegree`

`Attogram`

  alias of `AttoGram`

`Attograms`

  alias of `AttoGram`

`Attohartree`

  alias of `AttoHartree`

`Attohartrees`

  alias of `AttoHartree`

`Attohertz`

  alias of `AttoHertz`

`Attohertzs`

  alias of `AttoHertz`

`Attohour`

  alias of `AttoHour`

`Attohours`

  alias of `AttoHour`

`Attojoule`

  alias of `AttoJoule`

`Attojoules`

  alias of `AttoJoule`

`Attometer`

  alias of `AttoMeter`

`Attometers`

  alias of `AttoMeter`

`Attomillennia`

  alias of `AttoMillennium`

`Attomillennium`

  alias of `AttoMillennium`

`Attominute`

  alias of `AttoMinute`

`Attominutes`

  alias of `AttoMinute`

`Attoradian`

  alias of `AttoRadian`

`Attoradians`

  alias of `AttoRadian`

`Attosecond`

  alias of `AttoSecond`

`Attoseconds`

  alias of `AttoSecond`

`Attowavenumber`

  alias of `AttoWavenumber`

`Attowavenumbers`

  alias of `AttoWavenumber`

`Attoweek`

  alias of `AttoWeek`

`Attoweeks`

  alias of `AttoWeek`

`Attoyear`

  alias of `AttoYear`

`Attoyears`

  alias of `AttoYear`

class `Bohr`

`Bohrs`

  alias of `Bohr`

class `CentiAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`CentiAMUs`

  alias of `CentiAMU`

class `CentiAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`CentiAtomicUnitsOfCharge`

  alias of `CentiAtomicUnitOfCharge`

`CentiAtomicUnitsOfDistance`

  alias of `CentiAtomicUnitOfDistance`

`CentiAtomicUnitsOfEnergy`

  alias of `CentiAtomicUnitOfEnergy`

class `CentiBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

class `CentiYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebcc>

`Centiangstrom`

  alias of `CentiAngstrom`

`Centiangstroms`

  alias of `CentiAngstrom`

`Centibohr`

  alias of `CentiBohr`

`Centibohrs`

  alias of `CentiBohr`

`Centicenturies`

  alias of `CentiCentury`

`Centicentury`

  alias of `CentiCentury`

`Centicoulomb`

  alias of `CentiCoulomb`

`Centicoulombs`

  alias of `CentiCoulomb`

`Centiday`

  alias of `CentiDay`

`Centidays`

  alias of `CentiDay`

`Centidecade`

  alias of `CentiDecade`

`Centidecades`

  alias of `CentiDecade`

`Centidegree`

  alias of `CentiDegree`

`Centidegrees`

  alias of `CentiDegree`

`Centigram`

  alias of `CentiGram`

`Centigrams`

  alias of `CentiGram`

`Centihartree`

  alias of `CentiHartree`

`Centihartrees`

  alias of `CentiHartree`

`Centihertz`

  alias of `CentiHertz`

`Centihertzs`

  alias of `CentiHertz`

`Centihour`

  alias of `CentiHour`

`Centihours`

  alias of `CentiHour`

`Centijoule`

  alias of `CentiJoule`

`Centijoules`

  alias of `CentiJoule`

`Centimeter`

  alias of `CentiMeter`

`Centimeters`

  alias of `CentiMeter`

`Centimillennia`

  alias of `CentiMillennium`

`Centimillennium`

  alias of `CentiMillennium`

`Centiminute`

  alias of `CentiMinute`

`Centiminutes`

  alias of `CentiMinute`

`Centiradian`

  alias of `CentiRadian`

`Centiradians`

  alias of `CentiRadian`

`Centisecond`

  alias of `CentiSecond`

`Centiseconds`

  alias of `CentiSecond`

`Centiwavenumber`

  alias of `CentiWavenumber`

`Centiwavenumbers`

  alias of `CentiWavenumber`

`Centiweek`

  alias of `CentiWeek`

`Centiweeks`

  alias of `CentiWeek`

`Centiyear`

  alias of `CentiYear`

`Centiyears`

  alias of `CentiYear`

`Centuries`

  alias of `Century`

class `Century`

class `CompositeUnit`(numer_units_or_composed, denom_units=None, coeff=1.0)

  A class for composite units, e.g. Joules/Angstrom^2

  `coefficient` = 1.0
  `composed` = None
  `genre` None

    Analog of Unit.genre. Always returns CompositeUnit

  `name` None

    The name of the composite unit, as a product of base units

  `reduced`(using_units=None)

    Reduce the composite unit into the fewest base units possible.

        >>> from grendel.util.units import *
        >>> (Angstroms**2/Bohr).reduced()
        (1.88972612457 Angstrom)
        >>> (Degree / (Bohr**2)).reduced()
        Degree / Bohr**2
        >>> (Degree / (Bohr*Meter)).reduced()
        (5.2917721092e-11 Degree / Bohr**2)

  `to`()

class `ComputationDetails`(**kwargs)

  Encapsulates specifics about how the calculation was/is to be carried out, such as level of theory, basis set, program, etc. Can be subclassed for specific programs which may require special detail setting methods.

  `available_pairs`(*keys)
  classmethod `from_details`(details)

    Effectively clones details. Used internally for making a details into a ComputationDetails subclass

  classmethod `is_compatible_details`(requested, details_computed_with)
  `is_subset_of`(other)
  `is_superset_of`(other)
  `keywordify`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `keywordify_if_available`(format, *keys)

    Mostly for use by templates, this method returns a string of keyword-value pairs in using the given format for each argument in the argument list. format should use the str.format() protocol from the python standard library with the named slots {key} where the keyword name should go and {value} where the value of the detail should go (or, if the value of the detail is a Keyword object, the contents of the value attribute for that Keyword, or, if the value attribute for the keyword is not defined, the _name attribute for the Keyword object in question.

    Aliased as keywordify

  `required_details` = []

class `Coulomb`
  classmethod `to`(other)

`Coulombs`

  alias of `Coulomb`

class `Day`

`Days`

  alias of `Day`

class `DecaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`DecaAMUs`

  alias of `DecaAMU`

class `DecaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`DecaAtomicUnitsOfCharge`

  alias of `DecaAtomicUnitOfCharge`

`DecaAtomicUnitsOfDistance`

  alias of `DecaAtomicUnitOfDistance`

`DecaAtomicUnitsOfEnergy`

  alias of `DecaAtomicUnitOfEnergy`

class `DecaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

class `DecaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb8c>

`Decaangstrom`

  alias of `DecaAngstrom`

`Decaangstroms`

  alias of `DecaAngstrom`

`Decabohr`

  alias of `DecaBohr`

`Decabohrs`

  alias of `DecaBohr`

`Decacenturies`

  alias of `DecaCentury`

`Decacentury`

  alias of `DecaCentury`

`Decacoulomb`

  alias of `DecaCoulomb`

`Decacoulombs`

  alias of `DecaCoulomb`

`Decaday`

  alias of `DecaDay`

`Decadays`

  alias of `DecaDay`

class `Decade`

`Decadecade`

  alias of `DecaDecade`

`Decadecades`

  alias of `DecaDecade`

`Decadegree`

  alias of `DecaDegree`

`Decadegrees`

  alias of `DecaDegree`

`Decades`

  alias of `Decade`

`Decagram`

  alias of `DecaGram`

`Decagrams`

  alias of `DecaGram`

`Decahartree`

  alias of `DecaHartree`

`Decahartrees`

  alias of `DecaHartree`

`Decahertz`

  alias of `DecaHertz`

`Decahertzs`

  alias of `DecaHertz`

`Decahour`

  alias of `DecaHour`

`Decahours`

  alias of `DecaHour`

`Decajoule`

  alias of `DecaJoule`

`Decajoules`

  alias of `DecaJoule`

`Decameter`

  alias of `DecaMeter`

`Decameters`

  alias of `DecaMeter`

`Decamillennia`

  alias of `DecaMillennium`

`Decamillennium`

  alias of `DecaMillennium`

`Decaminute`

  alias of `DecaMinute`

`Decaminutes`

  alias of `DecaMinute`

`Decaradian`

  alias of `DecaRadian`

`Decaradians`

  alias of `DecaRadian`

`Decasecond`

  alias of `DecaSecond`

`Decaseconds`

  alias of `DecaSecond`

`Decawavenumber`

  alias of `DecaWavenumber`

`Decawavenumbers`

  alias of `DecaWavenumber`

`Decaweek`

  alias of `DecaWeek`

`Decaweeks`

  alias of `DecaWeek`

`Decayear`

  alias of `DecaYear`

`Decayears`

  alias of `DecaYear`

class `DeciAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`DeciAMUs`

  alias of `DeciAMU`

class `DeciAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`DeciAtomicUnitsOfCharge`

  alias of `DeciAtomicUnitOfCharge`

`DeciAtomicUnitsOfDistance`

  alias of `DeciAtomicUnitOfDistance`

`DeciAtomicUnitsOfEnergy`

  alias of `DeciAtomicUnitOfEnergy`

class `DeciBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

class `DeciYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebac>

`Deciangstrom`

  alias of `DeciAngstrom`

`Deciangstroms`

  alias of `DeciAngstrom`

`Decibohr`

  alias of `DeciBohr`

`Decibohrs`

  alias of `DeciBohr`

`Decicenturies`

  alias of `DeciCentury`

`Decicentury`

  alias of `DeciCentury`

`Decicoulomb`

  alias of `DeciCoulomb`

`Decicoulombs`

  alias of `DeciCoulomb`

`Deciday`

  alias of `DeciDay`

`Decidays`

  alias of `DeciDay`

`Decidecade`

  alias of `DeciDecade`

`Decidecades`

  alias of `DeciDecade`

`Decidegree`

  alias of `DeciDegree`

`Decidegrees`

  alias of `DeciDegree`

`Decigram`

  alias of `DeciGram`

`Decigrams`

  alias of `DeciGram`

`Decihartree`

  alias of `DeciHartree`

`Decihartrees`

  alias of `DeciHartree`

`Decihertz`

  alias of `DeciHertz`

`Decihertzs`

  alias of `DeciHertz`

`Decihour`

  alias of `DeciHour`

`Decihours`

  alias of `DeciHour`

`Decijoule`

  alias of `DeciJoule`

`Decijoules`

  alias of `DeciJoule`

`Decimeter`

  alias of `DeciMeter`

`Decimeters`

  alias of `DeciMeter`

`Decimillennia`

  alias of `DeciMillennium`

`Decimillennium`

  alias of `DeciMillennium`

`Deciminute`

  alias of `DeciMinute`

`Deciminutes`

  alias of `DeciMinute`

`Deciradian`

  alias of `DeciRadian`

`Deciradians`

  alias of `DeciRadian`

`Decisecond`

  alias of `DeciSecond`

`Deciseconds`

  alias of `DeciSecond`

`Deciwavenumber`

  alias of `DeciWavenumber`

`Deciwavenumbers`

  alias of `DeciWavenumber`

`Deciweek`

  alias of `DeciWeek`

`Deciweeks`

  alias of `DeciWeek`

`Deciyear`

  alias of `DeciYear`

`Deciyears`

  alias of `DeciYear`

class `Degree`
  classmethod `to`(other)

`Degrees`

  alias of `Degree`

class `DistanceUnit`

  General superclass for all distance units

  `default`

    alias of `Angstrom`

  `reference_unit`

    alias of `Angstrom`

class `ElectricChargeUnit`

  General superclass for all units of electric charge

  `default`

    alias of `Coulomb`

  `reference_unit`

    alias of `Coulomb`

class `Energy`(molecule, units=None, details=None)

  The energy of a molecule.

  `default_units`

    alias of `Wavenumber`

class `EnergyUnit`

  General superclass for all energy units

  `default`

    alias of `Wavenumber`

  `reference_unit`

    alias of `Joule`

class `ExaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`ExaAMUs`

  alias of `ExaAMU`

class `ExaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`ExaAtomicUnitsOfCharge`

  alias of `ExaAtomicUnitOfCharge`

`ExaAtomicUnitsOfDistance`

  alias of `ExaAtomicUnitOfDistance`

`ExaAtomicUnitsOfEnergy`

  alias of `ExaAtomicUnitOfEnergy`

class `ExaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

class `ExaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaac>

`Exaangstrom`

  alias of `ExaAngstrom`

`Exaangstroms`

  alias of `ExaAngstrom`

`Exabohr`

  alias of `ExaBohr`

`Exabohrs`

  alias of `ExaBohr`

`Exacenturies`

  alias of `ExaCentury`

`Exacentury`

  alias of `ExaCentury`

`Exacoulomb`

  alias of `ExaCoulomb`

`Exacoulombs`

  alias of `ExaCoulomb`

`Exaday`

  alias of `ExaDay`

`Exadays`

  alias of `ExaDay`

`Exadecade`

  alias of `ExaDecade`

`Exadecades`

  alias of `ExaDecade`

`Exadegree`

  alias of `ExaDegree`

`Exadegrees`

  alias of `ExaDegree`

`Exagram`

  alias of `ExaGram`

`Exagrams`

  alias of `ExaGram`

`Exahartree`

  alias of `ExaHartree`

`Exahartrees`

  alias of `ExaHartree`

`Exahertz`

  alias of `ExaHertz`

`Exahertzs`

  alias of `ExaHertz`

`Exahour`

  alias of `ExaHour`

`Exahours`

  alias of `ExaHour`

`Exajoule`

  alias of `ExaJoule`

`Exajoules`

  alias of `ExaJoule`

`Exameter`

  alias of `ExaMeter`

`Exameters`

  alias of `ExaMeter`

`Examillennia`

  alias of `ExaMillennium`

`Examillennium`

  alias of `ExaMillennium`

`Examinute`

  alias of `ExaMinute`

`Examinutes`

  alias of `ExaMinute`

`Exaradian`

  alias of `ExaRadian`

`Exaradians`

  alias of `ExaRadian`

`Exasecond`

  alias of `ExaSecond`

`Exaseconds`

  alias of `ExaSecond`

`Exawavenumber`

  alias of `ExaWavenumber`

`Exawavenumbers`

  alias of `ExaWavenumber`

`Exaweek`

  alias of `ExaWeek`

`Exaweeks`

  alias of `ExaWeek`

`Exayear`

  alias of `ExaYear`

`Exayears`

  alias of `ExaYear`

class `FemtoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`FemtoAMUs`

  alias of `FemtoAMU`

class `FemtoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`FemtoAtomicUnitsOfCharge`

  alias of `FemtoAtomicUnitOfCharge`

`FemtoAtomicUnitsOfDistance`

  alias of `FemtoAtomicUnitOfDistance`

`FemtoAtomicUnitsOfEnergy`

  alias of `FemtoAtomicUnitOfEnergy`

class `FemtoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

class `FemtoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec6c>

`Femtoangstrom`

  alias of `FemtoAngstrom`

`Femtoangstroms`

  alias of `FemtoAngstrom`

`Femtobohr`

  alias of `FemtoBohr`

`Femtobohrs`

  alias of `FemtoBohr`

`Femtocenturies`

  alias of `FemtoCentury`

`Femtocentury`

  alias of `FemtoCentury`

`Femtocoulomb`

  alias of `FemtoCoulomb`

`Femtocoulombs`

  alias of `FemtoCoulomb`

`Femtoday`

  alias of `FemtoDay`

`Femtodays`

  alias of `FemtoDay`

`Femtodecade`

  alias of `FemtoDecade`

`Femtodecades`

  alias of `FemtoDecade`

`Femtodegree`

  alias of `FemtoDegree`

`Femtodegrees`

  alias of `FemtoDegree`

`Femtogram`

  alias of `FemtoGram`

`Femtograms`

  alias of `FemtoGram`

`Femtohartree`

  alias of `FemtoHartree`

`Femtohartrees`

  alias of `FemtoHartree`

`Femtohertz`

  alias of `FemtoHertz`

`Femtohertzs`

  alias of `FemtoHertz`

`Femtohour`

  alias of `FemtoHour`

`Femtohours`

  alias of `FemtoHour`

`Femtojoule`

  alias of `FemtoJoule`

`Femtojoules`

  alias of `FemtoJoule`

`Femtometer`

  alias of `FemtoMeter`

`Femtometers`

  alias of `FemtoMeter`

`Femtomillennia`

  alias of `FemtoMillennium`

`Femtomillennium`

  alias of `FemtoMillennium`

`Femtominute`

  alias of `FemtoMinute`

`Femtominutes`

  alias of `FemtoMinute`

`Femtoradian`

  alias of `FemtoRadian`

`Femtoradians`

  alias of `FemtoRadian`

`Femtosecond`

  alias of `FemtoSecond`

`Femtoseconds`

  alias of `FemtoSecond`

`Femtowavenumber`

  alias of `FemtoWavenumber`

`Femtowavenumbers`

  alias of `FemtoWavenumber`

`Femtoweek`

  alias of `FemtoWeek`

`Femtoweeks`

  alias of `FemtoWeek`

`Femtoyear`

  alias of `FemtoYear`

`Femtoyears`

  alias of `FemtoYear`

class `GigaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`GigaAMUs`

  alias of `GigaAMU`

class `GigaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`GigaAtomicUnitsOfCharge`

  alias of `GigaAtomicUnitOfCharge`

`GigaAtomicUnitsOfDistance`

  alias of `GigaAtomicUnitOfDistance`

`GigaAtomicUnitsOfEnergy`

  alias of `GigaAtomicUnitOfEnergy`

class `GigaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

class `GigaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb0c>

`Gigaangstrom`

  alias of `GigaAngstrom`

`Gigaangstroms`

  alias of `GigaAngstrom`

`Gigabohr`

  alias of `GigaBohr`

`Gigabohrs`

  alias of `GigaBohr`

`Gigacenturies`

  alias of `GigaCentury`

`Gigacentury`

  alias of `GigaCentury`

`Gigacoulomb`

  alias of `GigaCoulomb`

`Gigacoulombs`

  alias of `GigaCoulomb`

`Gigaday`

  alias of `GigaDay`

`Gigadays`

  alias of `GigaDay`

`Gigadecade`

  alias of `GigaDecade`

`Gigadecades`

  alias of `GigaDecade`

`Gigadegree`

  alias of `GigaDegree`

`Gigadegrees`

  alias of `GigaDegree`

`Gigagram`

  alias of `GigaGram`

`Gigagrams`

  alias of `GigaGram`

`Gigahartree`

  alias of `GigaHartree`

`Gigahartrees`

  alias of `GigaHartree`

`Gigahertz`

  alias of `GigaHertz`

`Gigahertzs`

  alias of `GigaHertz`

`Gigahour`

  alias of `GigaHour`

`Gigahours`

  alias of `GigaHour`

`Gigajoule`

  alias of `GigaJoule`

`Gigajoules`

  alias of `GigaJoule`

`Gigameter`

  alias of `GigaMeter`

`Gigameters`

  alias of `GigaMeter`

`Gigamillennia`

  alias of `GigaMillennium`

`Gigamillennium`

  alias of `GigaMillennium`

`Gigaminute`

  alias of `GigaMinute`

`Gigaminutes`

  alias of `GigaMinute`

`Gigaradian`

  alias of `GigaRadian`

`Gigaradians`

  alias of `GigaRadian`

`Gigasecond`

  alias of `GigaSecond`

`Gigaseconds`

  alias of `GigaSecond`

`Gigawavenumber`

  alias of `GigaWavenumber`

`Gigawavenumbers`

  alias of `GigaWavenumber`

`Gigaweek`

  alias of `GigaWeek`

`Gigaweeks`

  alias of `GigaWeek`

`Gigayear`

  alias of `GigaYear`

`Gigayears`

  alias of `GigaYear`

class `Gram`
  classmethod `to`(other)

`Grams`

  alias of `Gram`

class `Hartree`

`Hartrees`

  alias of `Hartree`

class `HectoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`HectoAMUs`

  alias of `HectoAMU`

class `HectoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`HectoAtomicUnitsOfCharge`

  alias of `HectoAtomicUnitOfCharge`

`HectoAtomicUnitsOfDistance`

  alias of `HectoAtomicUnitOfDistance`

`HectoAtomicUnitsOfEnergy`

  alias of `HectoAtomicUnitOfEnergy`

class `HectoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

class `HectoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb6c>

`Hectoangstrom`

  alias of `HectoAngstrom`

`Hectoangstroms`

  alias of `HectoAngstrom`

`Hectobohr`

  alias of `HectoBohr`

`Hectobohrs`

  alias of `HectoBohr`

`Hectocenturies`

  alias of `HectoCentury`

`Hectocentury`

  alias of `HectoCentury`

`Hectocoulomb`

  alias of `HectoCoulomb`

`Hectocoulombs`

  alias of `HectoCoulomb`

`Hectoday`

  alias of `HectoDay`

`Hectodays`

  alias of `HectoDay`

`Hectodecade`

  alias of `HectoDecade`

`Hectodecades`

  alias of `HectoDecade`

`Hectodegree`

  alias of `HectoDegree`

`Hectodegrees`

  alias of `HectoDegree`

`Hectogram`

  alias of `HectoGram`

`Hectograms`

  alias of `HectoGram`

`Hectohartree`

  alias of `HectoHartree`

`Hectohartrees`

  alias of `HectoHartree`

`Hectohertz`

  alias of `HectoHertz`

`Hectohertzs`

  alias of `HectoHertz`

`Hectohour`

  alias of `HectoHour`

`Hectohours`

  alias of `HectoHour`

`Hectojoule`

  alias of `HectoJoule`

`Hectojoules`

  alias of `HectoJoule`

`Hectometer`

  alias of `HectoMeter`

`Hectometers`

  alias of `HectoMeter`

`Hectomillennia`

  alias of `HectoMillennium`

`Hectomillennium`

  alias of `HectoMillennium`

`Hectominute`

  alias of `HectoMinute`

`Hectominutes`

  alias of `HectoMinute`

`Hectoradian`

  alias of `HectoRadian`

`Hectoradians`

  alias of `HectoRadian`

`Hectosecond`

  alias of `HectoSecond`

`Hectoseconds`

  alias of `HectoSecond`

`Hectowavenumber`

  alias of `HectoWavenumber`

`Hectowavenumbers`

  alias of `HectoWavenumber`

`Hectoweek`

  alias of `HectoWeek`

`Hectoweeks`

  alias of `HectoWeek`

`Hectoyear`

  alias of `HectoYear`

`Hectoyears`

  alias of `HectoYear`

class `Hertz`

`Hertzs`

  alias of `Hertz`

class `Hour`

`Hours`

  alias of `Hour`

exception `IncompatibleUnitsError`(unit1, unit2)

  Exception for attempted incompatible unit conversions

exception `InvalidLegacyXMLFileError`

class `Joule`
  classmethod `to`(other)

`Joules`

  alias of `Joule`

`KCalPerMol`

  alias of `KiloCaloriePerMol`

`KCalsPerMol`

  alias of `KiloCaloriePerMol`

`KcalPerMol`

  alias of `KiloCaloriePerMol`

`KcalsPerMol`

  alias of `KiloCaloriePerMol`

class `KiloAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`KiloAMUs`

  alias of `KiloAMU`

class `KiloAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`KiloAtomicUnitsOfCharge`

  alias of `KiloAtomicUnitOfCharge`

`KiloAtomicUnitsOfDistance`

  alias of `KiloAtomicUnitOfDistance`

`KiloAtomicUnitsOfEnergy`

  alias of `KiloAtomicUnitOfEnergy`

class `KiloBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloCaloriePerMol`

`KiloCaloriePerMole`

  alias of `KiloCaloriePerMol`

`KiloCaloriePerMols`

  alias of `KiloCaloriePerMol`

`KiloCaloriesPerMol`

  alias of `KiloCaloriePerMol`

class `KiloCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloJoulePerMol`

`KiloJoulesPerMol`

  alias of `KiloJoulePerMol`

class `KiloKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

class `KiloYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb4c>

`Kiloangstrom`

  alias of `KiloAngstrom`

`Kiloangstroms`

  alias of `KiloAngstrom`

`Kilobohr`

  alias of `KiloBohr`

`Kilobohrs`

  alias of `KiloBohr`

`Kilocenturies`

  alias of `KiloCentury`

`Kilocentury`

  alias of `KiloCentury`

`Kilocoulomb`

  alias of `KiloCoulomb`

`Kilocoulombs`

  alias of `KiloCoulomb`

`Kiloday`

  alias of `KiloDay`

`Kilodays`

  alias of `KiloDay`

`Kilodecade`

  alias of `KiloDecade`

`Kilodecades`

  alias of `KiloDecade`

`Kilodegree`

  alias of `KiloDegree`

`Kilodegrees`

  alias of `KiloDegree`

`Kilogram`

  alias of `KiloGram`

`Kilograms`

  alias of `KiloGram`

`Kilohartree`

  alias of `KiloHartree`

`Kilohartrees`

  alias of `KiloHartree`

`Kilohertz`

  alias of `KiloHertz`

`Kilohertzs`

  alias of `KiloHertz`

`Kilohour`

  alias of `KiloHour`

`Kilohours`

  alias of `KiloHour`

`Kilojoule`

  alias of `KiloJoule`

`Kilojoules`

  alias of `KiloJoule`

`Kilometer`

  alias of `KiloMeter`

`Kilometers`

  alias of `KiloMeter`

`Kilomillennia`

  alias of `KiloMillennium`

`Kilomillennium`

  alias of `KiloMillennium`

`Kilominute`

  alias of `KiloMinute`

`Kilominutes`

  alias of `KiloMinute`

`Kiloradian`

  alias of `KiloRadian`

`Kiloradians`

  alias of `KiloRadian`

`Kilosecond`

  alias of `KiloSecond`

`Kiloseconds`

  alias of `KiloSecond`

`Kilowavenumber`

  alias of `KiloWavenumber`

`Kilowavenumbers`

  alias of `KiloWavenumber`

`Kiloweek`

  alias of `KiloWeek`

`Kiloweeks`

  alias of `KiloWeek`

`Kiloyear`

  alias of `KiloYear`

`Kiloyears`

  alias of `KiloYear`

class `LegacyXMLResultGetter`(comparison_representation, *files)
  `can_get_property_for_molecule`(molecule, property, details=None)
  `files` = None
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property_for_molecule`(molecule, property, details=None, verbose=True)
  `properties` = None
  `properties_for_molecules` = None

class `MassUnit`

  General superclass for all units of mass

  `default`

    alias of `AtomicMassUnit`

  `reference_unit`

    alias of `Gram`

class `MegaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`MegaAMUs`

  alias of `MegaAMU`

class `MegaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`MegaAtomicUnitsOfCharge`

  alias of `MegaAtomicUnitOfCharge`

`MegaAtomicUnitsOfDistance`

  alias of `MegaAtomicUnitOfDistance`

`MegaAtomicUnitsOfEnergy`

  alias of `MegaAtomicUnitOfEnergy`

class `MegaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

class `MegaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceb2c>

`Megaangstrom`

  alias of `MegaAngstrom`

`Megaangstroms`

  alias of `MegaAngstrom`

`Megabohr`

  alias of `MegaBohr`

`Megabohrs`

  alias of `MegaBohr`

`Megacenturies`

  alias of `MegaCentury`

`Megacentury`

  alias of `MegaCentury`

`Megacoulomb`

  alias of `MegaCoulomb`

`Megacoulombs`

  alias of `MegaCoulomb`

`Megaday`

  alias of `MegaDay`

`Megadays`

  alias of `MegaDay`

`Megadecade`

  alias of `MegaDecade`

`Megadecades`

  alias of `MegaDecade`

`Megadegree`

  alias of `MegaDegree`

`Megadegrees`

  alias of `MegaDegree`

`Megagram`

  alias of `MegaGram`

`Megagrams`

  alias of `MegaGram`

`Megahartree`

  alias of `MegaHartree`

`Megahartrees`

  alias of `MegaHartree`

`Megahertz`

  alias of `MegaHertz`

`Megahertzs`

  alias of `MegaHertz`

`Megahour`

  alias of `MegaHour`

`Megahours`

  alias of `MegaHour`

`Megajoule`

  alias of `MegaJoule`

`Megajoules`

  alias of `MegaJoule`

`Megameter`

  alias of `MegaMeter`

`Megameters`

  alias of `MegaMeter`

`Megamillennia`

  alias of `MegaMillennium`

`Megamillennium`

  alias of `MegaMillennium`

`Megaminute`

  alias of `MegaMinute`

`Megaminutes`

  alias of `MegaMinute`

`Megaradian`

  alias of `MegaRadian`

`Megaradians`

  alias of `MegaRadian`

`Megasecond`

  alias of `MegaSecond`

`Megaseconds`

  alias of `MegaSecond`

`Megawavenumber`

  alias of `MegaWavenumber`

`Megawavenumbers`

  alias of `MegaWavenumber`

`Megaweek`

  alias of `MegaWeek`

`Megaweeks`

  alias of `MegaWeek`

`Megayear`

  alias of `MegaYear`

`Megayears`

  alias of `MegaYear`

class `Meter`

`Meters`

  alias of `Meter`

class `MicroAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`MicroAMUs`

  alias of `MicroAMU`

class `MicroAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`MicroAtomicUnitsOfCharge`

  alias of `MicroAtomicUnitOfCharge`

`MicroAtomicUnitsOfDistance`

  alias of `MicroAtomicUnitOfDistance`

`MicroAtomicUnitsOfEnergy`

  alias of `MicroAtomicUnitOfEnergy`

class `MicroBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

class `MicroYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec0c>

`Microangstrom`

  alias of `MicroAngstrom`

`Microangstroms`

  alias of `MicroAngstrom`

`Microbohr`

  alias of `MicroBohr`

`Microbohrs`

  alias of `MicroBohr`

`Microcenturies`

  alias of `MicroCentury`

`Microcentury`

  alias of `MicroCentury`

`Microcoulomb`

  alias of `MicroCoulomb`

`Microcoulombs`

  alias of `MicroCoulomb`

`Microday`

  alias of `MicroDay`

`Microdays`

  alias of `MicroDay`

`Microdecade`

  alias of `MicroDecade`

`Microdecades`

  alias of `MicroDecade`

`Microdegree`

  alias of `MicroDegree`

`Microdegrees`

  alias of `MicroDegree`

`Microgram`

  alias of `MicroGram`

`Micrograms`

  alias of `MicroGram`

`Microhartree`

  alias of `MicroHartree`

`Microhartrees`

  alias of `MicroHartree`

`Microhertz`

  alias of `MicroHertz`

`Microhertzs`

  alias of `MicroHertz`

`Microhour`

  alias of `MicroHour`

`Microhours`

  alias of `MicroHour`

`Microjoule`

  alias of `MicroJoule`

`Microjoules`

  alias of `MicroJoule`

`Micrometer`

  alias of `MicroMeter`

`Micrometers`

  alias of `MicroMeter`

`Micromillennia`

  alias of `MicroMillennium`

`Micromillennium`

  alias of `MicroMillennium`

`Microminute`

  alias of `MicroMinute`

`Microminutes`

  alias of `MicroMinute`

`Microradian`

  alias of `MicroRadian`

`Microradians`

  alias of `MicroRadian`

`Microsecond`

  alias of `MicroSecond`

`Microseconds`

  alias of `MicroSecond`

`Microwavenumber`

  alias of `MicroWavenumber`

`Microwavenumbers`

  alias of `MicroWavenumber`

`Microweek`

  alias of `MicroWeek`

`Microweeks`

  alias of `MicroWeek`

`Microyear`

  alias of `MicroYear`

`Microyears`

  alias of `MicroYear`

`Millennia`

  alias of `Millennium`

class `Millennium`

class `MilliAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`MilliAMUs`

  alias of `MilliAMU`

class `MilliAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`MilliAtomicUnitsOfCharge`

  alias of `MilliAtomicUnitOfCharge`

`MilliAtomicUnitsOfDistance`

  alias of `MilliAtomicUnitOfDistance`

`MilliAtomicUnitsOfEnergy`

  alias of `MilliAtomicUnitOfEnergy`

class `MilliBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

class `MilliYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cebec>

`Milliangstrom`

  alias of `MilliAngstrom`

`Milliangstroms`

  alias of `MilliAngstrom`

`Millibohr`

  alias of `MilliBohr`

`Millibohrs`

  alias of `MilliBohr`

`Millicenturies`

  alias of `MilliCentury`

`Millicentury`

  alias of `MilliCentury`

`Millicoulomb`

  alias of `MilliCoulomb`

`Millicoulombs`

  alias of `MilliCoulomb`

`Milliday`

  alias of `MilliDay`

`Millidays`

  alias of `MilliDay`

`Millidecade`

  alias of `MilliDecade`

`Millidecades`

  alias of `MilliDecade`

`Millidegree`

  alias of `MilliDegree`

`Millidegrees`

  alias of `MilliDegree`

`Milligram`

  alias of `MilliGram`

`Milligrams`

  alias of `MilliGram`

`Millihartree`

  alias of `MilliHartree`

`Millihartrees`

  alias of `MilliHartree`

`Millihertz`

  alias of `MilliHertz`

`Millihertzs`

  alias of `MilliHertz`

`Millihour`

  alias of `MilliHour`

`Millihours`

  alias of `MilliHour`

`Millijoule`

  alias of `MilliJoule`

`Millijoules`

  alias of `MilliJoule`

`Millimeter`

  alias of `MilliMeter`

`Millimeters`

  alias of `MilliMeter`

`Millimillennia`

  alias of `MilliMillennium`

`Millimillennium`

  alias of `MilliMillennium`

`Milliminute`

  alias of `MilliMinute`

`Milliminutes`

  alias of `MilliMinute`

`Milliradian`

  alias of `MilliRadian`

`Milliradians`

  alias of `MilliRadian`

`Millisecond`

  alias of `MilliSecond`

`Milliseconds`

  alias of `MilliSecond`

`Milliwavenumber`

  alias of `MilliWavenumber`

`Milliwavenumbers`

  alias of `MilliWavenumber`

`Milliweek`

  alias of `MilliWeek`

`Milliweeks`

  alias of `MilliWeek`

`Milliyear`

  alias of `MilliYear`

`Milliyears`

  alias of `MilliYear`

class `Minute`

`Minutes`

  alias of `Minute`

class `MolecularProperty`(molecule, units=None, details=None)

  Abstract base class for all properties

  Attributes: |

  molecule : Molecule units : CompositeUnit or class with Unit metaclass

  `clear_value`()
  `default_units` = None
  `details` = None
  `from_groups`(groups, units)

    Retrieve the value of the property from a tuple of groups matched in a RegexSequence. See RegexSequence.groups()

  `from_sequence`(seq, units)

    Retrieve the value of the property from a RegexSequence object that has already been used on a file. By default, this just calls self.from_groups() with seq.groups(flatten) where flatten comes from self.from_groups.flatten.

  `get_value`(*args, **kwargs)

    The new paradigm for obtaining values. Call the callable instance attribute getter with the arguments and keyword arguments passed in.

  `getter` = None
  `has_value`()
  classmethod `in_units`(units)
  static `is_same_property`(prop1, prop2)
  `molecule` = None
  `property_type` None
  static `property_type_of`(cls_or_inst)
  `units` = None
  `value` None

    The value of the molecular property.

  `value_with_units` None

class `MoleculeDict`
  `default` = None
  `default_factory` = None
  `equality_digits` = 7
  `hash_digits` = 6
  `items`()
  `iteritems`()
  `iterkeys`()
  `itervalues`()
  `key_representation` = None
  `keys`()
  `update`(**kwargs)
  `values`()

class `MoleculeStub`(*args, **kwargs)

  The exact same thing as the parent Molecule class (for now, anyway), but used for holding specifications of molecules that can later be replaced by a full molecule class (so things like, for instance, the calculations attribute won’t be filled in, but later if the geometry is found to match, the class using the MoleculeStub in some list can replace the stub with the full Molecule instance upon matching.

  `charge_specified` = None
  `eq_precision` = 7
  `hash_precision` = 5
  `multiplicity_specified` = None
  classmethod `stub_for`(molecule)
  `units_specified` = None

class `NanoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`NanoAMUs`

  alias of `NanoAMU`

class `NanoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`NanoAtomicUnitsOfCharge`

  alias of `NanoAtomicUnitOfCharge`

`NanoAtomicUnitsOfDistance`

  alias of `NanoAtomicUnitOfDistance`

`NanoAtomicUnitsOfEnergy`

  alias of `NanoAtomicUnitOfEnergy`

class `NanoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

class `NanoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec2c>

`Nanoangstrom`

  alias of `NanoAngstrom`

`Nanoangstroms`

  alias of `NanoAngstrom`

`Nanobohr`

  alias of `NanoBohr`

`Nanobohrs`

  alias of `NanoBohr`

`Nanocenturies`

  alias of `NanoCentury`

`Nanocentury`

  alias of `NanoCentury`

`Nanocoulomb`

  alias of `NanoCoulomb`

`Nanocoulombs`

  alias of `NanoCoulomb`

`Nanoday`

  alias of `NanoDay`

`Nanodays`

  alias of `NanoDay`

`Nanodecade`

  alias of `NanoDecade`

`Nanodecades`

  alias of `NanoDecade`

`Nanodegree`

  alias of `NanoDegree`

`Nanodegrees`

  alias of `NanoDegree`

`Nanogram`

  alias of `NanoGram`

`Nanograms`

  alias of `NanoGram`

`Nanohartree`

  alias of `NanoHartree`

`Nanohartrees`

  alias of `NanoHartree`

`Nanohertz`

  alias of `NanoHertz`

`Nanohertzs`

  alias of `NanoHertz`

`Nanohour`

  alias of `NanoHour`

`Nanohours`

  alias of `NanoHour`

`Nanojoule`

  alias of `NanoJoule`

`Nanojoules`

  alias of `NanoJoule`

`Nanometer`

  alias of `NanoMeter`

`Nanometers`

  alias of `NanoMeter`

`Nanomillennia`

  alias of `NanoMillennium`

`Nanomillennium`

  alias of `NanoMillennium`

`Nanominute`

  alias of `NanoMinute`

`Nanominutes`

  alias of `NanoMinute`

`Nanoradian`

  alias of `NanoRadian`

`Nanoradians`

  alias of `NanoRadian`

`Nanosecond`

  alias of `NanoSecond`

`Nanoseconds`

  alias of `NanoSecond`

`Nanowavenumber`

  alias of `NanoWavenumber`

`Nanowavenumbers`

  alias of `NanoWavenumber`

`Nanoweek`

  alias of `NanoWeek`

`Nanoweeks`

  alias of `NanoWeek`

`Nanoyear`

  alias of `NanoYear`

`Nanoyears`

  alias of `NanoYear`

class `PetaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`PetaAMUs`

  alias of `PetaAMU`

class `PetaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`PetaAtomicUnitsOfCharge`

  alias of `PetaAtomicUnitOfCharge`

`PetaAtomicUnitsOfDistance`

  alias of `PetaAtomicUnitOfDistance`

`PetaAtomicUnitsOfEnergy`

  alias of `PetaAtomicUnitOfEnergy`

class `PetaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

class `PetaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceacc>

`Petaangstrom`

  alias of `PetaAngstrom`

`Petaangstroms`

  alias of `PetaAngstrom`

`Petabohr`

  alias of `PetaBohr`

`Petabohrs`

  alias of `PetaBohr`

`Petacenturies`

  alias of `PetaCentury`

`Petacentury`

  alias of `PetaCentury`

`Petacoulomb`

  alias of `PetaCoulomb`

`Petacoulombs`

  alias of `PetaCoulomb`

`Petaday`

  alias of `PetaDay`

`Petadays`

  alias of `PetaDay`

`Petadecade`

  alias of `PetaDecade`

`Petadecades`

  alias of `PetaDecade`

`Petadegree`

  alias of `PetaDegree`

`Petadegrees`

  alias of `PetaDegree`

`Petagram`

  alias of `PetaGram`

`Petagrams`

  alias of `PetaGram`

`Petahartree`

  alias of `PetaHartree`

`Petahartrees`

  alias of `PetaHartree`

`Petahertz`

  alias of `PetaHertz`

`Petahertzs`

  alias of `PetaHertz`

`Petahour`

  alias of `PetaHour`

`Petahours`

  alias of `PetaHour`

`Petajoule`

  alias of `PetaJoule`

`Petajoules`

  alias of `PetaJoule`

`Petameter`

  alias of `PetaMeter`

`Petameters`

  alias of `PetaMeter`

`Petamillennia`

  alias of `PetaMillennium`

`Petamillennium`

  alias of `PetaMillennium`

`Petaminute`

  alias of `PetaMinute`

`Petaminutes`

  alias of `PetaMinute`

`Petaradian`

  alias of `PetaRadian`

`Petaradians`

  alias of `PetaRadian`

`Petasecond`

  alias of `PetaSecond`

`Petaseconds`

  alias of `PetaSecond`

`Petawavenumber`

  alias of `PetaWavenumber`

`Petawavenumbers`

  alias of `PetaWavenumber`

`Petaweek`

  alias of `PetaWeek`

`Petaweeks`

  alias of `PetaWeek`

`Petayear`

  alias of `PetaYear`

`Petayears`

  alias of `PetaYear`

class `PicoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`PicoAMUs`

  alias of `PicoAMU`

class `PicoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`PicoAtomicUnitsOfCharge`

  alias of `PicoAtomicUnitOfCharge`

`PicoAtomicUnitsOfDistance`

  alias of `PicoAtomicUnitOfDistance`

`PicoAtomicUnitsOfEnergy`

  alias of `PicoAtomicUnitOfEnergy`

class `PicoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

class `PicoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cec4c>

`Picoangstrom`

  alias of `PicoAngstrom`

`Picoangstroms`

  alias of `PicoAngstrom`

`Picobohr`

  alias of `PicoBohr`

`Picobohrs`

  alias of `PicoBohr`

`Picocenturies`

  alias of `PicoCentury`

`Picocentury`

  alias of `PicoCentury`

`Picocoulomb`

  alias of `PicoCoulomb`

`Picocoulombs`

  alias of `PicoCoulomb`

`Picoday`

  alias of `PicoDay`

`Picodays`

  alias of `PicoDay`

`Picodecade`

  alias of `PicoDecade`

`Picodecades`

  alias of `PicoDecade`

`Picodegree`

  alias of `PicoDegree`

`Picodegrees`

  alias of `PicoDegree`

`Picogram`

  alias of `PicoGram`

`Picograms`

  alias of `PicoGram`

`Picohartree`

  alias of `PicoHartree`

`Picohartrees`

  alias of `PicoHartree`

`Picohertz`

  alias of `PicoHertz`

`Picohertzs`

  alias of `PicoHertz`

`Picohour`

  alias of `PicoHour`

`Picohours`

  alias of `PicoHour`

`Picojoule`

  alias of `PicoJoule`

`Picojoules`

  alias of `PicoJoule`

`Picometer`

  alias of `PicoMeter`

`Picometers`

  alias of `PicoMeter`

`Picomillennia`

  alias of `PicoMillennium`

`Picomillennium`

  alias of `PicoMillennium`

`Picominute`

  alias of `PicoMinute`

`Picominutes`

  alias of `PicoMinute`

`Picoradian`

  alias of `PicoRadian`

`Picoradians`

  alias of `PicoRadian`

`Picosecond`

  alias of `PicoSecond`

`Picoseconds`

  alias of `PicoSecond`

`Picowavenumber`

  alias of `PicoWavenumber`

`Picowavenumbers`

  alias of `PicoWavenumber`

`Picoweek`

  alias of `PicoWeek`

`Picoweeks`

  alias of `PicoWeek`

`Picoyear`

  alias of `PicoYear`

`Picoyears`

  alias of `PicoYear`

exception `PropertyUnavailableError`

class `Radian`

`Radians`

  alias of `Radian`

`ReadOnlyAttribute` None

  A read-only attribute. See SpecialAttribute for initialization variables standard to all SpecialAttribute subclasses.

  Attributes: |

  error_text : str
    The text for the error raised when setting of the attribute is attempted. Defaults to “cannot set read-only attribute”

class `ResultGetter`

  Abstract base class for all classes that encapsulate a method of retrieving a (set of) properties of a molecule from a computational chemistry package. An instance of a ResultGetter object should know how to turn a request for a given molecular property into a Computation object (which, in turn, houses MolecularProperty objects for one or more Molecule objects). ResultGetter objects generate Computation objects. Any ResultGetter subclass should always check for an available computation on (exactly) the same molecule that already has the result available.

  `can_get_property_for_molecule`(molecule, property, details=None)
  `get_property_for_molecule`(molecule, property, details=None)
  `has_property_for_molecule`(molecule, property, details=None, verbose=False)

class `Second`
  classmethod `to`(other)

`Seconds`

  alias of `Second`

class `TeraAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`TeraAMUs`

  alias of `TeraAMU`

class `TeraAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`TeraAtomicUnitsOfCharge`

  alias of `TeraAtomicUnitOfCharge`

`TeraAtomicUnitsOfDistance`

  alias of `TeraAtomicUnitOfDistance`

`TeraAtomicUnitsOfEnergy`

  alias of `TeraAtomicUnitOfEnergy`

class `TeraBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

class `TeraYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceaec>

`Teraangstrom`

  alias of `TeraAngstrom`

`Teraangstroms`

  alias of `TeraAngstrom`

`Terabohr`

  alias of `TeraBohr`

`Terabohrs`

  alias of `TeraBohr`

`Teracenturies`

  alias of `TeraCentury`

`Teracentury`

  alias of `TeraCentury`

`Teracoulomb`

  alias of `TeraCoulomb`

`Teracoulombs`

  alias of `TeraCoulomb`

`Teraday`

  alias of `TeraDay`

`Teradays`

  alias of `TeraDay`

`Teradecade`

  alias of `TeraDecade`

`Teradecades`

  alias of `TeraDecade`

`Teradegree`

  alias of `TeraDegree`

`Teradegrees`

  alias of `TeraDegree`

`Teragram`

  alias of `TeraGram`

`Teragrams`

  alias of `TeraGram`

`Terahartree`

  alias of `TeraHartree`

`Terahartrees`

  alias of `TeraHartree`

`Terahertz`

  alias of `TeraHertz`

`Terahertzs`

  alias of `TeraHertz`

`Terahour`

  alias of `TeraHour`

`Terahours`

  alias of `TeraHour`

`Terajoule`

  alias of `TeraJoule`

`Terajoules`

  alias of `TeraJoule`

`Terameter`

  alias of `TeraMeter`

`Terameters`

  alias of `TeraMeter`

`Teramillennia`

  alias of `TeraMillennium`

`Teramillennium`

  alias of `TeraMillennium`

`Teraminute`

  alias of `TeraMinute`

`Teraminutes`

  alias of `TeraMinute`

`Teraradian`

  alias of `TeraRadian`

`Teraradians`

  alias of `TeraRadian`

`Terasecond`

  alias of `TeraSecond`

`Teraseconds`

  alias of `TeraSecond`

`Terawavenumber`

  alias of `TeraWavenumber`

`Terawavenumbers`

  alias of `TeraWavenumber`

`Teraweek`

  alias of `TeraWeek`

`Teraweeks`

  alias of `TeraWeek`

`Terayear`

  alias of `TeraYear`

`Terayears`

  alias of `TeraYear`

class `TimeUnit`

  General superclass for all time units

  `default`

    alias of `Second`

  `reference_unit`

    alias of `Second`

class `Unit`(name, bases, dct)

  Metaclass for a general unit of something.

  `genre` None
  `genre_check`(other)
  `known_units` = ['Angstrom', 'Angstroms', YottaAngstrom, ZettaAngstrom, ExaAngstrom, PetaAngstrom, TeraAngstrom, GigaAngstrom, MegaAngstrom, KiloAngstrom, HectoAngstrom, DecaAngstrom, DeciAngstrom, CentiAngstrom, MilliAngstrom, MicroAngstrom, NanoAngstrom, PicoAngstrom, FemtoAngstrom, AttoAngstrom, ZeptoAngstrom, YoctoAngstrom, 'Bohr', 'Bohrs', YottaBohr, ZettaBohr, ExaBohr, PetaBohr, TeraBohr, GigaBohr, MegaBohr, KiloBohr, HectoBohr, DecaBohr, DeciBohr, CentiBohr, MilliBohr, MicroBohr, NanoBohr, PicoBohr, FemtoBohr, AttoBohr, ZeptoBohr, YoctoBohr, 'YottaAtomicUnitOfDistance', YottaAtomicUnitOfDistance, 'ZettaAtomicUnitOfDistance', ZettaAtomicUnitOfDistance, 'ExaAtomicUnitOfDistance', ExaAtomicUnitOfDistance, 'PetaAtomicUnitOfDistance', PetaAtomicUnitOfDistance, 'TeraAtomicUnitOfDistance', TeraAtomicUnitOfDistance, 'GigaAtomicUnitOfDistance', GigaAtomicUnitOfDistance, 'MegaAtomicUnitOfDistance', MegaAtomicUnitOfDistance, 'KiloAtomicUnitOfDistance', KiloAtomicUnitOfDistance, 'HectoAtomicUnitOfDistance', HectoAtomicUnitOfDistance, 'DecaAtomicUnitOfDistance', DecaAtomicUnitOfDistance, 'DeciAtomicUnitOfDistance', DeciAtomicUnitOfDistance, 'CentiAtomicUnitOfDistance', CentiAtomicUnitOfDistance, 'MilliAtomicUnitOfDistance', MilliAtomicUnitOfDistance, 'MicroAtomicUnitOfDistance', MicroAtomicUnitOfDistance, 'NanoAtomicUnitOfDistance', NanoAtomicUnitOfDistance, 'PicoAtomicUnitOfDistance', PicoAtomicUnitOfDistance, 'FemtoAtomicUnitOfDistance', FemtoAtomicUnitOfDistance, 'AttoAtomicUnitOfDistance', AttoAtomicUnitOfDistance, 'ZeptoAtomicUnitOfDistance', ZeptoAtomicUnitOfDistance, 'YoctoAtomicUnitOfDistance', YoctoAtomicUnitOfDistance, 'Meter', 'Meters', YottaMeter, ZettaMeter, ExaMeter, PetaMeter, TeraMeter, GigaMeter, MegaMeter, KiloMeter, HectoMeter, DecaMeter, DeciMeter, CentiMeter, MilliMeter, MicroMeter, NanoMeter, PicoMeter, FemtoMeter, AttoMeter, ZeptoMeter, YoctoMeter, 'Degree', 'Degrees', YottaDegree, ZettaDegree, ExaDegree, PetaDegree, TeraDegree, GigaDegree, MegaDegree, KiloDegree, HectoDegree, DecaDegree, DeciDegree, CentiDegree, MilliDegree, MicroDegree, NanoDegree, PicoDegree, FemtoDegree, AttoDegree, ZeptoDegree, YoctoDegree, 'Radian', 'Radians', YottaRadian, ZettaRadian, ExaRadian, PetaRadian, TeraRadian, GigaRadian, MegaRadian, KiloRadian, HectoRadian, DecaRadian, DeciRadian, CentiRadian, MilliRadian, MicroRadian, NanoRadian, PicoRadian, FemtoRadian, AttoRadian, ZeptoRadian, YoctoRadian, 'Joule', 'Joules', YottaJoule, ZettaJoule, ExaJoule, PetaJoule, TeraJoule, GigaJoule, MegaJoule, KiloJoule, HectoJoule, DecaJoule, DeciJoule, CentiJoule, MilliJoule, MicroJoule, NanoJoule, PicoJoule, FemtoJoule, AttoJoule, ZeptoJoule, YoctoJoule, 'Wavenumber', 'Wavenumbers', YottaWavenumber, ZettaWavenumber, ExaWavenumber, PetaWavenumber, TeraWavenumber, GigaWavenumber, MegaWavenumber, KiloWavenumber, HectoWavenumber, DecaWavenumber, DeciWavenumber, CentiWavenumber, MilliWavenumber, MicroWavenumber, NanoWavenumber, PicoWavenumber, FemtoWavenumber, AttoWavenumber, ZeptoWavenumber, YoctoWavenumber, 'Hertz', 'Hertzs', YottaHertz, ZettaHertz, ExaHertz, PetaHertz, TeraHertz, GigaHertz, MegaHertz, KiloHertz, HectoHertz, DecaHertz, DeciHertz, CentiHertz, MilliHertz, MicroHertz, NanoHertz, PicoHertz, FemtoHertz, AttoHertz, ZeptoHertz, YoctoHertz, 'Hartree', 'Hartrees', YottaHartree, ZettaHartree, ExaHartree, PetaHartree, TeraHartree, GigaHartree, MegaHartree, KiloHartree, HectoHartree, DecaHartree, DeciHartree, CentiHartree, MilliHartree, MicroHartree, NanoHartree, PicoHartree, FemtoHartree, AttoHartree, ZeptoHartree, YoctoHartree, 'YottaAtomicUnitOfEnergy', YottaAtomicUnitOfEnergy, 'ZettaAtomicUnitOfEnergy', ZettaAtomicUnitOfEnergy, 'ExaAtomicUnitOfEnergy', ExaAtomicUnitOfEnergy, 'PetaAtomicUnitOfEnergy', PetaAtomicUnitOfEnergy, 'TeraAtomicUnitOfEnergy', TeraAtomicUnitOfEnergy, 'GigaAtomicUnitOfEnergy', GigaAtomicUnitOfEnergy, 'MegaAtomicUnitOfEnergy', MegaAtomicUnitOfEnergy, 'KiloAtomicUnitOfEnergy', KiloAtomicUnitOfEnergy, 'HectoAtomicUnitOfEnergy', HectoAtomicUnitOfEnergy, 'DecaAtomicUnitOfEnergy', DecaAtomicUnitOfEnergy, 'DeciAtomicUnitOfEnergy', DeciAtomicUnitOfEnergy, 'CentiAtomicUnitOfEnergy', CentiAtomicUnitOfEnergy, 'MilliAtomicUnitOfEnergy', MilliAtomicUnitOfEnergy, 'MicroAtomicUnitOfEnergy', MicroAtomicUnitOfEnergy, 'NanoAtomicUnitOfEnergy', NanoAtomicUnitOfEnergy, 'PicoAtomicUnitOfEnergy', PicoAtomicUnitOfEnergy, 'FemtoAtomicUnitOfEnergy', FemtoAtomicUnitOfEnergy, 'AttoAtomicUnitOfEnergy', AttoAtomicUnitOfEnergy, 'ZeptoAtomicUnitOfEnergy', ZeptoAtomicUnitOfEnergy, 'YoctoAtomicUnitOfEnergy', YoctoAtomicUnitOfEnergy, 'KiloCaloriePerMol', 'KiloCaloriePerMols', 'KiloJoulePerMol', 'KiloJoulesPerMol', YottaKiloJoulePerMol, ZettaKiloJoulePerMol, ExaKiloJoulePerMol, PetaKiloJoulePerMol, TeraKiloJoulePerMol, GigaKiloJoulePerMol, MegaKiloJoulePerMol, KiloKiloJoulePerMol, HectoKiloJoulePerMol, DecaKiloJoulePerMol, DeciKiloJoulePerMol, CentiKiloJoulePerMol, MilliKiloJoulePerMol, MicroKiloJoulePerMol, NanoKiloJoulePerMol, PicoKiloJoulePerMol, FemtoKiloJoulePerMol, AttoKiloJoulePerMol, ZeptoKiloJoulePerMol, YoctoKiloJoulePerMol, 'Second', 'Seconds', YottaSecond, ZettaSecond, ExaSecond, PetaSecond, TeraSecond, GigaSecond, MegaSecond, KiloSecond, HectoSecond, DecaSecond, DeciSecond, CentiSecond, MilliSecond, MicroSecond, NanoSecond, PicoSecond, FemtoSecond, AttoSecond, ZeptoSecond, YoctoSecond, 'AtomicUnitOfTime', 'AtomicUnitsOfTime', YottaAtomicUnitOfTime, ZettaAtomicUnitOfTime, ExaAtomicUnitOfTime, PetaAtomicUnitOfTime, TeraAtomicUnitOfTime, GigaAtomicUnitOfTime, MegaAtomicUnitOfTime, KiloAtomicUnitOfTime, HectoAtomicUnitOfTime, DecaAtomicUnitOfTime, DeciAtomicUnitOfTime, CentiAtomicUnitOfTime, MilliAtomicUnitOfTime, MicroAtomicUnitOfTime, NanoAtomicUnitOfTime, PicoAtomicUnitOfTime, FemtoAtomicUnitOfTime, AttoAtomicUnitOfTime, ZeptoAtomicUnitOfTime, YoctoAtomicUnitOfTime, 'Minute', 'Minutes', YottaMinute, ZettaMinute, ExaMinute, PetaMinute, TeraMinute, GigaMinute, MegaMinute, KiloMinute, HectoMinute, DecaMinute, DeciMinute, CentiMinute, MilliMinute, MicroMinute, NanoMinute, PicoMinute, FemtoMinute, AttoMinute, ZeptoMinute, YoctoMinute, 'Hour', 'Hours', YottaHour, ZettaHour, ExaHour, PetaHour, TeraHour, GigaHour, MegaHour, KiloHour, HectoHour, DecaHour, DeciHour, CentiHour, MilliHour, MicroHour, NanoHour, PicoHour, FemtoHour, AttoHour, ZeptoHour, YoctoHour, 'Day', 'Days', YottaDay, ZettaDay, ExaDay, PetaDay, TeraDay, GigaDay, MegaDay, KiloDay, HectoDay, DecaDay, DeciDay, CentiDay, MilliDay, MicroDay, NanoDay, PicoDay, FemtoDay, AttoDay, ZeptoDay, YoctoDay, 'Week', 'Weeks', YottaWeek, ZettaWeek, ExaWeek, PetaWeek, TeraWeek, GigaWeek, MegaWeek, KiloWeek, HectoWeek, DecaWeek, DeciWeek, CentiWeek, MilliWeek, MicroWeek, NanoWeek, PicoWeek, FemtoWeek, AttoWeek, ZeptoWeek, YoctoWeek, 'Year', 'Years', YottaYear, ZettaYear, ExaYear, PetaYear, TeraYear, GigaYear, MegaYear, KiloYear, HectoYear, DecaYear, DeciYear, CentiYear, MilliYear, MicroYear, NanoYear, PicoYear, FemtoYear, AttoYear, ZeptoYear, YoctoYear, 'Decade', 'Decades', YottaDecade, ZettaDecade, ExaDecade, PetaDecade, TeraDecade, GigaDecade, MegaDecade, KiloDecade, HectoDecade, DecaDecade, DeciDecade, CentiDecade, MilliDecade, MicroDecade, NanoDecade, PicoDecade, FemtoDecade, AttoDecade, ZeptoDecade, YoctoDecade, 'Century', 'Centuries', YottaCentury, ZettaCentury, ExaCentury, PetaCentury, TeraCentury, GigaCentury, MegaCentury, KiloCentury, HectoCentury, DecaCentury, DeciCentury, CentiCentury, MilliCentury, MicroCentury, NanoCentury, PicoCentury, FemtoCentury, AttoCentury, ZeptoCentury, YoctoCentury, 'Millennium', 'Millennia', YottaMillennium, ZettaMillennium, ExaMillennium, PetaMillennium, TeraMillennium, GigaMillennium, MegaMillennium, KiloMillennium, HectoMillennium, DecaMillennium, DeciMillennium, CentiMillennium, MilliMillennium, MicroMillennium, NanoMillennium, PicoMillennium, FemtoMillennium, AttoMillennium, ZeptoMillennium, YoctoMillennium, 'Coulomb', 'Coulombs', YottaCoulomb, ZettaCoulomb, ExaCoulomb, PetaCoulomb, TeraCoulomb, GigaCoulomb, MegaCoulomb, KiloCoulomb, HectoCoulomb, DecaCoulomb, DeciCoulomb, CentiCoulomb, MilliCoulomb, MicroCoulomb, NanoCoulomb, PicoCoulomb, FemtoCoulomb, AttoCoulomb, ZeptoCoulomb, YoctoCoulomb, 'AtomicUnitOfElectricCharge', 'AtomicUnitsOfElectricCharge', YottaAtomicUnitOfElectricCharge, ZettaAtomicUnitOfElectricCharge, ExaAtomicUnitOfElectricCharge, PetaAtomicUnitOfElectricCharge, TeraAtomicUnitOfElectricCharge, GigaAtomicUnitOfElectricCharge, MegaAtomicUnitOfElectricCharge, KiloAtomicUnitOfElectricCharge, HectoAtomicUnitOfElectricCharge, DecaAtomicUnitOfElectricCharge, DeciAtomicUnitOfElectricCharge, CentiAtomicUnitOfElectricCharge, MilliAtomicUnitOfElectricCharge, MicroAtomicUnitOfElectricCharge, NanoAtomicUnitOfElectricCharge, PicoAtomicUnitOfElectricCharge, FemtoAtomicUnitOfElectricCharge, AttoAtomicUnitOfElectricCharge, ZeptoAtomicUnitOfElectricCharge, YoctoAtomicUnitOfElectricCharge, 'YottaAtomicUnitOfCharge', YottaAtomicUnitOfCharge, 'ZettaAtomicUnitOfCharge', ZettaAtomicUnitOfCharge, 'ExaAtomicUnitOfCharge', ExaAtomicUnitOfCharge, 'PetaAtomicUnitOfCharge', PetaAtomicUnitOfCharge, 'TeraAtomicUnitOfCharge', TeraAtomicUnitOfCharge, 'GigaAtomicUnitOfCharge', GigaAtomicUnitOfCharge, 'MegaAtomicUnitOfCharge', MegaAtomicUnitOfCharge, 'KiloAtomicUnitOfCharge', KiloAtomicUnitOfCharge, 'HectoAtomicUnitOfCharge', HectoAtomicUnitOfCharge, 'DecaAtomicUnitOfCharge', DecaAtomicUnitOfCharge, 'DeciAtomicUnitOfCharge', DeciAtomicUnitOfCharge, 'CentiAtomicUnitOfCharge', CentiAtomicUnitOfCharge, 'MilliAtomicUnitOfCharge', MilliAtomicUnitOfCharge, 'MicroAtomicUnitOfCharge', MicroAtomicUnitOfCharge, 'NanoAtomicUnitOfCharge', NanoAtomicUnitOfCharge, 'PicoAtomicUnitOfCharge', PicoAtomicUnitOfCharge, 'FemtoAtomicUnitOfCharge', FemtoAtomicUnitOfCharge, 'AttoAtomicUnitOfCharge', AttoAtomicUnitOfCharge, 'ZeptoAtomicUnitOfCharge', ZeptoAtomicUnitOfCharge, 'YoctoAtomicUnitOfCharge', YoctoAtomicUnitOfCharge, 'Gram', 'Grams', YottaGram, ZettaGram, ExaGram, PetaGram, TeraGram, GigaGram, MegaGram, KiloGram, HectoGram, DecaGram, DeciGram, CentiGram, MilliGram, MicroGram, NanoGram, PicoGram, FemtoGram, AttoGram, ZeptoGram, YoctoGram, 'AtomicMassUnit', 'AtomicMassUnits', YottaAtomicMassUnit, ZettaAtomicMassUnit, ExaAtomicMassUnit, PetaAtomicMassUnit, TeraAtomicMassUnit, GigaAtomicMassUnit, MegaAtomicMassUnit, KiloAtomicMassUnit, HectoAtomicMassUnit, DecaAtomicMassUnit, DeciAtomicMassUnit, CentiAtomicMassUnit, MilliAtomicMassUnit, MicroAtomicMassUnit, NanoAtomicMassUnit, PicoAtomicMassUnit, FemtoAtomicMassUnit, AttoAtomicMassUnit, ZeptoAtomicMassUnit, YoctoAtomicMassUnit, 'YottaAMU', YottaAMU, 'ZettaAMU', ZettaAMU, 'ExaAMU', ExaAMU, 'PetaAMU', PetaAMU, 'TeraAMU', TeraAMU, 'GigaAMU', GigaAMU, 'MegaAMU', MegaAMU, 'KiloAMU', KiloAMU, 'HectoAMU', HectoAMU, 'DecaAMU', DecaAMU, 'DeciAMU', DeciAMU, 'CentiAMU', CentiAMU, 'MilliAMU', MilliAMU, 'MicroAMU', MicroAMU, 'NanoAMU', NanoAMU, 'PicoAMU', PicoAMU, 'FemtoAMU', FemtoAMU, 'AttoAMU', AttoAMU, 'ZeptoAMU', ZeptoAMU, 'YoctoAMU', YoctoAMU, 'AtomicUnitOfMass', 'AtomicUnitsOfMass', YottaAtomicUnitOfMass, ZettaAtomicUnitOfMass, ExaAtomicUnitOfMass, PetaAtomicUnitOfMass, TeraAtomicUnitOfMass, GigaAtomicUnitOfMass, MegaAtomicUnitOfMass, KiloAtomicUnitOfMass, HectoAtomicUnitOfMass, DecaAtomicUnitOfMass, DeciAtomicUnitOfMass, CentiAtomicUnitOfMass, MilliAtomicUnitOfMass, MicroAtomicUnitOfMass, NanoAtomicUnitOfMass, PicoAtomicUnitOfMass, FemtoAtomicUnitOfMass, AttoAtomicUnitOfMass, ZeptoAtomicUnitOfMass, YoctoAtomicUnitOfMass]
  `name` None
  `prefix_factor`(other)
  `prefixes` = [<grendel.util.units.unit.Prefix object at 0xd1cea6c>, <grendel.util.units.unit.Prefix object at 0xd1cea8c>, <grendel.util.units.unit.Prefix object at 0xd1ceaac>, <grendel.util.units.unit.Prefix object at 0xd1ceacc>, <grendel.util.units.unit.Prefix object at 0xd1ceaec>, <grendel.util.units.unit.Prefix object at 0xd1ceb0c>, <grendel.util.units.unit.Prefix object at 0xd1ceb2c>, <grendel.util.units.unit.Prefix object at 0xd1ceb4c>, <grendel.util.units.unit.Prefix object at 0xd1ceb6c>, <grendel.util.units.unit.Prefix object at 0xd1ceb8c>, <grendel.util.units.unit.Prefix object at 0xd1cebac>, <grendel.util.units.unit.Prefix object at 0xd1cebcc>, <grendel.util.units.unit.Prefix object at 0xd1cebec>, <grendel.util.units.unit.Prefix object at 0xd1cec0c>, <grendel.util.units.unit.Prefix object at 0xd1cec2c>, <grendel.util.units.unit.Prefix object at 0xd1cec4c>, <grendel.util.units.unit.Prefix object at 0xd1cec6c>, <grendel.util.units.unit.Prefix object at 0xd1cec8c>, <grendel.util.units.unit.Prefix object at 0xd1cecac>, <grendel.util.units.unit.Prefix object at 0xd1ceccc>]
  `to`(other)

class `Unitized`

  Abstract base class for things with units. It requires its subclasses to implement the properties ‘value’ and ‘units’. Unitized subclasses are also expected have __mul__, __div__, __truediv__, __pow__, __add__, __sub__, __neg__, __pos__, and __abs__ handle units correctly, when implemented in the given subclass.

  `in_units`(new_units)
  `units` None
  `value` None

exception `UnitizedObjectError`

  For errors encountered in handling unitized objects

exception `UnknownUnitError`(unit1)

  Exception for attempted conversion of something that is not a subclass of Unit

class `ValueWithUnits`(value, units)

  A class for encapsulating a physical constant and it’s units.

  units : CompositeUnit or a class with Unit as its metaclass
    The units in which the value of self is to be interpreted
  `convert_to`(units)
  `in_units`(units)
  `units` = None
  `value` None

class `Wavenumber`

`Wavenumbers`

  alias of `Wavenumber`

class `Week`

`Weeks`

  alias of `Week`

exception `XMLResultGetterError`

class `Year`

`Years`

  alias of `Year`

class `YoctoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`YoctoAMUs`

  alias of `YoctoAMU`

class `YoctoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`YoctoAtomicUnitsOfCharge`

  alias of `YoctoAtomicUnitOfCharge`

`YoctoAtomicUnitsOfDistance`

  alias of `YoctoAtomicUnitOfDistance`

`YoctoAtomicUnitsOfEnergy`

  alias of `YoctoAtomicUnitOfEnergy`

class `YoctoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

class `YoctoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1ceccc>

`Yoctoangstrom`

  alias of `YoctoAngstrom`

`Yoctoangstroms`

  alias of `YoctoAngstrom`

`Yoctobohr`

  alias of `YoctoBohr`

`Yoctobohrs`

  alias of `YoctoBohr`

`Yoctocenturies`

  alias of `YoctoCentury`

`Yoctocentury`

  alias of `YoctoCentury`

`Yoctocoulomb`

  alias of `YoctoCoulomb`

`Yoctocoulombs`

  alias of `YoctoCoulomb`

`Yoctoday`

  alias of `YoctoDay`

`Yoctodays`

  alias of `YoctoDay`

`Yoctodecade`

  alias of `YoctoDecade`

`Yoctodecades`

  alias of `YoctoDecade`

`Yoctodegree`

  alias of `YoctoDegree`

`Yoctodegrees`

  alias of `YoctoDegree`

`Yoctogram`

  alias of `YoctoGram`

`Yoctograms`

  alias of `YoctoGram`

`Yoctohartree`

  alias of `YoctoHartree`

`Yoctohartrees`

  alias of `YoctoHartree`

`Yoctohertz`

  alias of `YoctoHertz`

`Yoctohertzs`

  alias of `YoctoHertz`

`Yoctohour`

  alias of `YoctoHour`

`Yoctohours`

  alias of `YoctoHour`

`Yoctojoule`

  alias of `YoctoJoule`

`Yoctojoules`

  alias of `YoctoJoule`

`Yoctometer`

  alias of `YoctoMeter`

`Yoctometers`

  alias of `YoctoMeter`

`Yoctomillennia`

  alias of `YoctoMillennium`

`Yoctomillennium`

  alias of `YoctoMillennium`

`Yoctominute`

  alias of `YoctoMinute`

`Yoctominutes`

  alias of `YoctoMinute`

`Yoctoradian`

  alias of `YoctoRadian`

`Yoctoradians`

  alias of `YoctoRadian`

`Yoctosecond`

  alias of `YoctoSecond`

`Yoctoseconds`

  alias of `YoctoSecond`

`Yoctowavenumber`

  alias of `YoctoWavenumber`

`Yoctowavenumbers`

  alias of `YoctoWavenumber`

`Yoctoweek`

  alias of `YoctoWeek`

`Yoctoweeks`

  alias of `YoctoWeek`

`Yoctoyear`

  alias of `YoctoYear`

`Yoctoyears`

  alias of `YoctoYear`

class `YottaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`YottaAMUs`

  alias of `YottaAMU`

class `YottaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`YottaAtomicUnitsOfCharge`

  alias of `YottaAtomicUnitOfCharge`

`YottaAtomicUnitsOfDistance`

  alias of `YottaAtomicUnitOfDistance`

`YottaAtomicUnitsOfEnergy`

  alias of `YottaAtomicUnitOfEnergy`

class `YottaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

class `YottaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea6c>

`Yottaangstrom`

  alias of `YottaAngstrom`

`Yottaangstroms`

  alias of `YottaAngstrom`

`Yottabohr`

  alias of `YottaBohr`

`Yottabohrs`

  alias of `YottaBohr`

`Yottacenturies`

  alias of `YottaCentury`

`Yottacentury`

  alias of `YottaCentury`

`Yottacoulomb`

  alias of `YottaCoulomb`

`Yottacoulombs`

  alias of `YottaCoulomb`

`Yottaday`

  alias of `YottaDay`

`Yottadays`

  alias of `YottaDay`

`Yottadecade`

  alias of `YottaDecade`

`Yottadecades`

  alias of `YottaDecade`

`Yottadegree`

  alias of `YottaDegree`

`Yottadegrees`

  alias of `YottaDegree`

`Yottagram`

  alias of `YottaGram`

`Yottagrams`

  alias of `YottaGram`

`Yottahartree`

  alias of `YottaHartree`

`Yottahartrees`

  alias of `YottaHartree`

`Yottahertz`

  alias of `YottaHertz`

`Yottahertzs`

  alias of `YottaHertz`

`Yottahour`

  alias of `YottaHour`

`Yottahours`

  alias of `YottaHour`

`Yottajoule`

  alias of `YottaJoule`

`Yottajoules`

  alias of `YottaJoule`

`Yottameter`

  alias of `YottaMeter`

`Yottameters`

  alias of `YottaMeter`

`Yottamillennia`

  alias of `YottaMillennium`

`Yottamillennium`

  alias of `YottaMillennium`

`Yottaminute`

  alias of `YottaMinute`

`Yottaminutes`

  alias of `YottaMinute`

`Yottaradian`

  alias of `YottaRadian`

`Yottaradians`

  alias of `YottaRadian`

`Yottasecond`

  alias of `YottaSecond`

`Yottaseconds`

  alias of `YottaSecond`

`Yottawavenumber`

  alias of `YottaWavenumber`

`Yottawavenumbers`

  alias of `YottaWavenumber`

`Yottaweek`

  alias of `YottaWeek`

`Yottaweeks`

  alias of `YottaWeek`

`Yottayear`

  alias of `YottaYear`

`Yottayears`

  alias of `YottaYear`

class `ZeptoAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`ZeptoAMUs`

  alias of `ZeptoAMU`

class `ZeptoAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`ZeptoAtomicUnitsOfCharge`

  alias of `ZeptoAtomicUnitOfCharge`

`ZeptoAtomicUnitsOfDistance`

  alias of `ZeptoAtomicUnitOfDistance`

`ZeptoAtomicUnitsOfEnergy`

  alias of `ZeptoAtomicUnitOfEnergy`

class `ZeptoBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

class `ZeptoYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cecac>

`Zeptoangstrom`

  alias of `ZeptoAngstrom`

`Zeptoangstroms`

  alias of `ZeptoAngstrom`

`Zeptobohr`

  alias of `ZeptoBohr`

`Zeptobohrs`

  alias of `ZeptoBohr`

`Zeptocenturies`

  alias of `ZeptoCentury`

`Zeptocentury`

  alias of `ZeptoCentury`

`Zeptocoulomb`

  alias of `ZeptoCoulomb`

`Zeptocoulombs`

  alias of `ZeptoCoulomb`

`Zeptoday`

  alias of `ZeptoDay`

`Zeptodays`

  alias of `ZeptoDay`

`Zeptodecade`

  alias of `ZeptoDecade`

`Zeptodecades`

  alias of `ZeptoDecade`

`Zeptodegree`

  alias of `ZeptoDegree`

`Zeptodegrees`

  alias of `ZeptoDegree`

`Zeptogram`

  alias of `ZeptoGram`

`Zeptograms`

  alias of `ZeptoGram`

`Zeptohartree`

  alias of `ZeptoHartree`

`Zeptohartrees`

  alias of `ZeptoHartree`

`Zeptohertz`

  alias of `ZeptoHertz`

`Zeptohertzs`

  alias of `ZeptoHertz`

`Zeptohour`

  alias of `ZeptoHour`

`Zeptohours`

  alias of `ZeptoHour`

`Zeptojoule`

  alias of `ZeptoJoule`

`Zeptojoules`

  alias of `ZeptoJoule`

`Zeptometer`

  alias of `ZeptoMeter`

`Zeptometers`

  alias of `ZeptoMeter`

`Zeptomillennia`

  alias of `ZeptoMillennium`

`Zeptomillennium`

  alias of `ZeptoMillennium`

`Zeptominute`

  alias of `ZeptoMinute`

`Zeptominutes`

  alias of `ZeptoMinute`

`Zeptoradian`

  alias of `ZeptoRadian`

`Zeptoradians`

  alias of `ZeptoRadian`

`Zeptosecond`

  alias of `ZeptoSecond`

`Zeptoseconds`

  alias of `ZeptoSecond`

`Zeptowavenumber`

  alias of `ZeptoWavenumber`

`Zeptowavenumbers`

  alias of `ZeptoWavenumber`

`Zeptoweek`

  alias of `ZeptoWeek`

`Zeptoweeks`

  alias of `ZeptoWeek`

`Zeptoyear`

  alias of `ZeptoYear`

`Zeptoyears`

  alias of `ZeptoYear`

class `ZettaAMU`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`ZettaAMUs`

  alias of `ZettaAMU`

class `ZettaAngstrom`
  `base_unit`

    alias of `Angstrom`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicMassUnit`
  `base_unit`

    alias of `AtomicMassUnit`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfDistance`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfElectricCharge`
  `base_unit`

    alias of `AtomicUnitOfElectricCharge`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfEnergy`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfMass`
  `base_unit`

    alias of `AtomicUnitOfMass`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaAtomicUnitOfTime`
  `base_unit`

    alias of `AtomicUnitOfTime`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`ZettaAtomicUnitsOfCharge`

  alias of `ZettaAtomicUnitOfCharge`

`ZettaAtomicUnitsOfDistance`

  alias of `ZettaAtomicUnitOfDistance`

`ZettaAtomicUnitsOfEnergy`

  alias of `ZettaAtomicUnitOfEnergy`

class `ZettaBohr`
  `base_unit`

    alias of `Bohr`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaCentury`
  `base_unit`

    alias of `Century`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaCoulomb`
  `base_unit`

    alias of `Coulomb`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaDay`
  `base_unit`

    alias of `Day`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaDecade`
  `base_unit`

    alias of `Decade`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaDegree`
  `base_unit`

    alias of `Degree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaGram`
  `base_unit`

    alias of `Gram`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaHartree`
  `base_unit`

    alias of `Hartree`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaHertz`
  `base_unit`

    alias of `Hertz`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaHour`
  `base_unit`

    alias of `Hour`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaJoule`
  `base_unit`

    alias of `Joule`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaKiloJoulePerMol`
  `base_unit`

    alias of `KiloJoulePerMol`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaMeter`
  `base_unit`

    alias of `Meter`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaMillennium`
  `base_unit`

    alias of `Millennium`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaMinute`
  `base_unit`

    alias of `Minute`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaRadian`
  `base_unit`

    alias of `Radian`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaSecond`
  `base_unit`

    alias of `Second`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaWavenumber`
  `base_unit`

    alias of `Wavenumber`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaWeek`
  `base_unit`

    alias of `Week`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

class `ZettaYear`
  `base_unit`

    alias of `Year`

  `prefix` = <grendel.util.units.unit.Prefix object at 0xd1cea8c>

`Zettaangstrom`

  alias of `ZettaAngstrom`

`Zettaangstroms`

  alias of `ZettaAngstrom`

`Zettabohr`

  alias of `ZettaBohr`

`Zettabohrs`

  alias of `ZettaBohr`

`Zettacenturies`

  alias of `ZettaCentury`

`Zettacentury`

  alias of `ZettaCentury`

`Zettacoulomb`

  alias of `ZettaCoulomb`

`Zettacoulombs`

  alias of `ZettaCoulomb`

`Zettaday`

  alias of `ZettaDay`

`Zettadays`

  alias of `ZettaDay`

`Zettadecade`

  alias of `ZettaDecade`

`Zettadecades`

  alias of `ZettaDecade`

`Zettadegree`

  alias of `ZettaDegree`

`Zettadegrees`

  alias of `ZettaDegree`

`Zettagram`

  alias of `ZettaGram`

`Zettagrams`

  alias of `ZettaGram`

`Zettahartree`

  alias of `ZettaHartree`

`Zettahartrees`

  alias of `ZettaHartree`

`Zettahertz`

  alias of `ZettaHertz`

`Zettahertzs`

  alias of `ZettaHertz`

`Zettahour`

  alias of `ZettaHour`

`Zettahours`

  alias of `ZettaHour`

`Zettajoule`

  alias of `ZettaJoule`

`Zettajoules`

  alias of `ZettaJoule`

`Zettameter`

  alias of `ZettaMeter`

`Zettameters`

  alias of `ZettaMeter`

`Zettamillennia`

  alias of `ZettaMillennium`

`Zettamillennium`

  alias of `ZettaMillennium`

`Zettaminute`

  alias of `ZettaMinute`

`Zettaminutes`

  alias of `ZettaMinute`

`Zettaradian`

  alias of `ZettaRadian`

`Zettaradians`

  alias of `ZettaRadian`

`Zettasecond`

  alias of `ZettaSecond`

`Zettaseconds`

  alias of `ZettaSecond`

`Zettawavenumber`

  alias of `ZettaWavenumber`

`Zettawavenumbers`

  alias of `ZettaWavenumber`

`Zettaweek`

  alias of `ZettaWeek`

`Zettaweeks`

  alias of `ZettaWeek`

`Zettayear`

  alias of `ZettaYear`

`Zettayears`

  alias of `ZettaYear`

`compatible_units`(unit1, unit2)

  Aliased as iscompatible()

`convert`(*fargs, **fkeywords)

  Alias for convert_units()

`convert_units`(val, from_unit, to_unit)

  Aliased as convert()

class `defaultdict`

  defaultdict(default_factory) –> dict with default factory

  The default factory is called without arguments to produce a new value when a key is not present, in __getitem__ only. A defaultdict compares equal to a dict with the same items.

  `copy`() → a shallow copy of D.
  `default_factory` None

    Factory for default value called by __missing__().

`has_units`(obj)

  Aliased as hasunits()

`hasunits`(*fargs, **fkeywords)

  Alias for has_units()

`indented`(instr, nspaces=4)

  Aliased as indent()

`is_unit`(*fargs, **fkeywords)

  Alias for isunit()

`iscompatible`(*fargs, **fkeywords)

  Alias for compatible_units()

`isunit`(unit)

  Aliased as is_unit()

`listify_args`(*args, **kwargs)

  A simple way to accept arguments that can be an Iterable or a bunch of arguments that should be treated as a single Iterable. (This method is pretty trivial, but I find myself doing it a whole lot.) The reason you can’t just use list() for this purpose is that if an Iterable is given as the only argument, list(args) will return a list of Iterables rather than a single Iterable.

  Examples: |

      >>> def test(*args):
      ...     return listify_args(*args)
      ...
      >>> test(1,2,3)
      [1, 2, 3]
      >>> test([1,2,3])
      [1, 2, 3]
      >>> test([1,2,3], 4)
      [[1, 2, 3], 4]
      >>> test("1,2,3", 4)
      ['1,2,3', 4]
      >>> test("1,2,3")
      ['1,2,3']

`strip_units` None
  Strips the units off of a unitized object
    (or, if the object is not Unitized, just return it). If convert_to is given, convert to these units if obj is Unitized. If assume_units is given, obj is assumed to have the units given by this argument if (and only if) it is not an instance of Unitized.

  Aliased as stripunits()

`stripunits`(*fargs, **fkeywords)

  Alias for strip_units()

## p4const

### Navigation

- index
- modules
- toc
- next
- previous
- PSI4 [beta5] »