def test__from_data():
""" test vmat.from_data
"""
vma1 = vmat.from_data(
syms=vmat.symbols(CH4O_VMA),
key_mat=vmat.key_matrix(CH4O_VMA),
name_mat=vmat.name_matrix(CH4O_VMA),
)
assert vma1 == CH4O_VMA
vma2 = vmat.from_data(
syms=vmat.symbols(CH4O_VMA_NO_NONES),
key_mat=vmat.key_matrix(CH4O_VMA_NO_NONES),
name_mat=vmat.name_matrix(CH4O_VMA_NO_NONES),
)
assert vma2 == CH4O_VMA
vma1 = list(map(list, vma1))
vma2 = list(map(list, vma2))
assert vmat.is_valid(vma1)
assert vmat.is_valid(vma2)
vma1[0] += [None]
vma2[0][1] = vma2[0][1] + (None,)
assert not vmat.is_valid(vma1)
assert not vmat.is_valid(vma2)
def remove_atom(zma, key):
""" Remove an atom from a Z-Matrix. Error raised if attempting
to remove atom other atoms depend on.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param key: key of atom to remove
:type key: str
:rtype: automol Z-Matrix data structure
"""
symbs = list(symbols(zma))
symbs.pop(key)
key_mat = list(key_matrix(zma))
key_mat.pop(key)
key_mat = numpy.array(key_mat, dtype=numpy.object_)
if (key_mat == key).any():
raise ValueError(
"Other atoms in z-matrix depend on atom {}".format(key))
key_map = numpy.vectorize(lambda x: x if (x is None or x < key) else x - 1)
key_mat = key_map(key_mat)
val_mat = list(value_matrix(zma))
val_mat.pop(key)
name_mat = list(name_matrix(zma))
name_mat.pop(key)
zma = from_data(symbs, key_mat, val_mat, name_mat)
return zma
def set_values_by_name(zma, val_dct, angstrom=True, degree=True):
""" Re-set the name matrix of a Z-Matrix using the input value dictionary.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param val_dct: dictionary of coordinate values
:type val_dct: dict[str: float]
:param angstrom: parameter to control Bohr->Angstrom conversion
:type angstrom: bool
:param degree: parameter to control radian->degree conversion
:type degree: bool
:rtype: automol Z-Matrix data structure
"""
val_mat = numpy.array(value_matrix(zma), dtype=numpy.object_)
name_mat = numpy.array(name_matrix(zma), dtype=numpy.object_)
for (row, col), name in numpy.ndenumerate(name_mat):
if name in val_dct:
val = val_dct[name]
if col == 0:
val *= phycon.ANG2BOHR if angstrom else 1
else:
assert col > 0
val *= phycon.DEG2RAD if degree else 1
val_mat[row, col] = val
return set_value_matrix(zma, val_mat)
def dihedral_angle_coordinate_name(zma, key1, key2, key3, key4):
""" get the name of dihedral coordinate for a set of 4 atoms
:param zma: the z-matrix
:type zma: automol Z-Matrix data structure
:param key1: the first key
:type key1: int
:param key2: the second key
:type key2: int
:param key3: the third key
:type key3: int
:param key4: the fourth key
:type key4: int
:rtype: str
"""
if key1 > key4:
key1, key2, key3, key4 = key4, key3, key2, key1
name_mat = name_matrix(zma)
key_mat = key_matrix(zma)
assert (
key_mat[key4][0] == key3 and key_mat[key4][1] == key2
and key_mat[key4][2] == key1
), ("{:d}-{:d}-{:d}-{:d} is not a dihedral coordinate in this zmatrix:\n{}"
.format(key1, key2, key3, key4, string(zma, one_indexed=False)))
name = name_mat[key4][2]
return name
def from_geometry(vma, geo):
""" Build a Z-Matrix from a V-Matrix and a molecular geometry.
:param vma: V-Matrix
:type vma: automol V-Matrix data structure
:param geo: molecular geometry
:type geo: automol molecular geometry data structure
:rtype: automol Z-Matrix data structure
"""
assert symbols(vma) == symbols(geo)
symbs = symbols(vma)
key_mat = key_matrix(vma)
name_mat = name_matrix(vma)
val_mat = numpy.empty(numpy.shape(key_mat), dtype=numpy.object_)
for row, key_row in enumerate(key_mat):
if row > 0:
val_mat[row,
0] = automol.geom.base.distance(geo, row, *key_row[:1])
if row > 1:
val_mat[row, 1] = automol.geom.base.central_angle(
geo, row, *key_row[:2])
if row > 2:
val_mat[row, 2] = automol.geom.base.dihedral_angle(
geo, row, *key_row[:3])
zma = from_data(symbs, key_mat, val_mat, name_mat)
return zma
def name_matrix(zma):
""" Obtain the name matrix of the Z-Matrix that contains the
coordinate names by row and column.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:rtype: tuple(tuple(str))
"""
return vmat.name_matrix(zma)
def vmatrix(zma):
""" Parse and return the V-Matrix component of a Z-Matrix.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
"""
return vmat.from_data(symbs=symbols(zma),
key_mat=key_matrix(zma),
name_mat=name_matrix(zma))
def test__from_data():
""" test vmat.from_data
"""
vma = vmat.from_data(
symbs=vmat.symbols(CH4O_VMA),
key_mat=vmat.key_matrix(CH4O_VMA),
name_mat=vmat.name_matrix(CH4O_VMA),
)
assert vma == CH4O_VMA
def rename(zma, name_dct):
""" set coordinate names for the z-matrix
"""
syms = symbols(zma)
key_mat = key_matrix(zma)
val_mat = value_matrix(zma)
vma = vmat.rename(zma, name_dct)
name_mat = vmat.name_matrix(vma)
zma = automol.create.zmat.from_data(syms, key_mat, val_mat, name_mat)
return zma
def add_atom(zma,
sym,
key_row,
val_row,
name_row=None,
one_indexed=False,
angstrom=True,
degree=True):
""" Add an atom to a Z-Matrix.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param symb: symbol of atom to add
:type symb: str
:param key_row: row of keys to define new atom added to key matrix
:type key_row: tuple(int)
:param val_row: row of values to define new atom added to name matrix
:type val_row: tuple(float)
:param name_row: row of names to define new atom added to name matrix
:type name_row: tuple(str)
:param one_indexed: parameter to store keys in one-indexing
:type one_indexed: bool
:param angstrom: parameter to control Bohr->Angstrom conversion
:type angstrom: bool
:param degree: parameter to control radian->degree conversion
:type degree: bool
:rtype: automol Z-Matrix data structure
"""
symbs = symbols(zma)
symbs += (sym, )
key_mat = key_matrix(zma, shift=(1 if one_indexed else 0))
key_mat += (key_row, )
val_mat = value_matrix(zma, angstrom=angstrom, degree=degree)
val_mat += (val_row, )
name_mat = None if name_row is None else name_matrix(zma) + (name_row, )
zma = from_data(symbs,
key_mat,
val_mat,
name_mat,
one_indexed=one_indexed,
angstrom=angstrom,
degree=degree)
return zma
def set_value_matrix(zma, val_mat):
""" Re-set the name matrix of a Z-Matrix using the input value matrix.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param val_mat: matrix of Z-Matrix coordinate values
:type val_mat: tuple(tuple(int))
:rtype: automol Z-Matrix data structure
"""
symbs = symbols(zma)
key_mat = key_matrix(zma)
name_mat = name_matrix(zma)
zma = from_data(symbs, key_mat, val_mat, name_mat)
return zma
def value_dictionary(zma, angstrom=False, degree=False):
""" Obtain the values of the coordinates defined in the Z-Matrix
in the form of a dictionary.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param angstrom: parameter to control Bohr->Angstrom conversion
:type angstrom: bool
:param degree: parameter to control radian->degree conversion
:type degree: bool
:rtype: dict[str: float]
"""
names = numpy.ravel(name_matrix(zma))
vals = numpy.ravel(value_matrix(zma, angstrom=angstrom, degree=degree))
val_dct = dict(zip(names, vals))
val_dct.pop(None)
return val_dct
def rename(zma, name_dct):
""" Rename a subset of the coordinates of a Z-Matrix.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param name_dct: mapping from old coordinate names to new ones
:type name_dct: dict[str: str]
:rtype: automol Z-Matrix data strucutre
"""
symbs = symbols(zma)
key_mat = key_matrix(zma)
val_mat = value_matrix(zma)
vma = vmat.rename(zma, name_dct)
name_mat = vmat.name_matrix(vma)
zma = from_data(symbs, key_mat, val_mat, name_mat)
return zma
def distance_coordinate_name(zma, key1, key2):
""" get the name of a distance coordinate for a given bond
:param zma: the z-matrix
:type zma: automol Z-Matrix data structure
:param key1: the first key in the torsion axis (rotational bond)
:type key1: int
:param key2: the second key in the torsion axis (rotational bond)
:type key2: int
:rtype: str
"""
key1, key2 = sorted([key1, key2])
name_mat = name_matrix(zma)
key_mat = key_matrix(zma)
assert key_mat[key2][0] == key1, (
"{:d}-{:d} is not a distance coordinate in this zmatrix:\n{}".format(
key1, key2, string(zma, one_indexed=False)))
name = name_mat[key2][0]
return name
def value_dictionary(zma, angstrom=False, degree=False):
""" Obtain the values of the coordinates defined in the Z-Matrix
in the form of a dictionary.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param angstrom: parameter to control Bohr->Angstrom conversion
:type angstrom: bool
:param degree: parameter to control radian->degree conversion
:type degree: bool
:rtype: dict[str: tuple(float)]
"""
names = numpy.ravel(name_matrix(zma))
vals = numpy.ravel(value_matrix(zma, angstrom=angstrom, degree=degree))
val_dct = dict(zip(names, vals))
# Remove None entries from the None in name mat, convert npflatt to float
val_dct.pop(None)
val_dct = {name: float(val) for name, val in val_dct.items()}
return val_dct
def string(zma, one_indexed=True, angstrom=True, degree=True):
""" Write a Z-Matrix object to a string.
:param zma: Z-Matrix
:type zma: automol Z-Matrix data structure
:param one_indexed: parameter to store keys in one-indexing
:type one_indexed: bool
:param angstrom: parameter to control Bohr->Angstrom conversion
:type angstrom: bool
:param degree: parameter to control radian->degree conversion
:type degree: bool
:rtype: str
"""
shift = 1 if one_indexed else 0
zma_str = aw.zmat.write(symbs=symbols(zma),
key_mat=key_matrix(zma, shift=shift),
name_mat=name_matrix(zma),
val_dct=value_dictionary(zma,
angstrom=angstrom,
degree=degree))
return zma_str
def central_angle_coordinate_name(zma, key1, key2, key3):
""" get the name of angle coordinate for a set of 3 atoms
:param zma: the z-matrix
:type zma: automol Z-Matrix data structure
:param key1: the first key
:type key1: int
:param key2: the second key (central atom)
:type key2: int
:param key3: the third key
:type key3: int
:rtype: str
"""
key1, key3 = sorted([key1, key3])
name_mat = name_matrix(zma)
key_mat = key_matrix(zma)
assert key_mat[key3][0] == key2 and key_mat[key3][1] == key1, (
"{:d}-{:d}-{:d} is not a distance coordinate in this zmatrix:\n{}".
format(key1, key2, key3, string(zma, one_indexed=False)))
name = name_mat[key3][1]
return name
def name_matrix(zma):
""" coordinate names, by z-matrix row and column
"""
return vmat.name_matrix(zma)
