def _unique_gras(gra_lst): """ Determine all of the unique gras deals with gras with multiple components """ uni_gras = tuple() if gra_lst: # Initialize list with first element uni_gras += (gra_lst[0], ) # Test if the del_gra is isomorphic to any of the uni_del_gras for gra in gra_lst[1:]: new_uni = True for uni_gra in uni_gras: if len(gra) == 1: isodct = full_isomorphism(gra[0], uni_gra[0]) else: isodct = full_isomorphism(union(*gra), union(*uni_gra)) if isodct: new_uni = False break # Add graph and idx to lst if del gra is unique if new_uni: uni_gras += (gra, ) return uni_gras
def chem_unique_atoms_of_type(gra, asymb): """ For the given atom type, determine the idxs of all the chemically unique atoms. """ # Get the indices for the atom type symb_idx_dct = atom_symbol_idxs(gra) atom_idxs = symb_idx_dct[asymb] # Loop over each idx uni_idxs = tuple() uni_del_gras = [] for idx in atom_idxs: # Remove the atom from the graph del_gra = remove_atoms(gra, [idx]) # Test if the del_gra is isomorphic to any of the uni_del_gras new_uni = True for uni_del_gra in uni_del_gras: iso_dct = full_isomorphism(del_gra, uni_del_gra) if iso_dct: new_uni = False break # Add graph and idx to lst if del gra is unique if new_uni: uni_del_gras.append(del_gra) uni_idxs += (idx,) return uni_idxs
def _radical_graph_isomorphisms(gra): """ Generate a set of graphs where the radical has been migrated to a new atom and then calculate the isomorphism between the input graph and all of the new graphs generated by moving the radical """ # Determine useful keys symbols = atom_symbols(gra) unsat_keys = unsaturated_atom_keys(gra) unsat_key = next(iter(unsat_keys)) h_atm_key = max(symbols.keys()) + 1 new_gras, isomorphisms = [], [] for aidx, symbol in enumerate(symbols.values()): # Loop over saturated (non-radical) heavy atoms if symbol != 'H' and aidx != unsat_key: # Add hydrogen atom to radical atom new_graph = add_atom_explicit_hydrogen_keys( gra, {unsat_key: [h_atm_key]}) # Remove hydrogen from saturated atom neighbors = atoms_neighbor_atom_keys(new_graph) for neigh in neighbors[aidx]: if symbols[neigh] == 'H': aneighbor = neigh break new_graph = remove_atoms(new_graph, [aneighbor]) # Build lists to return new_gras.append(new_graph) isomorphisms.append(full_isomorphism(gra, new_graph)) return tuple(zip(new_gras, isomorphisms))
def isomorphic_radical_graphs(gra): """ Generate a set of graphs that are isomorphic to a graph of a radical species """ # Determine useful keys symbols = atom_symbols(gra) unsat_keys = unsaturated_atom_keys(gra) unsat_key = next(iter(unsat_keys)) h_atm_key = max(symbols.keys()) + 1 iso_gras = [] for aidx, symbol in enumerate(symbols.values()): # Loop over saturated (non-radical) heavy atoms if symbol != 'H' and aidx != unsat_key: # Add hydrogen atom to radical atom new_graph = add_atom_explicit_hydrogen_keys( gra, {unsat_key: [h_atm_key]}) # Remove hydrogen from saturated atom neighbors = atom_neighbor_keys(new_graph) for neigh in neighbors[aidx]: if symbols[neigh] == 'H': aneighbor = neigh break new_graph = remove_atoms(new_graph, [aneighbor]) # Test to see if new radical species is the same as the original inv_atm_key_dct = full_isomorphism(gra, new_graph) if inv_atm_key_dct: iso_gras.append(new_graph) return iso_gras
def is_stereo_compatible(tra, sgr1, sgr2): """ is this transformation compatible with the reactant/product stereo assignments? """ cgr1 = without_stereo_parities(sgr1) cgr2 = without_stereo_parities(sgr2) atm_key_dct = full_isomorphism(apply(tra, cgr1), cgr2) # determine the stereo centers which are preserved in the transformation sgr1 = _relabel(sgr1, atm_key_dct) atm_keys = sorted(atom_stereo_keys(sgr1) & atom_stereo_keys(sgr2)) bnd_keys = sorted(bond_stereo_keys(sgr1) & bond_stereo_keys(sgr2)) atm_pars1 = dict_.values_by_key(atom_stereo_parities(sgr1), atm_keys) atm_pars2 = dict_.values_by_key(atom_stereo_parities(sgr2), atm_keys) bnd_pars1 = dict_.values_by_key(bond_stereo_parities(sgr1), bnd_keys) bnd_pars2 = dict_.values_by_key(bond_stereo_parities(sgr2), bnd_keys) atm_ngb_keys_dct1 = atom_neighbor_keys(sgr1) atm_ngb_keys_dct2 = atom_neighbor_keys(sgr2) ret = True for atm_key, par1, par2 in zip(atm_keys, atm_pars1, atm_pars2): atm_ngb_keys1 = stereo_sorted_atom_neighbor_keys( sgr1, atm_key, atm_ngb_keys_dct1[atm_key]) atm_ngb_keys2 = stereo_sorted_atom_neighbor_keys( sgr2, atm_key, atm_ngb_keys_dct2[atm_key]) if _permutation_parity(atm_ngb_keys1, atm_ngb_keys2): ret &= (par1 == par2) else: ret &= (par1 != par2) for bnd_key, par1, par2 in zip(bnd_keys, bnd_pars1, bnd_pars2): atm1_key, atm2_key = bnd_key atm1_ngb_key1 = stereo_sorted_atom_neighbor_keys( sgr1, atm1_key, atm_ngb_keys_dct1[atm1_key] - {atm2_key})[0] atm2_ngb_key1 = stereo_sorted_atom_neighbor_keys( sgr1, atm2_key, atm_ngb_keys_dct1[atm2_key] - {atm1_key})[0] atm1_ngb_key2 = stereo_sorted_atom_neighbor_keys( sgr2, atm1_key, atm_ngb_keys_dct2[atm1_key] - {atm2_key})[0] atm2_ngb_key2 = stereo_sorted_atom_neighbor_keys( sgr2, atm2_key, atm_ngb_keys_dct2[atm2_key] - {atm1_key})[0] if not ((atm1_ngb_key1 != atm1_ngb_key2) ^ (atm2_ngb_key1 != atm2_ngb_key2)): ret &= (par1 == par2) else: ret &= (par1 != par2) return ret
def ring_forming_scission(rct_gras, prd_gras): """ find a ring forming reaction that eliminates a radical group """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) tras = [] rct_idxs = None prd_idxs = None is_triv = is_trivial_reaction(rct_gras, prd_gras) if len(rct_gras) == 1 and len(prd_gras) == 2 and not is_triv: rgra, = rct_gras pgra1, pgra2 = prd_gras pgra = automol.graph.union(pgra1, pgra2) rad_atm_keys = unsaturated_atom_keys(rgra) atms, bnds = rgra ngb_atms = automol.graph.atom_neighbor_keys(rgra) for rad_atm in rad_atm_keys: for xatm in atms: if (xatm != rad_atm and atms[xatm][1] != 'H' and xatm not in ngb_atms[rad_atm] and not tras): for natm in ngb_atms[xatm]: if natm != rad_atm: xgra = atms.copy(), bnds.copy() xgra = add_bonds(xgra, [frozenset({rad_atm, xatm})]) xgra = remove_bonds(xgra, [frozenset({xatm, natm})]) atm_key_dct = full_isomorphism(xgra, pgra) if atm_key_dct: tra = trans.from_data( rxn_class=( par.REACTION_CLASS.RING_FORM_SCISSION), frm_bnd_keys=[{rad_atm, xatm}], brk_bnd_keys=[ {xatm, natm}, ]) tras.append(tra) break # sort the reactants so that the largest species is first rct_idxs = (0, ) prd_idxs = _argsort_reactants(prd_gras) tras = tuple(tras) return tras, rct_idxs, prd_idxs
def _partial_hydrogen_abstraction(qh_gra, q_gra): rets = [] h_atm_key = max(atom_keys(q_gra)) + 1 uns_atm_keys = unsaturated_atom_keys(q_gra) for atm_key in uns_atm_keys: q_gra_h = add_atom_explicit_hydrogen_keys(q_gra, {atm_key: [h_atm_key]}) inv_atm_key_dct = full_isomorphism(q_gra_h, qh_gra) if inv_atm_key_dct: qh_q_atm_key = inv_atm_key_dct[atm_key] qh_h_atm_key = inv_atm_key_dct[h_atm_key] q_q_atm_key = atm_key rets.append((qh_q_atm_key, qh_h_atm_key, q_q_atm_key)) return rets
def hydrogen_migration(rct_gras, prd_gras): """ find a hydrogen migration transformation Hydrogen migrations are identified by adding a hydrogen to an unsaturated site of the reactant and adding a hydrogen to an unsaturated site of the product and seeing if they match up. If so, we have a hydrogen migration between these two sites. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) tras = [] rct_idxs = None prd_idxs = None is_triv = is_trivial_reaction(rct_gras, prd_gras) if len(rct_gras) == 1 and len(prd_gras) == 1 and not is_triv: gra1, = rct_gras gra2, = prd_gras h_atm_key1 = max(atom_keys(gra1)) + 1 h_atm_key2 = max(atom_keys(gra2)) + 1 atm_keys1 = unsaturated_atom_keys(gra1) atm_keys2 = unsaturated_atom_keys(gra2) for atm_key1, atm_key2 in itertools.product(atm_keys1, atm_keys2): gra1_h = add_atom_explicit_hydrogen_keys(gra1, {atm_key1: [h_atm_key1]}) gra2_h = add_atom_explicit_hydrogen_keys(gra2, {atm_key2: [h_atm_key2]}) inv_atm_key_dct = full_isomorphism(gra2_h, gra1_h) if inv_atm_key_dct: tra = trans.from_data( rxn_class=par.REACTION_CLASS.HYDROGEN_MIGRATION, frm_bnd_keys=[{atm_key1, inv_atm_key_dct[h_atm_key2]}], brk_bnd_keys=[{ inv_atm_key_dct[atm_key2], inv_atm_key_dct[h_atm_key2] }]) tras.append(tra) rct_idxs = (0, ) prd_idxs = (0, ) tras = tuple(tras) return tras, rct_idxs, prd_idxs
def trivial_reaction(rct_gras, prd_gras): """ is this a trivial reaction, with the same reactants and products? """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) tras = [] rct_idxs = None prd_idxs = None if len(rct_gras) == len(prd_gras): prd_gras = list(prd_gras) num = len(rct_gras) rct_idxs = tuple(range(num)) prd_idxs = [0] * num # cycle through reactants and check for matching products for rct_idx, rct_gra in enumerate(rct_gras): prd_idx = next((idx for idx, prd_gra in enumerate(prd_gras) if full_isomorphism(rct_gra, prd_gra)), None) # if the reactant has a matching product, remove it from the # products list if prd_idx is not None: prd_idxs[rct_idx] = prd_idx prd_gras.pop(prd_idx) # if the reactant has no matching product, this is not a # trivial reaction else: tras = [] rct_idxs = prd_idxs = None break if rct_idxs is not None: tra = trans.from_data(rxn_class=par.REACTION_CLASS.TRIVIAL, frm_bnd_keys=[], brk_bnd_keys=[]) tras = (tra, ) rct_idxs = tuple(rct_idxs) prd_idxs = tuple(prd_idxs) tras = tuple(tras) return tras, rct_idxs, prd_idxs
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): if full_isomorphism(explicit(group), explicit(pgra1)): 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 substitution(rct_gras, prd_gras): """ find an substitution transformation Substitutions are identified by breaking one bond in the reactants and one bond from the products and checking for isomorphism. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) tras = [] rct_idxs = None prd_idxs = None is_triv = is_trivial_reaction(rct_gras, prd_gras) if len(rct_gras) == 2 and len(prd_gras) == 2 and not is_triv: rct_gra = union_from_sequence(rct_gras) prd_gra = union_from_sequence(prd_gras) rct_bnd_keys = bond_keys(rct_gra) prd_bnd_keys = bond_keys(prd_gra) for rct_bnd_key, prd_bnd_key in itertools.product( rct_bnd_keys, prd_bnd_keys): rct_gra_ = remove_bonds(rct_gra, [rct_bnd_key]) prd_gra_ = remove_bonds(prd_gra, [prd_bnd_key]) inv_atm_key_dct = full_isomorphism(prd_gra_, rct_gra_) if inv_atm_key_dct: brk_bnd_key = rct_bnd_key frm_bnd_key = frozenset( map(inv_atm_key_dct.__getitem__, prd_bnd_key)) tra = trans.from_data( rxn_class=par.REACTION_CLASS.SUBSTITUTION, frm_bnd_keys=[frm_bnd_key], brk_bnd_keys=[brk_bnd_key]) tras.append(tra) rct_idxs = _argsort_reactants(rct_gras) prd_idxs = _argsort_reactants(prd_gras) tras = tuple(set(tras)) return tras, rct_idxs, prd_idxs
def reverse(tra, xgr1, xgr2): """ reverse a transformation to get the one taking products into reactants """ rxn_class = reaction_class(tra) frm_bnd_keys = formed_bond_keys(tra) brk_bnd_keys = broken_bond_keys(tra) atm_key_dct = full_isomorphism(apply(tra, xgr1), xgr2) rev_rxn_class = reverse_class(rxn_class) rev_frm_bnd_keys = [ frozenset(map(atm_key_dct.__getitem__, bnd_key)) for bnd_key in brk_bnd_keys ] rev_brk_bnd_keys = [ frozenset(map(atm_key_dct.__getitem__, bnd_key)) for bnd_key in frm_bnd_keys ] rev_tra = from_data(rxn_class=rev_rxn_class, frm_bnd_keys=rev_frm_bnd_keys, brk_bnd_keys=rev_brk_bnd_keys) return rev_tra
def addition(rct_gras, prd_gras): """ find an addition transformation Additions are identified by joining an unsaturated site on one reactant to an unsaturated site on the other. If the result matches the products, this is an addition reaction. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) tras = [] rct_idxs = None prd_idxs = None is_triv = is_trivial_reaction(rct_gras, prd_gras) if len(rct_gras) == 2 and len(prd_gras) == 1 and not is_triv: x_gra, y_gra = rct_gras prd_gra, = prd_gras x_atm_keys = unsaturated_atom_keys(x_gra) y_atm_keys = unsaturated_atom_keys(y_gra) for x_atm_key, y_atm_key in itertools.product(x_atm_keys, y_atm_keys): xy_gra = add_bonds(union(x_gra, y_gra), [{x_atm_key, y_atm_key}]) atm_key_dct = full_isomorphism(xy_gra, prd_gra) if atm_key_dct: tra = trans.from_data(rxn_class=par.REACTION_CLASS.ADDITION, frm_bnd_keys=[{x_atm_key, y_atm_key}], brk_bnd_keys=[]) tras.append(tra) # sort the reactants so that the largest species is first rct_idxs = _argsort_reactants(rct_gras) prd_idxs = (0, ) tras = tuple(tras) return tras, rct_idxs, prd_idxs
def prod_hydrogen_migration(gra): """ products of hydrogen migration """ prod_gras = tuple() keys = atom_keys(gra) num_keys = len(keys) if num_keys > 2: rad_idxs = resonance_dominant_radical_atom_keys(gra) uni_h_idxs = chem_unique_atoms_of_type(gra, 'H') h_atm_key = max(keys) + 1 for h_idx in uni_h_idxs: for rad_idx in rad_idxs: gra2 = remove_atoms(gra, [h_idx]) gra2_h = add_atom_explicit_hydrogen_keys( gra2, {rad_idx: [h_atm_key]}) if not full_isomorphism(gra, gra2_h): prod_gras += ((gra2_h, ), ) return _unique_gras(prod_gras)
def elimination(rct_gras, prd_gras): """ find an elimination transformation Eliminations are identified by breaking two bonds from the reactant, forming three fragments. This will form one "central fragment" with two break sites and two "end fragments" with one break site each. If the central fragment plus the two end fragments, joined at their break sites, matches the products, this is an elimination reaction. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) tras = [] rct_idxs = None prd_idxs = None is_triv = is_trivial_reaction(rct_gras, prd_gras) if len(rct_gras) == 1 and len(prd_gras) == 2 and not is_triv: rct_gra, = rct_gras rct_bnd_keys = bond_keys(rct_gra) # Loop over pairs of bonds and break them. Then, if this forms three # fragments, join the two end fragments and compare the result to the # products. for brk_bnd_key1, brk_bnd_key2 in itertools.combinations(rct_bnd_keys, r=2): rct_gra_ = remove_bonds(rct_gra, [brk_bnd_key1, brk_bnd_key2]) # Find the central fragment, which is the one connected to both # break sites. If there's a loop there may not be a central # fragment, in which case this function will return None. cent_frag_atm_keys = _central_fragment_atom_keys( rct_gra_, brk_bnd_key1, brk_bnd_key2) if cent_frag_atm_keys is not None: atm1_key, = brk_bnd_key1 - cent_frag_atm_keys atm2_key, = brk_bnd_key2 - cent_frag_atm_keys frm_bnd_key = frozenset({atm1_key, atm2_key}) rct_gra_ = add_bonds(rct_gra_, [frm_bnd_key]) prd_gra = union_from_sequence(prd_gras) atm_key_dct = full_isomorphism(rct_gra_, prd_gra) if atm_key_dct: tra = trans.from_data( rxn_class=par.REACTION_CLASS.ELIMINATION, frm_bnd_keys=[frm_bnd_key], brk_bnd_keys=[brk_bnd_key1, brk_bnd_key2]) tras.append(tra) rct_idxs = (0, ) cent_prd_atm_keys = frozenset( map(atm_key_dct.__getitem__, cent_frag_atm_keys)) if cent_prd_atm_keys <= atom_keys(prd_gras[0]): prd_idxs = (0, 1) else: assert cent_prd_atm_keys <= atom_keys(prd_gras[1]) prd_idxs = (1, 0) tras = tuple(tras) return tras, rct_idxs, prd_idxs