def _decompose_ring_system_atom_keys(rsy):
""" decompose a ring system into a ring and a series of arcs
"""
# sort from smallest to largest
rngs_pool = sorted(
rings(rsy), key=lambda x: atom_count(x, with_implicit=False))
decomp = ()
decomp_bnd_keys = set({})
rng = rngs_pool.pop(0)
bnd_keys = bond_keys(rng)
atm_keys = sorted_ring_atom_keys_from_bond_keys(bnd_keys)
decomp += (atm_keys,)
decomp_bnd_keys.update(bnd_keys)
while rngs_pool:
decomp_rsy = bond_induced_subgraph(rsy, decomp_bnd_keys)
for idx, rng in enumerate(rngs_pool):
arcs = ring_arc_complement_atom_keys(decomp_rsy, rng)
if arcs:
rngs_pool.pop(idx)
decomp += arcs
decomp_bnd_keys.update(bond_keys(rng))
return decomp
def bond_equivalence_class_reps(gra, bnd_keys=None, stereo=True, dummy=True):
""" Identify isomorphically unique bonds, which do not transform into each
other by an automorphism
Optionally, a subset of bonds can be passed in to consider class
representatives from within that list.
:param gra: A graph
:param bnd_keys: An optional list of bond keys from which to determine
equivalence class representatives. If None, the full set of bond keys
will be used.
:param stereo: Consider stereo?
:type stereo: bool
:param dummy: Consider dummy atoms?
:type dummy: bool
:returns: The list of equivalence class reprentatives/unique bonds.
:rtype: frozenset[int]
"""
bnd_keys = bond_keys(gra) if bnd_keys is None else bnd_keys
def _equiv(bnd1_key, bnd2_key):
return are_equivalent_bonds(gra, bnd1_key, bnd2_key, stereo=stereo,
dummy=dummy)
eq_classes = util.equivalence_partition(bnd_keys, _equiv)
class_reps = frozenset(next(iter(c)) for c in eq_classes)
return class_reps
def ring_system_decomposed_atom_keys(rsy, rng_keys=None, check=True):
""" decomposed atom keys for a polycyclic ring system in a graph
The ring system is decomposed into a ring and a series of arcs that can
be used to successively construct the system
:param rsy: the ring system
:param rng_keys: keys for the first ring in the decomposition; if None, the
smallest ring in the system will be chosen
"""
if rng_keys is None:
rng = sorted(rings(rsy), key=atom_count)[0]
rng_keys = sorted_ring_atom_keys(rng)
# check the arguments, if requested
if check:
# check that the graph is connected
assert is_connected(rsy), "Ring system can't be disconnected."
# check that the graph is actually a ring system
assert is_ring_system(rsy), (
f"This is not a ring system graph:\n{string(rsy):s}")
# check that rng is a subgraph of rsy
assert set(rng_keys) <= atom_keys(rsy), (
f"{string(rsy, one_indexed=False)}\n^ "
"Rings system doesn't contain ring as subgraph:\n"
f"{str(rng_keys)}")
bnd_keys = list(mit.windowed(rng_keys + rng_keys[:1], 2))
# Remove bonds for the ring
rsy = remove_bonds(rsy, bnd_keys)
keys_lst = [rng_keys]
done_keys = set(rng_keys)
while bond_keys(rsy):
# Determine shortest paths for the graph with one more ring/arc deleted
sp_dct = atom_shortest_paths(rsy)
# The shortest path will be the next shortest arc in the system
arc_keys = min(
(sp_dct[i][j] for i, j in itertools.combinations(done_keys, 2)
if j in sp_dct[i]), key=len)
# Add this arc to the list
keys_lst.append(arc_keys)
# Add these keys to the list of done keys
done_keys |= set(arc_keys)
# Delete tbond keys for the new arc and continue to the next iteration
bnd_keys = list(map(frozenset, mit.windowed(arc_keys, 2)))
rsy = remove_bonds(rsy, bnd_keys)
keys_lst = tuple(map(tuple, keys_lst))
return keys_lst
def radical_dissociation_prods(gra, pgra1):
""" given a dissociation product, determine the other product
"""
gra = without_fractional_bonds(gra)
pgra2 = None
rads = sing_res_dom_radical_atom_keys(gra)
adj_atms = atoms_neighbor_atom_keys(gra)
# adj_idxs = tuple(adj_atms[rad] for rad in rads)
for rad in rads:
for adj in adj_atms[rad]:
for group in atom_groups(gra, adj, stereo=False):
if isomorphism(group, pgra1, backbone_only=True):
pgra2 = remove_atoms(gra, atom_keys(group))
# pgra2 = remove_bonds(pgra2, bond_keys(group))
if bond_keys(group) in pgra2:
pgra2 = remove_bonds(pgra2, bond_keys(group))
return (pgra1, pgra2)
def rotational_bond_keys(gra, lin_keys=None, with_h_rotors=True):
""" get all rotational bonds for a graph
:param gra: the graph
:param lin_keys: keys to linear atoms in the graph
"""
gra = explicit(gra)
sym_dct = atom_symbols(gra)
ngb_keys_dct = atoms_neighbor_atom_keys(gra)
bnd_ord_dct = resonance_dominant_bond_orders(gra)
rng_bnd_keys = list(itertools.chain(*rings_bond_keys(gra)))
def _is_rotational_bond(bnd_key):
ngb_keys_lst = [ngb_keys_dct[k] - bnd_key for k in bnd_key]
is_single = max(bnd_ord_dct[bnd_key]) <= 1
has_neighbors = all(ngb_keys_lst)
not_in_ring = bnd_key not in rng_bnd_keys
is_h_rotor = any(
set(map(sym_dct.__getitem__, ks)) == {'H'} for ks in ngb_keys_lst)
return is_single and has_neighbors and not_in_ring and (
not is_h_rotor or with_h_rotors)
rot_bnd_keys = frozenset(filter(_is_rotational_bond, bond_keys(gra)))
lin_keys_lst = linear_segments_atom_keys(gra, lin_keys=lin_keys)
dum_keys = tuple(atom_keys(gra, sym='X'))
for keys in lin_keys_lst:
bnd_keys = sorted((k for k in rot_bnd_keys if k & set(keys)),
key=sorted)
# Check whether there are neighboring atoms on either side of the
# linear segment
excl_keys = set(keys) | set(dum_keys)
end_key1 = atom_neighbor_atom_key(gra,
keys[0],
excl_atm_keys=excl_keys)
excl_keys |= {end_key1}
end_key2 = atom_neighbor_atom_key(gra,
keys[-1],
excl_atm_keys=excl_keys)
end_keys = {end_key1, end_key2}
ngb_keys_lst = [ngb_keys_dct[k] - excl_keys for k in end_keys]
has_neighbors = all(ngb_keys_lst)
if not has_neighbors:
rot_bnd_keys -= set(bnd_keys)
else:
rot_bnd_keys -= set(bnd_keys[:-1])
return rot_bnd_keys
def resonance_dominant_bond_orders(rgr):
""" resonance-dominant bond orders, by bond
"""
rgr = without_fractional_bonds(rgr)
bnd_keys = list(bond_keys(rgr))
bnd_ords_by_res = [
dict_.values_by_key(bond_orders(dom_rgr), bnd_keys)
for dom_rgr in dominant_resonances(rgr)
]
bnd_ords_lst = list(map(frozenset, zip(*bnd_ords_by_res)))
bnd_dom_res_ords_dct = dict(zip(bnd_keys, bnd_ords_lst))
return bnd_dom_res_ords_dct
def rings_bond_keys(gra):
""" bond keys for each ring in the graph (minimal basis)
"""
bnd_keys = bond_keys(gra)
def _ring_bond_keys(rng_atm_keys):
return frozenset(filter(lambda x: x <= rng_atm_keys, bnd_keys))
nxg = _networkx.from_graph(gra)
rng_atm_keys_lst = _networkx.minimum_cycle_basis(nxg)
rng_bnd_keys_lst = frozenset(map(_ring_bond_keys, rng_atm_keys_lst))
return rng_bnd_keys_lst
def ring_arc_complement_atom_keys(gra, rng):
""" non-intersecting arcs from a ring that shares segments with a graph
"""
gra_atm_bnd_dct = atoms_bond_keys(gra)
rng_atm_bnd_dct = atoms_bond_keys(rng)
# 1. find divergence points, given by the atom at which the divergence
# occurs and the bond followed by the ring as it diverges
div_dct = {}
for atm_key in atom_keys(gra) & atom_keys(rng):
div = rng_atm_bnd_dct[atm_key] - gra_atm_bnd_dct[atm_key]
if div:
bnd_key, = div
div_dct[atm_key] = bnd_key
# 2. cycle through the ring atoms; if you meet a starting divergence, start
# an arc; extend the arc until you meet an ending divergence; repeat until
# all divergences are accounted for
atm_keys = sorted_ring_atom_keys_from_bond_keys(bond_keys(rng))
arcs = []
arc = []
for atm_key, next_atm_key in mit.windowed(itertools.cycle(atm_keys), 2):
bnd_key = frozenset({atm_key, next_atm_key})
# if we haven't started an arc, see if we are at a starting divergence;
# if so, start the arc now and cross the divergence from our list
if not arc:
if atm_key in div_dct and div_dct[atm_key] == bnd_key:
div_dct.pop(atm_key)
arc.append(atm_key)
# if we've started an arc, extend it; then, check if we are at an
# ending divergence; if so, end the arc and cross the divergence from
# our list; add it to our list of arcs
else:
arc.append(atm_key)
if next_atm_key in div_dct and div_dct[next_atm_key] == bnd_key:
div_dct.pop(next_atm_key)
arc.append(next_atm_key)
arcs.append(arc)
arc = []
# if no divergences are left, break out of the loop
if not div_dct:
break
arcs = tuple(map(tuple, arcs))
return arcs
def _bond_capacities(rgr):
""" the number of electron pairs available for further pi-bonding, by bond
"""
rgr = without_dummy_bonds(rgr)
atm_unsat_vlc_dct = atom_unsaturated_valences(rgr)
def _pi_capacities(bnd_key):
return min(map(atm_unsat_vlc_dct.__getitem__, bnd_key))
bnd_keys = list(bond_keys(rgr))
bnd_caps = tuple(map(_pi_capacities, bnd_keys))
bnd_cap_dct = dict(zip(bnd_keys, bnd_caps))
return bnd_cap_dct
def _add_pi_bonds(rgr, bnd_ord_inc_dct):
""" add pi bonds to this graph
"""
bnd_keys = bond_keys(rgr)
assert set(bnd_ord_inc_dct.keys()) <= bnd_keys
bnd_keys = list(bnd_keys)
bnd_ords = dict_.values_by_key(bond_orders(rgr), bnd_keys)
bnd_ord_incs = dict_.values_by_key(bnd_ord_inc_dct, bnd_keys, fill_val=0)
new_bnd_ords = numpy.add(bnd_ords, bnd_ord_incs)
bnd_ord_dct = dict(zip(bnd_keys, new_bnd_ords))
rgr = set_bond_orders(rgr, bnd_ord_dct)
return rgr
def equivalent_bonds(gra, bnd_key, stereo=True, dummy=True):
""" Identify sets of isomorphically equivalent bonds
Two bonds are equivalent if they transform into each other under an
automorphism
:param gra: A graph
:param bnd_key: An bond key for the graph, which may be sorted or unsorted
:param backbone_only: Compare backbone atoms only?
:type stereo: bool
:param dummy: Consider dummy atoms?
:type dummy: bool
:returns: Keys to equivalent bonds
:rtype: frozenset
"""
bnd_key = tuple(bnd_key)
bnd_keys = list(map(tuple, map(sorted, bond_keys(gra))))
bnd_keys += list(map(tuple, map(reversed, bnd_keys)))
assert bnd_key in bnd_keys, f"{bnd_key} not in {bnd_keys}"
atm_symb_dct = atom_symbols(gra)
atm_ngbs_dct = atoms_neighbor_atom_keys(gra)
def _symbols(bnd_key):
return list(map(atm_symb_dct.__getitem__, bnd_key))
def _neighbor_symbols(bnd_key):
key1, key2 = bnd_key
nsymbs1 = sorted(map(atm_symb_dct.__getitem__, atm_ngbs_dct[key1]))
nsymbs2 = sorted(map(atm_symb_dct.__getitem__, atm_ngbs_dct[key2]))
return nsymbs1, nsymbs2
# 1. Find bonds with the same atom types
bnd_symbs = _symbols(bnd_key)
cand_keys = [k for k in bnd_keys if _symbols(k) == bnd_symbs]
# 2. Of those, find bonds with the same neighboring atom types
bnd_ngb_symbs = _neighbor_symbols(bnd_key)
cand_keys = [k for k in cand_keys
if _neighbor_symbols(k) == bnd_ngb_symbs]
# 3. Find the equivalent bonds from the list of candidates.
# Strategy: Change the atom symbols to 'Lv' and 'Ts' and check for
# isomorphism. Assumes none of the compounds have element 116 or 117.
bnd_keys = []
for key in cand_keys:
if are_equivalent_bonds(gra, bnd_key, key, stereo=stereo, dummy=dummy):
bnd_keys.append(key)
return frozenset(bnd_keys)
def resonance_avg_bond_orders(rgr):
""" resonance-dominant bond orders, by bond
"""
rgr = without_fractional_bonds(rgr)
bnd_keys = list(bond_keys(rgr))
bnd_ords_by_res = [
dict_.values_by_key(bond_orders(dom_rgr), bnd_keys)
for dom_rgr in dominant_resonances(rgr)
]
nres = len(bnd_ords_by_res)
bnd_ords_lst = zip(*bnd_ords_by_res)
avg_bnd_ord_lst = [sum(bnd_ords) / nres for bnd_ords in bnd_ords_lst]
avg_bnd_ord_dct = dict(zip(bnd_keys, avg_bnd_ord_lst))
return avg_bnd_ord_dct
def stereo_priority_vector(gra, atm_key, atm_ngb_key):
""" generates a sortable one-to-one representation of the branch extending
from `atm_key` through its bonded neighbor `atm_ngb_key`
"""
bbn_keys = backbone_keys(gra)
exp_hyd_keys = explicit_hydrogen_keys(gra)
if atm_ngb_key not in bbn_keys:
assert atm_ngb_key in exp_hyd_keys
assert frozenset({atm_key, atm_ngb_key}) in bond_keys(gra)
pri_vec = ()
else:
gra = implicit(gra)
atm_dct = atoms(gra)
bnd_dct = bonds(gra)
assert atm_key in bbn_keys
assert frozenset({atm_key, atm_ngb_key}) in bnd_dct
# here, switch to an implicit graph
atm_ngb_keys_dct = atoms_neighbor_atom_keys(gra)
def _priority_vector(atm1_key, atm2_key, seen_keys):
# we keep a list of seen keys to cut off cycles, avoiding infinite
# loops
bnd_val = bnd_dct[frozenset({atm1_key, atm2_key})]
atm_val = atm_dct[atm2_key]
bnd_val = _replace_nones_with_negative_infinity(bnd_val)
atm_val = _replace_nones_with_negative_infinity(atm_val)
if atm2_key in seen_keys:
ret = (bnd_val, )
else:
seen_keys.update({atm1_key, atm2_key})
atm3_keys = atm_ngb_keys_dct[atm2_key] - {atm1_key}
if atm3_keys:
next_vals, seen_keys = zip(*[
_priority_vector(atm2_key, atm3_key, seen_keys)
for atm3_key in atm3_keys
])
ret = (bnd_val, atm_val) + next_vals
else:
ret = (bnd_val, atm_val)
return ret, seen_keys
pri_vec, _ = _priority_vector(atm_key, atm_ngb_key, set())
return pri_vec
def radical_dissociation_products(gra, pgra1):
""" For a given species, determine the products of a dissociation
occuring around a radical site. We assume one of the
dissociation products is known, and we attempt to find the
corresponding product.
Currently, we assume that the input pgra1 is appropriately
stereolabeled.
:param gra: species undergoing dissociation
:type gra: automol.graph object
:param pgra1: one of the known products of dissociation
:type pgra1: automol.graph object
:rtype: tuple(automol.graph.object)
"""
# Remove gractional bonds for functions to work
gra = without_fractional_bonds(gra)
# Attempt to find a graph of product corresponding to pgra1
pgra2 = None
for rad in sing_res_dom_radical_atom_keys(gra):
for adj in atoms_neighbor_atom_keys(gra)[rad]:
for group in atom_groups(gra, adj, stereo=False):
if isomorphism(group, pgra1, backbone_only=True):
pgra2 = remove_atoms(gra, atom_keys(group))
if bond_keys(group) in pgra2:
pgra2 = remove_bonds(pgra2, bond_keys(group))
# If pgra2 is ID'd, rebuild the two product graphs with stereo labels
if pgra2 is not None:
keys2 = atom_keys(pgra2)
idx_gra = to_index_based_stereo(gra)
idx_pgra2 = subgraph(idx_gra, keys2, stereo=True)
pgra2 = from_index_based_stereo(idx_pgra2)
return pgra1, pgra2
def from_graph(gra):
""" networkx graph object from a molecular graph
"""
nxg = networkx.Graph()
nxg.add_nodes_from(atom_keys(gra))
nxg.add_edges_from(bond_keys(gra))
networkx.set_node_attributes(nxg, atom_symbols(gra), 'symbol')
networkx.set_node_attributes(nxg, atom_implicit_hydrogen_valences(gra),
'implicit_hydrogen_valence')
networkx.set_node_attributes(nxg, atom_stereo_parities(gra),
'stereo_parity')
networkx.set_edge_attributes(nxg, bond_orders(gra), 'order')
networkx.set_edge_attributes(nxg, bond_stereo_parities(gra),
'stereo_parity')
return nxg
def rotational_groups(gra, key1, key2, dummy=False):
""" get the rotational groups for a given rotational axis
:param gra: the graph
:param key1: the first atom key
:param key2: the second atom key
"""
if not dummy:
gra = without_dummy_atoms(gra)
bnd_key = frozenset({key1, key2})
assert bnd_key in bond_keys(gra)
grp1 = branch_atom_keys(gra, key2, bnd_key) - {key1}
grp2 = branch_atom_keys(gra, key1, bnd_key) - {key2}
grp1 = tuple(sorted(grp1))
grp2 = tuple(sorted(grp2))
return grp1, grp2
def from_graph(gra):
""" igraph object from a molecular graph
"""
atm_keys = sorted(atom_keys(gra))
bnd_keys = sorted(bond_keys(gra), key=sorted)
atm_vals = dict_.values_by_key(atoms(gra), atm_keys)
bnd_vals = dict_.values_by_key(bonds(gra), bnd_keys)
atm_colors = list(itertools.starmap(_encode_vertex_attributes, atm_vals))
bnd_colors = list(itertools.starmap(_encode_edge_attributes, bnd_vals))
atm_idx_dct = dict(map(reversed, enumerate(atm_keys)))
bnd_idxs = [sorted(map(atm_idx_dct.__getitem__, k)) for k in bnd_keys]
igr = igraph.Graph(bnd_idxs)
igr.vs['keys'] = atm_keys
igr.vs['color'] = atm_colors
igr.es['color'] = bnd_colors
return igr
def bond_symmetry_numbers(gra, frm_bnd_key=None, brk_bnd_key=None):
""" symmetry numbers, by bond
TODO: DEPRECATE -- I think this function can be replaced with
rotational_symmetry_number(). Passing in formed and broken keys is
unnecessary if one passes in a TS graph, which is stored in the reaction
object.
the (approximate) symmetry number of the torsional potential for this bond,
based on the hydrogen counts for each atom
It is reduced to 1 if one of the H atoms in the torsional bond is a
neighbor to the special bonding atom (the atom that is being transferred)
"""
imp_gra = implicit(gra)
atm_imp_hyd_vlc_dct = atom_implicit_hydrogen_valences(imp_gra)
bnd_keys = bond_keys(imp_gra)
tfr_atm = None
if frm_bnd_key and brk_bnd_key:
for atm_f in list(frm_bnd_key):
for atm_b in list(brk_bnd_key):
if atm_f == atm_b:
tfr_atm = atm_f
if tfr_atm:
neighbor_dct = atoms_neighbor_atom_keys(gra)
nei_tfr = neighbor_dct[tfr_atm]
atms = gra[0]
all_hyds = []
for atm in atms:
if atms[atm][0] == 'H':
all_hyds.append(atm)
else:
nei_tfr = {}
bnd_symb_num_dct = {}
bnd_symb_nums = []
for bnd_key in bnd_keys:
bnd_sym = 1
vlc = max(map(atm_imp_hyd_vlc_dct.__getitem__, bnd_key))
if vlc == 3:
bnd_sym = 3
if tfr_atm:
for atm in nei_tfr:
nei_s = neighbor_dct[atm]
h_nei = 0
for nei in nei_s:
if nei in all_hyds:
h_nei += 1
if h_nei == 3:
bnd_sym = 1
bnd_symb_nums.append(bnd_sym)
bnd_symb_num_dct = dict(zip(bnd_keys, bnd_symb_nums))
# fill in the rest of the bonds for completeness
bnd_symb_num_dct = dict_.by_key(bnd_symb_num_dct,
bond_keys(gra),
fill_val=1)
return bnd_symb_num_dct
def sorted_ring_atom_keys(rng):
""" get a ring's atom keys, sorted in order of connectivity
"""
return sorted_ring_atom_keys_from_bond_keys(bond_keys(rng))
