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 ring_atom_chirality(gra, atm, ring_atms, stereo=False):
"""is this ring atom a chiral center?
"""
if not stereo:
gra = without_stereo_parities(gra)
adj_atms = atoms_neighbor_atom_keys(gra)
keys = []
for atmi in adj_atms[atm]:
key = [atm, atmi]
key.sort()
key = frozenset(key)
keys.append(key)
if atmi in ring_atms:
for atmj in adj_atms[atmi]:
if atmj in ring_atms:
key = [atmj, atmi]
key.sort()
key = frozenset(key)
keys.append(key)
gras = remove_bonds(gra, keys)
cgras = connected_components(gras)
ret_gras = []
for gra_i in cgras:
atms_i = atom_keys(gra_i)
if [x for x in atms_i if x in adj_atms[atm] or x == atm]:
ret_gras.append(gra_i)
return ret_gras
def reactants_graph(tsg):
""" get a graph of the reactants from a transition state graph
"""
frm_bnd_keys = forming_bond_keys(tsg)
ord_dct = dict_.transform_values(bond_orders(tsg), func=round)
gra = set_bond_orders(tsg, ord_dct)
gra = remove_bonds(gra, frm_bnd_keys)
return gra
def atom_groups(gra, atm, stereo=False):
""" return a list of groups off of one atom
TODO: MERGE WITH BRANCH FUNCTIONS OR MAKE NAMING CONSISTENT SOMEHOW
"""
if not stereo:
gra = without_stereo_parities(gra)
adj_atms = atoms_neighbor_atom_keys(gra)
keys = []
for atmi in adj_atms[atm]:
key = [atm, atmi]
key.sort()
key = frozenset(key)
keys.append(key)
gras = remove_bonds(gra, keys)
return connected_components(gras)
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 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