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))