Exemplo n.º 1
0
def test__equivalent_atoms():
    """ test graph.equivalent_atoms
    """
    # central carbon
    assert graph.equivalent_atoms(C4H10_GRA, 3) == {3}
    # central hydrogen
    assert graph.equivalent_atoms(C4H10_GRA, 13) == {13}
    # terminal carbons
    assert graph.equivalent_atoms(C4H10_GRA, 0) == {0, 1, 2}
    assert graph.equivalent_atoms(C4H10_GRA, 1) == {0, 1, 2}
    assert graph.equivalent_atoms(C4H10_GRA, 2) == {0, 1, 2}
    # terminal hydrogens
    assert graph.equivalent_atoms(C4H10_GRA,
                                  4) == {4, 5, 6, 7, 8, 9, 10, 11, 12}
    assert graph.equivalent_atoms(C4H10_GRA,
                                  5) == {4, 5, 6, 7, 8, 9, 10, 11, 12}
    assert graph.equivalent_atoms(C4H10_GRA,
                                  6) == {4, 5, 6, 7, 8, 9, 10, 11, 12}
    assert graph.equivalent_atoms(C4H10_GRA,
                                  11) == {4, 5, 6, 7, 8, 9, 10, 11, 12}
    assert graph.equivalent_atoms(C4H10_GRA,
                                  12) == {4, 5, 6, 7, 8, 9, 10, 11, 12}
Exemplo n.º 2
0
def hydrogen_migrations(rct_gras, prd_gras):
    """ find hydrogen migrations 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 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)

    rxns = []

    if len(rct_gras) == 1 and len(prd_gras) == 1:
        rct_gra, = rct_gras
        prd_gra, = prd_gras

        # Find keys for reactant graph
        rct_h_key = max(atom_keys(rct_gra)) + 1
        rct_rad_keys = unsaturated_atom_keys(rct_gra)

        # Find keys for product graph
        prd_h_key = max(atom_keys(prd_gra)) + 1
        prd_rad_keys = unsaturated_atom_keys(prd_gra)

        for rct_rad_key, prd_rad_key in (itertools.product(
                rct_rad_keys, prd_rad_keys)):
            # Add hydrogens to each radical site and see if the result matches
            rct_h_gra = add_bonded_atom(rct_gra,
                                        'H',
                                        rct_rad_key,
                                        bnd_atm_key=rct_h_key)
            prd_h_gra = add_bonded_atom(prd_gra,
                                        'H',
                                        prd_rad_key,
                                        bnd_atm_key=prd_h_key)

            iso_dct = isomorphism(rct_h_gra, prd_h_gra)
            if iso_dct:
                inv_dct = dict(map(reversed, iso_dct.items()))

                rct_don_key = inv_dct[prd_rad_key]
                prd_don_key = iso_dct[rct_rad_key]

                # Check equivalent donor atoms for other possible TSs
                rct_don_keys = equivalent_atoms(rct_h_gra, rct_don_key)
                prd_don_keys = equivalent_atoms(prd_h_gra, prd_don_key)

                for rct_don_key, prd_don_key in (itertools.product(
                        rct_don_keys, prd_don_keys)):
                    rct_hyd_key = atom_neighbor_atom_key(rct_gra,
                                                         rct_don_key,
                                                         symbs_first=('H', ),
                                                         symbs_last=())
                    prd_hyd_key = atom_neighbor_atom_key(prd_gra,
                                                         prd_don_key,
                                                         symbs_first=('H', ),
                                                         symbs_last=())

                    forw_tsg = ts.graph(rct_gra,
                                        frm_bnd_keys=[(rct_rad_key,
                                                       rct_hyd_key)],
                                        brk_bnd_keys=[(rct_don_key,
                                                       rct_hyd_key)])

                    back_tsg = ts.graph(prd_gra,
                                        frm_bnd_keys=[(prd_rad_key,
                                                       prd_hyd_key)],
                                        brk_bnd_keys=[(prd_don_key,
                                                       prd_hyd_key)])

                    if isomorphism(forw_tsg, ts.reverse(back_tsg)):
                        rxns.append(
                            Reaction(
                                rxn_cls=par.ReactionClass.HYDROGEN_MIGRATION,
                                forw_tsg=forw_tsg,
                                back_tsg=back_tsg,
                                rcts_keys=[atom_keys(rct_gra)],
                                prds_keys=[atom_keys(prd_gra)],
                            ))

    return ts_unique(rxns)