def substitutions(rct_gras, prd_gras): """ find substitutions consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) 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) rxns = [] if len(rct_gras) == 2 and len(prd_gras) == 2: rct_gra = union_from_sequence(rct_gras) prd_gra = union_from_sequence(prd_gras) for rgra1, rgra2 in itertools.permutations(rct_gras): bnd_keys = bond_keys(rgra1) rad_keys = unsaturated_atom_keys(rgra2) for bnd_key, rad_key in itertools.product(bnd_keys, rad_keys): gra = remove_bonds(rct_gra, [bnd_key]) for brk_key1 in bnd_key: gra = add_bonds(gra, [(brk_key1, rad_key)]) inv_dct = isomorphism(gra, prd_gra) if inv_dct: brk_key2, = bnd_key - {brk_key1} f_frm_bnd_key = (brk_key1, rad_key) f_brk_bnd_key = (brk_key1, brk_key2) b_frm_bnd_key = (inv_dct[brk_key1], inv_dct[brk_key2]) b_brk_bnd_key = (inv_dct[brk_key1], inv_dct[rad_key]) forw_tsg = ts.graph(rct_gra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[f_brk_bnd_key]) back_tsg = ts.graph(prd_gra, frm_bnd_keys=[b_frm_bnd_key], brk_bnd_keys=[b_brk_bnd_key]) rcts_atm_keys = [atom_keys(rgra1), atom_keys(rgra2)] prds_atm_keys = list(map(atom_keys, prd_gras)) if inv_dct[rad_key] not in prds_atm_keys[0]: prds_atm_keys = list(reversed(prds_atm_keys)) # Create the reaction object rxns.append( Reaction( rxn_cls=par.ReactionClass.SUBSTITUTION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=rcts_atm_keys, prds_keys=prds_atm_keys, )) return ts_unique(rxns)
def trivial(rct_gras, prd_gras): """ find 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) rxns = [] if len(rct_gras) == len(prd_gras): prd_gras = list(prd_gras) rct_idxs = [] prd_idxs = [] # One at a time, find matches for each reactant; track the positions to # get the right sort order for rct_idx, rct_gra in enumerate(rct_gras): prd_idx = next((idx for idx, prd_gra in enumerate(prd_gras) if isomorphism(rct_gra, prd_gra)), None) if prd_idx is not None: rct_idxs.append(rct_idx) prd_idxs.append(prd_idx) prd_gras.pop(prd_idx) else: break if rct_idxs and prd_idxs: # reorder the reactants and products rct_gras = list(map(rct_gras.__getitem__, rct_idxs)) prd_gras = list(map(prd_gras.__getitem__, prd_idxs)) rcts_gra = union_from_sequence(rct_gras) prds_gra = union_from_sequence(prd_gras) rxns.append( Reaction( rxn_cls=par.ReactionClass.TRIVIAL, forw_tsg=ts.graph(rcts_gra, [], []), back_tsg=ts.graph(prds_gra, [], []), rcts_keys=list(map(atom_keys, rct_gras)), prds_keys=list(map(atom_keys, prd_gras)), )) return tuple(rxns)
def ring_forming_scissions(rct_gras, prd_gras): """ find ring-forming scissions consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) Ring-forming scissions are found by breaking ring-bonds on one product and joining the ends to unsaturated sites on the other product """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 1 and len(prd_gras) == 2: rgra, = rct_gras pgra = union_from_sequence(prd_gras) for pgra1, pgra2 in itertools.permutations(prd_gras): bnd_keys = list(itertools.chain(*rings_bond_keys(pgra1))) atm_keys = unsaturated_atom_keys(pgra2) for bnd_key, atm_key in itertools.product(bnd_keys, atm_keys): # Break a ring bond gra = remove_bonds(pgra, [bnd_key]) for end_key in bnd_key: # Add to one end of the broken ring fgra = add_bonds(gra, [(atm_key, end_key)]) inv_dct = isomorphism(fgra, rgra) if inv_dct: other_end_key, = bnd_key - {end_key} f_frm_bnd_key = (inv_dct[end_key], inv_dct[other_end_key]) f_brk_bnd_key = (inv_dct[end_key], inv_dct[atm_key]) b_frm_bnd_key = (end_key, atm_key) b_brk_bnd_key = (end_key, other_end_key) forw_tsg = ts.graph(rgra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[f_brk_bnd_key]) back_tsg = ts.graph(pgra, frm_bnd_keys=[b_frm_bnd_key], brk_bnd_keys=[b_brk_bnd_key]) # Create the reaction object rxns.append( Reaction( rxn_cls=par.ReactionClass.RING_FORM_SCISSION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=[atom_keys(rgra)], prds_keys=[atom_keys(pgra1), atom_keys(pgra2)], )) return ts_unique(rxns)
def additions(rct_gras, prd_gras): """ find additions consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) 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) rxns = [] if len(rct_gras) == 2 and len(prd_gras) == 1: 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}]) iso_dct = isomorphism(xy_gra, prd_gra) if iso_dct: rcts_gra = union_from_sequence(rct_gras) prds_gra = prd_gra f_frm_bnd_key = (x_atm_key, y_atm_key) b_brk_bnd_key = (iso_dct[x_atm_key], iso_dct[y_atm_key]) forw_tsg = ts.graph(rcts_gra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[]) back_tsg = ts.graph(prds_gra, frm_bnd_keys=[], brk_bnd_keys=[b_brk_bnd_key]) # sort the reactants so that the largest species is first rct_idxs = _argsort_reactants(rct_gras) rct_gras = list(map(rct_gras.__getitem__, rct_idxs)) # Create the reaction object rxns.append( Reaction( rxn_cls=par.ReactionClass.ADDITION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=list(map(atom_keys, rct_gras)), prds_keys=list(map(atom_keys, prd_gras)), )) return ts_unique(rxns)
def hydrogen_abstractions(rct_gras, prd_gras): """ find hydrogen abstractions consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) Hydrogen abstractions are identified first by checking whether the molecular formulas are consistent with a reaction of the form R1H + R2 => R2H + R1. If they do, we identify the abstraction sites by adding hydrogens to unsaturated sites of the R1 product to see if we get the R1H reactant. We then do the same for the R2 reactant and the R2H product. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 2 and len(prd_gras) == 2: rct_fmls = list(map(graph_formula, rct_gras)) prd_fmls = list(map(graph_formula, prd_gras)) ret = automol.formula.reac.argsort_hydrogen_abstraction( rct_fmls, prd_fmls) if ret: rct_idxs_, prd_idxs_ = ret rct_gras = list(map(rct_gras.__getitem__, rct_idxs_)) prd_gras = list(map(prd_gras.__getitem__, prd_idxs_)) q1h_gra, q2_gra = rct_gras q2h_gra, q1_gra = prd_gras rets1 = _partial_hydrogen_abstraction(q1h_gra, q1_gra) rets2 = _partial_hydrogen_abstraction(q2h_gra, q2_gra) for ret1, ret2 in itertools.product(rets1, rets2): f_q1h_q_atm_key, f_q1h_h_atm_key, b_q2_q_atm_key = ret1 b_q1h_q_atm_key, b_q1h_h_atm_key, f_q2_q_atm_key = ret2 # Create the forward/backward ts graphs rcts_gra = union_from_sequence(rct_gras) prds_gra = union_from_sequence(prd_gras) f_frm_bnd_key = (f_q2_q_atm_key, f_q1h_h_atm_key) f_brk_bnd_key = (f_q1h_q_atm_key, f_q1h_h_atm_key) b_frm_bnd_key = (b_q2_q_atm_key, b_q1h_h_atm_key) b_brk_bnd_key = (b_q1h_q_atm_key, b_q1h_h_atm_key) forw_tsg = ts.graph(rcts_gra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[f_brk_bnd_key]) back_tsg = ts.graph(prds_gra, frm_bnd_keys=[b_frm_bnd_key], brk_bnd_keys=[b_brk_bnd_key]) # Create the reaction object rxns.append( Reaction( rxn_cls=par.ReactionClass.HYDROGEN_ABSTRACTION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=list(map(atom_keys, rct_gras)), prds_keys=list(map(atom_keys, prd_gras)), )) return ts_unique(rxns)
def eliminations(rct_gras, prd_gras): """ find eliminations consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) Eliminations are identified by forming a bond between an attacking heavy atom and another atom not initially bonded to it, forming a ring. The bond adjacent to the attacked atom is then broken, along with a second bond in the ring, downstream of the attacking heavy atom, away from the attacked atom. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 1 and len(prd_gras) == 2: rct_gra, = rct_gras prds_gra = union_from_sequence(prd_gras) ngb_keys_dct = atoms_neighbor_atom_keys(rct_gra) frm1_keys = atom_keys(rct_gra, excl_syms=('H', )) frm2_keys = atom_keys(rct_gra) bnd_keys = bond_keys(rct_gra) frm_bnd_keys = [ (frm1_key, frm2_key) for frm1_key, frm2_key in itertools.product(frm1_keys, frm2_keys) if frm1_key != frm2_key and not frozenset({frm1_key, frm2_key}) in bnd_keys ] for frm1_key, frm2_key in frm_bnd_keys: # Bond the radical atom to the hydrogen atom gra_ = add_bonds(rct_gra, [(frm2_key, frm1_key)]) # Get keys to the ring formed by this extra bond rng_keys = next((ks for ks in rings_atom_keys(gra_) if frm2_key in ks and frm1_key in ks), None) # Eliminations (as far as I can tell) only happen through TSs with # 3- or 4-membered rings if rng_keys is not None and len(rng_keys) < 5: frm1_ngb_key, = ngb_keys_dct[frm1_key] & set(rng_keys) frm2_ngb_key, = ngb_keys_dct[frm2_key] & set(rng_keys) # Break the bonds on either side of the newly formed bond gra_ = remove_bonds(gra_, [(frm1_key, frm1_ngb_key)]) gra_ = remove_bonds(gra_, [(frm2_key, frm2_ngb_key)]) inv_dct = isomorphism(gra_, prds_gra) if inv_dct: f_frm_bnd_key = (frm1_key, frm2_key) f_brk_bnd_key1 = (frm1_key, frm1_ngb_key) f_brk_bnd_key2 = (frm2_key, frm2_ngb_key) inv_ = inv_dct.__getitem__ b_frm_bnd_key1 = tuple(map(inv_, f_brk_bnd_key1)) b_frm_bnd_key2 = tuple(map(inv_, f_brk_bnd_key2)) b_brk_bnd_key = tuple(map(inv_, f_frm_bnd_key)) forw_tsg = ts.graph( rct_gra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[f_brk_bnd_key1, f_brk_bnd_key2]) back_tsg = ts.graph( prds_gra, frm_bnd_keys=[b_frm_bnd_key1, b_frm_bnd_key2], brk_bnd_keys=[b_brk_bnd_key]) rcts_atm_keys = list(map(atom_keys, rct_gras)) prds_atm_keys = list(map(atom_keys, prd_gras)) if inv_dct[frm2_key] not in prds_atm_keys[1]: prds_atm_keys = list(reversed(prds_atm_keys)) # Create the reaction object rxns.append( Reaction( rxn_cls=par.ReactionClass.ELIMINATION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=rcts_atm_keys, prds_keys=prds_atm_keys, )) return ts_unique(rxns)
def substitutions(rct_gras, prd_gras): """ find substitutions consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) Substitutions are identified by breaking one bond in the reactants and one bond from the products and checking for isomorphism. Currently it assumes that one of the reactants has a radical site that can attack the other reactants, forming a bond and breaking another. From the perspective of breaking and forming breaking bonds, substitutions are equivalent with hydrogen abstractions. Hence, we remove all cases where the forming bond involves a hydrogen atom off the reactant in which a bond is breaking. """ assert_is_valid_reagent_graph_list(rct_gras) assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 2 and len(prd_gras) == 2: rct_gra = union_from_sequence(rct_gras) prd_gra = union_from_sequence(prd_gras) # Loop over both orders of reactants: A+B and B+A for rgra1, rgra2 in itertools.permutations(rct_gras): bnd_keys = bond_keys(rgra1) atom_symb_dct = automol.graph.atom_symbols(rgra1) rad_keys = unsaturated_atom_keys(rgra2) # Break all possible bonds in total reactant for bnd_key, rad_key in itertools.product(bnd_keys, rad_keys): gra = remove_bonds(rct_gra, [bnd_key]) # Form all possible bonds between rad site and non-H atoms frm_keys = () for key in bnd_key: frm_symb = atom_symb_dct[key] if frm_symb != 'H': frm_keys += (key, ) for frm_key in frm_keys: gra = add_bonds(gra, [(frm_key, rad_key)]) inv_dct = isomorphism(gra, prd_gra) if inv_dct: brk_key2, = bnd_key - {frm_key} f_frm_bnd_key = (frm_key, rad_key) f_brk_bnd_key = (frm_key, brk_key2) b_frm_bnd_key = (inv_dct[frm_key], inv_dct[brk_key2]) b_brk_bnd_key = (inv_dct[frm_key], inv_dct[rad_key]) forw_tsg = ts.graph(rct_gra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[f_brk_bnd_key]) back_tsg = ts.graph(prd_gra, frm_bnd_keys=[b_frm_bnd_key], brk_bnd_keys=[b_brk_bnd_key]) rcts_atm_keys = [atom_keys(rgra1), atom_keys(rgra2)] prds_atm_keys = list(map(atom_keys, prd_gras)) if inv_dct[rad_key] not in prds_atm_keys[0]: prds_atm_keys = list(reversed(prds_atm_keys)) # Create the reaction object rxns.append( Reaction( rxn_cls=ReactionClass.Typ.SUBSTITUTION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=rcts_atm_keys, prds_keys=prds_atm_keys, )) return ts_unique(rxns)
def two_bond_additions(rct_gras, prd_gras): """ two bond additions """ assert_is_valid_reagent_graph_list(rct_gras) assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 2 and len(prd_gras) == 1: rct_gras = sort_reagents(rct_gras) x_gra, y_gra = rct_gras prd_gra, = prd_gras x_atm_keys = frozenset().union(unsaturated_atom_keys(x_gra), lone_pair_atom_keys(x_gra)) y_atm_keys = frozenset().union(unsaturated_atom_keys(y_gra), lone_pair_atom_keys(y_gra)) print('x,y keys', x_atm_keys, y_atm_keys) # Generate pairs of forming bonds, where each is a pair of idxs # describing the atoms making up the forming bond: # (frm1, frm2) = ((idx1, idx2), (idx1, idx2)) frm_bnd_pairs = tuple(itertools.product(x_atm_keys, y_atm_keys)) frm_bnds_lst = () for pair in itertools.product(frm_bnd_pairs, frm_bnd_pairs): # Preclude pairs with same idxs (formind same bond twice) if pair[0] != pair[1]: # Preclude multiple bonds formed to same atom X---A---Y if pair[0][0] != pair[1][0] and pair[0][1] != pair[1][1]: # Preclude the reverse if pair[::-1] not in frm_bnds_lst: frm_bnds_lst += (pair, ) for frm_bnd_keys in frm_bnds_lst: xy_gra = add_bonds(union(x_gra, y_gra), [set(frm_bnd_keys[0]), set(frm_bnd_keys[1])]) iso_dct = isomorphism(xy_gra, prd_gra) if iso_dct: rcts_gra = union_from_sequence(rct_gras) prds_gra = prd_gra b_brk_bnd_keys = [[ iso_dct[frm_bnd_keys[0][0]], iso_dct[frm_bnd_keys[0][1]] ], [iso_dct[frm_bnd_keys[1][0]], iso_dct[frm_bnd_keys[1][1]]]] forw_tsg = ts.graph(rcts_gra, frm_bnd_keys=frm_bnd_keys, brk_bnd_keys=[]) back_tsg = ts.graph(prds_gra, frm_bnd_keys=[], brk_bnd_keys=b_brk_bnd_keys) # Create the reaction object rxns.append( Reaction( rxn_cls=ReactionClass.Typ.ADDITION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=list(map(atom_keys, rct_gras)), prds_keys=list(map(atom_keys, prd_gras)), )) return ts_unique(rxns)
def eliminations(rct_gras, prd_gras): """ find eliminations consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) Eliminations are identified by forming a bond between an attacking heavy atom and another atom not initially bonded to it, forming a ring. The bond adjacent to the attacked atom is then broken, along with a second bond in the ring, downstream of the attacking heavy atom, away from the attacked atom. """ def _identify(frm1_keys, frm2_keys, bnd_keys): """ Try and identify elmination from some set of keys """ _rxns = [] frm_bnd_keys = [ (frm1_key, frm2_key) for frm1_key, frm2_key in itertools.product(frm1_keys, frm2_keys) if frm1_key != frm2_key and not frozenset({frm1_key, frm2_key}) in bnd_keys ] for frm1_key, frm2_key in frm_bnd_keys: prds_gra_ = add_bonds(rct_gra, [(frm2_key, frm1_key)]) # Get keys of all bonds in the ring formed by this extra bond rng_bnd_keys = next((ks for ks in rings_bond_keys(prds_gra_) if frozenset({frm1_key, frm2_key}) in ks), None) if rng_bnd_keys is not None: # Elims break two bonds of the ring formed by the forming bond # Loop over all ring bond-pairs, break bonds, see if prods form # Ensure to preclude the forming-bond from this set brk_bnds = tuple( bond for bond in itertools.combinations(rng_bnd_keys, 2) if frozenset({frm1_key, frm2_key}) not in bond) for brk_bnd_1, brk_bnd_2 in brk_bnds: prds_gra_2_ = prds_gra_ prds_gra_2_ = remove_bonds(prds_gra_2_, [brk_bnd_1]) prds_gra_2_ = remove_bonds(prds_gra_2_, [brk_bnd_2]) inv_dct = isomorphism(prds_gra_2_, prds_gra) if inv_dct: f_frm_bnd_key = (frm1_key, frm2_key) inv_ = inv_dct.__getitem__ b_frm_bnd_key1 = tuple(map(inv_, brk_bnd_1)) b_frm_bnd_key2 = tuple(map(inv_, brk_bnd_2)) b_brk_bnd_key = tuple(map(inv_, f_frm_bnd_key)) forw_tsg = ts.graph( rct_gra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[brk_bnd_1, brk_bnd_2]) back_tsg = ts.graph( prds_gra, frm_bnd_keys=[b_frm_bnd_key1, b_frm_bnd_key2], brk_bnd_keys=[b_brk_bnd_key]) rcts_atm_keys = list(map(atom_keys, rct_gras)) prds_atm_keys = list(map(atom_keys, prd_gras)) if inv_dct[frm1_key] not in prds_atm_keys[1]: prds_atm_keys = list(reversed(prds_atm_keys)) assert inv_dct[frm1_key] in prds_atm_keys[1] assert inv_dct[frm2_key] in prds_atm_keys[1] # Create the reaction object _rxns.append( Reaction( rxn_cls=ReactionClass.Typ.ELIMINATION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=rcts_atm_keys, prds_keys=prds_atm_keys, )) return _rxns assert_is_valid_reagent_graph_list(rct_gras) assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 1 and len(prd_gras) == 2: rct_gra, = rct_gras prds_gra = union_from_sequence(prd_gras) # ngb_keys_dct = atoms_neighbor_atom_keys(rct_gra) # Generate keys all bonds and 1/2 the forming bond frm1_keys = atom_keys(rct_gra) bnd_keys = bond_keys(rct_gra) frm2_keys = unsaturated_atom_keys(rct_gra) rct_symbs = atom_symbols(rct_gra) frm2_keys_o = frozenset(key for key in frm2_keys if rct_symbs[key] == 'O') rxns.extend(_identify(frm1_keys, frm2_keys_o, bnd_keys)) # OLD WAY. More IDs but more mistakes # To make the function general, try to ID reaction # with different types of keys for the attacking atom # (1) unsaturated atom sites # frm2_keys = unsaturated_atom_keys(rct_gra) # rxns.extend(_identify(frm1_keys, frm2_keys, bnd_keys)) # if not rxns: # # (2) remaining saturated atom sites # frm2_keys = atom_keys(rct_gra, excl_syms=('H',)) - frm2_keys # rxns.extend(_identify(frm1_keys, frm2_keys, bnd_keys)) # # if not rxns: # Ignoring H2 formation for now for speed # # # (3) H atoms # # frm1_keys = atom_keys(rct_gra, sym='H') # # rxns.extend(_identify(frm1_keys, frm2_keys, bnd_keys)) return ts_unique(rxns)
def eliminations(rct_gras, prd_gras): """ find eliminations consistent with these reactants and products :param rct_gras: reactant graphs (must have non-overlapping keys) :param prd_gras: product graphs (must have non-overlapping keys) Eliminations are identified by forming a bond between an attacking heavy atom and another atom not initially bonded to it, forming a ring. The bond adjacent to the attacked atom is then broken, along with a second bond in the ring, downstream of the attacking heavy atom, away from the attacked atom. """ _assert_is_valid_reagent_graph_list(rct_gras) _assert_is_valid_reagent_graph_list(prd_gras) rxns = [] if len(rct_gras) == 1 and len(prd_gras) == 2: rgra, = rct_gras pgra = union_from_sequence(prd_gras) rngb_keys = atoms_sorted_neighbor_atom_keys(rgra) frm1_keys = atom_keys(rgra, excl_syms=('H', )) frm2_keys = atom_keys(rgra) bnd_keys = bond_keys(rgra) frm_bnd_keys = [ (frm1_key, frm2_key) for frm1_key, frm2_key in itertools.product(frm1_keys, frm2_keys) if frm1_key != frm2_key and not frozenset({frm1_key, frm2_key}) in bnd_keys ] for frm1_key, frm2_key in frm_bnd_keys: # Bond the radical atom to the hydrogen atom rgra_ = add_bonds(rgra, [(frm2_key, frm1_key)]) # Get keys to the ring formed by this extra bond rng_keys = next((ks for ks in rings_atom_keys(rgra_) if frm2_key in ks and frm1_key in ks), None) if rng_keys is not None: for nfrm2_key in rngb_keys[frm2_key]: # Break the bond between the attacked atom and its neighbor rgra_ = remove_bonds(rgra_, [(frm2_key, nfrm2_key)]) # Sort the ring keys so that they start with the radical # atom and end with the hydrogen atom keys = cycle_ring_atom_key_to_front(rng_keys, frm1_key, end_key=frm2_key) # Break one ring bond at a time, starting from the rind, # and see what we get for brk_key1, brk_key2 in mit.windowed(keys[:-1], 2): gra = remove_bonds(rgra_, [(brk_key1, brk_key2)]) inv_dct = full_isomorphism(gra, pgra) if inv_dct: f_frm_bnd_key = (frm2_key, frm1_key) f_brk_bnd_key1 = (frm2_key, nfrm2_key) f_brk_bnd_key2 = (brk_key1, brk_key2) b_frm_bnd_key1 = (inv_dct[frm2_key], inv_dct[nfrm2_key]) b_frm_bnd_key2 = (inv_dct[brk_key1], inv_dct[brk_key2]) b_brk_bnd_key = (inv_dct[frm2_key], inv_dct[frm1_key]) forw_tsg = ts.graph( rgra, frm_bnd_keys=[f_frm_bnd_key], brk_bnd_keys=[f_brk_bnd_key1, f_brk_bnd_key2]) back_tsg = ts.graph( pgra, frm_bnd_keys=[b_frm_bnd_key1, b_frm_bnd_key2], brk_bnd_keys=[b_brk_bnd_key]) rcts_atm_keys = list(map(atom_keys, rct_gras)) prds_atm_keys = list(map(atom_keys, prd_gras)) if inv_dct[frm2_key] not in prds_atm_keys[1]: prds_atm_keys = list(reversed(prds_atm_keys)) # Create the reaction object rxns.append( Reaction( rxn_cls=par.ReactionClass.ELIMINATION, forw_tsg=forw_tsg, back_tsg=back_tsg, rcts_keys=rcts_atm_keys, prds_keys=prds_atm_keys, )) return tuple(rxns)
def test__reac__hydrogen_migration(): """ test graph.reac.hydrogen_migration """ # first test a radical site migration rct_cgr = ({ 0: ('C', 1, None), 1: ('C', 1, None), 2: ('C', 1, None), 3: ('C', 1, None), 4: ('C', 1, None), 5: ('O', 0, None) }, { frozenset({3, 4}): (1, None), frozenset({2, 3}): (1, None), frozenset({1, 2}): (1, None), frozenset({4, 5}): (1, None), frozenset({0, 1}): (1, None) }) prd_cgr = ({ 0: ('C', 2, None), 1: ('C', 1, None), 2: ('C', 1, None), 3: ('C', 1, None), 4: ('C', 0, None), 5: ('O', 0, None) }, { frozenset({3, 4}): (1, None), frozenset({2, 3}): (1, None), frozenset({1, 2}): (1, None), frozenset({4, 5}): (1, None), frozenset({0, 1}): (1, None) }) rct_cgr = graph.explicit(rct_cgr) prd_cgr = graph.explicit(prd_cgr) rct_cgrs = graph.connected_components(rct_cgr) prd_cgrs = graph.connected_components(prd_cgr) tras, rct_idxs, prd_idxs = graph.reac.hydrogen_migration( rct_cgrs, prd_cgrs) assert tras assert rct_idxs assert prd_idxs print("hydrogen migration") rct_cgr = graph.union_from_sequence(rct_cgrs) prd_cgr = graph.union_from_sequence(prd_cgrs) for tra in tras: print(tra) assert graph.backbone_isomorphic(graph.trans.apply(tra, rct_cgr), prd_cgr) tras, rct_idxs, prd_idxs = graph.reac.hydrogen_migration( prd_cgrs, rct_cgrs) assert tras assert rct_idxs assert prd_idxs # then test a tautomerization rct_cgr = ({ 0: ('C', 2, None), 1: ('C', 1, None), 2: ('O', 1, None) }, { frozenset({0, 1}): (1, None), frozenset({1, 2}): (1, None) }) prd_cgr = ({ 0: ('C', 3, None), 1: ('C', 1, None), 2: ('O', 0, None) }, { frozenset({0, 1}): (1, None), frozenset({1, 2}): (1, None) }) rct_cgr = graph.explicit(rct_cgr) prd_cgr = graph.explicit(prd_cgr) rct_cgrs = graph.connected_components(rct_cgr) prd_cgrs = graph.connected_components(prd_cgr) tras, rct_idxs, prd_idxs = graph.reac.hydrogen_migration( rct_cgrs, prd_cgrs) assert tras assert rct_idxs assert prd_idxs for tra in tras: print(tra) assert graph.backbone_isomorphic(graph.trans.apply(tra, rct_cgr), prd_cgr) tras, rct_idxs, prd_idxs = graph.reac.hydrogen_migration( prd_cgrs, rct_cgrs) assert tras assert rct_idxs assert prd_idxs
def test__reac__hydrogen_abstraction(): """ test graph.reac.hydrogen_abstraction """ rct_cgr = ({ 0: ('C', 3, None), 1: ('C', 3, None), 2: ('C', 1, None), 3: ('C', 2, None), 4: ('C', 1, None), 5: ('C', 2, None), 6: ('C', 2, None), 7: ('O', 1, None) }, { frozenset({4, 6}): (1, None), frozenset({0, 2}): (1, None), frozenset({2, 4}): (1, None), frozenset({5, 6}): (1, None), frozenset({3, 5}): (1, None), frozenset({1, 3}): (1, None) }) prd_cgr = ({ 0: ('C', 2, None), 1: ('C', 3, None), 2: ('C', 1, None), 3: ('C', 2, None), 4: ('C', 1, None), 5: ('C', 2, None), 6: ('C', 2, None), 7: ('O', 2, None) }, { frozenset({4, 6}): (1, None), frozenset({0, 2}): (1, None), frozenset({2, 4}): (1, None), frozenset({5, 6}): (1, None), frozenset({3, 5}): (1, None), frozenset({1, 3}): (1, None) }) rct_cgr = graph.explicit(rct_cgr) prd_cgr = graph.explicit(prd_cgr) rct_cgrs = graph.connected_components(rct_cgr) prd_cgrs = graph.connected_components(prd_cgr) tras, rct_idxs, prd_idxs = graph.reac.hydrogen_abstraction( rct_cgrs, prd_cgrs) assert tras assert rct_idxs assert prd_idxs print("hydrogen abstraction") rct_cgr = graph.union_from_sequence(rct_cgrs) print(rct_cgr) for tra in tras: print(tra) assert graph.backbone_isomorphic(graph.trans.apply(tra, rct_cgr), prd_cgr) tras, prd_idxs, rct_idxs = graph.reac.hydrogen_abstraction( prd_cgrs, rct_cgrs) assert tras assert rct_idxs assert prd_idxs for tra in tras: print(tra) assert graph.backbone_isomorphic(graph.trans.apply(tra, prd_cgr), rct_cgr)