def test__trans__is_stereo_compatible():
""" test graph.trans.is_stereo_compatible
"""
cgr1 = ({
0: ('C', 1, None),
1: ('C', 1, None),
2: ('C', 1, None),
3: ('C', 1, None),
4: ('F', 0, None),
5: ('F', 0, None),
6: ('O', 1, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({0, 2}): (1, None),
frozenset({2, 4}): (1, None),
frozenset({3, 5}): (1, None),
frozenset({1, 3}): (1, None)
})
cgr2 = ({
0: ('C', 1, None),
1: ('C', 1, None),
2: ('C', 1, None),
3: ('C', 1, None),
4: ('F', 0, None),
5: ('F', 0, None),
6: ('O', 1, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({0, 2}): (1, None),
frozenset({3, 6}): (1, None),
frozenset({2, 4}): (1, None),
frozenset({3, 5}): (1, None),
frozenset({1, 3}): (1, None)
})
cgr1 = graph.explicit(cgr1)
cgr2 = graph.explicit(cgr2)
ich1 = graph.inchi(cgr1)
ich2 = graph.inchi(cgr2)
smi1 = automol.inchi.smiles(ich1)
smi2 = automol.inchi.smiles(ich2)
print(smi1)
print(smi2)
cgr1s = graph.connected_components(cgr1)
cgr2s = graph.connected_components(cgr2)
tras, _, _ = graph.reac.addition(cgr1s, cgr2s)
for tra in tras:
assert graph.backbone_isomorphic(graph.trans.apply(tra, cgr1), cgr2)
sgr1 = graph.stereomers(cgr1)[0]
print(sgr1)
for sgr2 in graph.stereomers(cgr2):
print(sgr2)
print(graph.trans.is_stereo_compatible(tra, sgr1, sgr2))
def test__reac__beta_scission():
""" test graph.reac.beta_scission
"""
rct_cgr = ({
0: ('C', 1, None),
1: ('C', 1, None),
2: ('C', 1, None),
3: ('C', 1, None),
4: ('F', 0, None),
5: ('F', 0, None),
6: ('O', 1, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({0, 2}): (1, None),
frozenset({3, 6}): (1, None),
frozenset({2, 4}): (1, None),
frozenset({3, 5}): (1, None),
frozenset({1, 3}): (1, None)
})
prd_cgr = ({
0: ('C', 1, None),
1: ('C', 1, None),
2: ('C', 1, None),
3: ('C', 1, None),
4: ('F', 0, None),
5: ('F', 0, None),
6: ('O', 1, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({0, 2}): (1, None),
frozenset({2, 4}): (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.beta_scission(rct_cgrs, prd_cgrs)
assert tras
assert rct_idxs
assert prd_idxs
print("beta scission")
for tra in tras:
print(tra)
assert graph.backbone_isomorphic(graph.trans.apply(tra, rct_cgr),
prd_cgr)
def homolytic_scissions(rct_gras, viable_only=False):
""" find all possible homolytic scission reactions for these reactants
:param rct_gras: graphs for the reactants, without stereo and without
overlapping keys
:param viable_only: Filter out reactions with non-viable products?
:type viable_only: bool
:returns: a list of Reaction objects
:rtype: tuple[Reaction]
Homolytic scissions are enumerated by identifying all pure single bonds
(single bonds with no resonances), and looping over the results of
breaking each of them. If this gives rise to two distinct
fragments, the reaction is added to the list.
"""
assert_is_valid_reagent_graph_list(rct_gras)
rxns = []
if len(rct_gras) == 1:
rct_gra, = rct_gras
# Identify all pure single bonds involving radical site neighbor
avg_bnd_ord_dct = resonance_avg_bond_orders(rct_gra)
brk_bnd_keys = dict_.keys_by_value(avg_bnd_ord_dct, lambda x: x == 1)
for brk_bnd_key in brk_bnd_keys:
prds_gra = remove_bonds(rct_gra, [brk_bnd_key])
prd_gras = connected_components(prds_gra)
if len(prd_gras) == 2:
prd_gras = sort_reagents(prd_gras)
forw_tsg = ts.graph(rct_gra,
frm_bnd_keys=[],
brk_bnd_keys=[brk_bnd_key])
back_tsg = ts.graph(prds_gra,
frm_bnd_keys=[brk_bnd_key],
brk_bnd_keys=[])
# Create the reaction object
rxns.append(
Reaction(
rxn_cls=par.ReactionClass.Typ.HOMOLYT_SCISSION,
forw_tsg=forw_tsg,
back_tsg=back_tsg,
rcts_keys=list(map(atom_keys, rct_gras)),
prds_keys=list(map(atom_keys, prd_gras)),
))
# Dummy line to fix linting checks
assert viable_only or not viable_only
# filter removes all reactions
# if viable_only:
# rxns = filter_viable_reactions(rxns)
return ts_unique(rxns)
def test__connected_components():
""" test graph.connected_components
"""
gra1 = C3H3_CGR
gra2 = C2_CGR
gra1_natms = automol.formula.atom_count(graph.formula(C3H3_CGR))
gra2 = graph.transform_keys(gra2, lambda x: x + gra1_natms)
gra = graph.union(gra1, gra2)
cmp_gras = graph.connected_components(gra)
assert cmp_gras in [(gra1, gra2), (gra2, gra1)]
def test__reac__substitution():
""" test graph.reac.substitution
"""
# CH3OOH + CH3 => CH3OCH3 + OH
rct_cgr = ({
0: ('C', 3, None),
1: ('O', 1, None),
2: ('O', 0, None),
3: ('C', 3, None)
}, {
frozenset({0, 2}): (1, None),
frozenset({1, 2}): (1, None)
})
prd_cgr = ({
0: ('C', 3, None),
1: ('C', 3, None),
2: ('O', 0, None),
3: ('O', 1, None)
}, {
frozenset({0, 2}): (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.substitution(rct_cgrs, prd_cgrs)
assert tras
assert rct_idxs
assert prd_idxs
print("substitution")
for tra in tras:
print(tra)
assert graph.backbone_isomorphic(graph.trans.apply(tra, rct_cgr),
prd_cgr)
def insertions(rct_gras, viable_only=True):
""" find all possible insertion reactions for these reactants
:param rct_gras: graphs for the reactants, without stereo and without
overlapping keys
:param viable_only: Filter out reactions with non-viable products?
:type viable_only: bool
:returns: a list of Reaction objects
:rtype: tuple[Reaction]
Insertions are enumerated by looping over carbenes and multiple bonds on
one reactant, which serve as a source of potential "attacking" atoms for
the insertion, and looping over single bonds that could be inserted into on
the other reactant. For lack of a better term, we can call these "donating
atoms". The insertion then looks as follows:
A1=A2 A1
. . or .
. . . .
D1-D2 D1-D2
where two bonds are formed between the A and D atoms and the bond between
the two D atoms is broken.
"""
assert_is_valid_reagent_graph_list(rct_gras)
rxns = []
if len(rct_gras) == 2:
for rct1_gra, rct2_gra in itertools.permutations(rct_gras):
rcts_gra = union(rct1_gra, rct2_gra)
# Carbenes on R1 are potential attacking atoms
atm_keys = radical_atom_keys(rct1_gra, min_valence=2.)
atm_keys = tuple(atm_keys)
# So are atoms on either side of a multiple bond
bnd_keys = dict_.keys_by_value(resonance_avg_bond_orders(rct1_gra),
lambda x: x > 1.)
bnd_keys = bond_equivalence_class_reps(rct1_gra, bnd_keys)
# Use this to form a list of attacking atom pairs for R1
att_pairs = list(map(tuple, map(sorted, bnd_keys)))
att_pairs += list(zip(atm_keys, atm_keys))
# As donor pairs, consider single bonds on R2
don_bnd_keys = dict_.keys_by_value(
resonance_avg_bond_orders(rct2_gra), lambda x: x == 1.)
don_bnd_keys = bond_equivalence_class_reps(rct2_gra, don_bnd_keys)
don_pairs = list(map(tuple, map(sorted, don_bnd_keys)))
for att_pair, don_pair in itertools.product(att_pairs, don_pairs):
if not (are_equivalent_atoms(rct1_gra, *att_pair)
or are_equivalent_atoms(rct2_gra, *don_pair)):
don_pairs_ = list(itertools.permutations(don_pair))
else:
don_pairs_ = [don_pair]
for don_pair_ in don_pairs_:
att1_key, att2_key = att_pair
don1_key, don2_key = don_pair_
prds_gra = rcts_gra
prds_gra = add_bonds(prds_gra, [(att1_key, don1_key),
(att2_key, don2_key)])
prds_gra = remove_bonds(prds_gra, [(don1_key, don2_key)])
prd_gras = connected_components(prds_gra)
if len(prd_gras) == 1:
forw_tsg = ts.graph(rcts_gra,
frm_bnd_keys=[(att1_key, don1_key),
(att2_key, don2_key)
],
brk_bnd_keys=[(don1_key, don2_key)
])
back_tsg = ts.graph(prds_gra,
frm_bnd_keys=[(don1_key, don2_key)
],
brk_bnd_keys=[(att1_key, don1_key),
(att2_key, don2_key)
])
# Create the reaction object
rcts_keys = list(map(atom_keys, [rct1_gra, rct2_gra]))
prds_keys = list(map(atom_keys, prd_gras))
rxns.append(
Reaction(
rxn_cls=par.ReactionClass.Typ.INSERTION,
forw_tsg=forw_tsg,
back_tsg=back_tsg,
rcts_keys=rcts_keys,
prds_keys=prds_keys,
))
if viable_only:
rxns = filter_viable_reactions(rxns)
return ts_unique(rxns)
def eliminations(rct_gras, viable_only=True):
""" find all possible elimination reactions for these reactants
:param rct_gras: graphs for the reactants, without stereo and without
overlapping keys
:param viable_only: Filter out reactions with non-viable products?
:type viable_only: bool
:returns: a list of Reaction objects
:rtype: tuple[Reaction]
Eliminations are enumerated 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 from the attacking heavy atom, away from the attacked
atom.
"""
assert_is_valid_reagent_graph_list(rct_gras)
rxns = []
if len(rct_gras) == 1:
rct_gra, = rct_gras
ngb_keys_dct = atoms_neighbor_atom_keys(rct_gra)
# frm1_keys = atom_keys(rct_gra, excl_syms=('H',))
frm1_keys = unsaturated_atom_keys(rct_gra)
rct_symbs = atom_symbols(rct_gra)
frm1_keys_o = frozenset(key for key in frm1_keys
if rct_symbs[key] == 'O')
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_o, 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
prds_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(prds_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
prds_gra = remove_bonds(prds_gra, [(frm1_key, frm1_ngb_key)])
prds_gra = remove_bonds(prds_gra, [(frm2_key, frm2_ngb_key)])
prd_gras = connected_components(prds_gra)
if len(prd_gras) == 2:
forw_tsg = ts.graph(rct_gra,
frm_bnd_keys=[(frm1_key, frm2_key)],
brk_bnd_keys=[(frm1_key, frm1_ngb_key),
(frm2_key, frm2_ngb_key)
])
back_tsg = ts.graph(prds_gra,
frm_bnd_keys=[(frm1_key, frm1_ngb_key),
(frm2_key, frm2_ngb_key)
],
brk_bnd_keys=[(frm1_key, frm2_key)])
rcts_atm_keys = list(map(atom_keys, rct_gras))
prds_atm_keys = list(map(atom_keys, prd_gras))
if 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.Typ.ELIMINATION,
forw_tsg=forw_tsg,
back_tsg=back_tsg,
rcts_keys=rcts_atm_keys,
prds_keys=prds_atm_keys,
))
if viable_only:
rxns = filter_viable_reactions(rxns)
return ts_unique(rxns)
def ring_forming_scissions(rct_gras, viable_only=True):
""" find all possible ring-forming scission reactions for these reactants
:param rct_gras: graphs for the reactants, without stereo and without
overlapping keys
:param viable_only: Filter out reactions with non-viable products?
:type viable_only: bool
:returns: a list of Reaction objects
:rtype: tuple[Reaction]
Right now it takes the lazy, chemically specific approach of finding
C-O-O-H groups and forming a bond between the O of the C-O bond
and radical sites of the species, while breaking the O-O bond.
"""
assert_is_valid_reagent_graph_list(rct_gras)
rxns = []
if len(rct_gras) == 1:
rct_gra, = rct_gras
# Identify the radical sites and COOH groups
rad_keys = radical_atom_keys(rct_gra)
cooh_grps = hydroperoxy_groups(rct_gra)
# Get the bnd keys for filtering
bnd_keys = bond_keys(rct_gra)
# Set the forming and breaking bonds by looping over COOH groups
rxn_bnd_keys = ()
for cooh_grp in cooh_grps:
brk_bnd_key = frozenset(cooh_grp[1:3])
for rad_key in rad_keys:
frm_bnd_key = frozenset({rad_key, cooh_grp[1]})
# Only includ frm bnd if it does not exist
# e.g., CC[C]OO already has frm bnd -> no rxn possible
if frm_bnd_key not in bnd_keys:
rxn_bnd_keys += ((frm_bnd_key, brk_bnd_key), )
# Form reactions with all combinations of frm and brk bnds
for frm_bnd_key, brk_bnd_key in rxn_bnd_keys:
prds_gra = rct_gra
prds_gra = add_bonds(prds_gra, [frm_bnd_key])
prds_gra = remove_bonds(prds_gra, [brk_bnd_key])
prd_gras = connected_components(prds_gra)
if len(prd_gras) == 2:
prd_gras = sort_reagents(prd_gras)
forw_tsg = ts.graph(rct_gra,
frm_bnd_keys=[frm_bnd_key],
brk_bnd_keys=[brk_bnd_key])
back_tsg = ts.graph(prds_gra,
frm_bnd_keys=[brk_bnd_key],
brk_bnd_keys=[frm_bnd_key])
# Create the reaction object
rxns.append(
Reaction(
rxn_cls=par.ReactionClass.Typ.RING_FORM_SCISSION,
forw_tsg=forw_tsg,
back_tsg=back_tsg,
rcts_keys=list(map(atom_keys, rct_gras)),
prds_keys=list(map(atom_keys, prd_gras)),
))
if viable_only:
rxns = filter_viable_reactions(rxns)
return ts_unique(rxns)
def beta_scissions(rct_gras, viable_only=True):
""" find all possible beta scission reactions for these reactants
:param rct_gras: graphs for the reactants, without stereo and without
overlapping keys
:param viable_only: Filter out reactions with non-viable products?
:type viable_only: bool
:returns: a list of Reaction objects
:rtype: tuple[Reaction]
FIX DESCRIPTION:
Beta scissions are enumerated by identifying all pure single bonds (single
bonds with no resonances), and looping over the results of breaking each of
them. If this gives rise to two distinct fragments, the reaction is added
to the list.
"""
assert_is_valid_reagent_graph_list(rct_gras)
rxns = []
if len(rct_gras) == 1:
rct_gra, = rct_gras
# Identify all atom keys that neighbor radical sites
rad_neighs = frozenset({})
neigh_dct = atoms_neighbor_atom_keys(rct_gra)
for rad_key in radical_atom_keys(rct_gra):
rad_neighs = rad_neighs | neigh_dct[rad_key]
# Identify all pure single bonds involving radical site neighbor
avg_bnd_ord_dct = resonance_avg_bond_orders(rct_gra)
brk_bnd_keys = dict_.keys_by_value(avg_bnd_ord_dct, lambda x: x == 1)
beta_bnd_keys = ()
for brk_bnd_key in brk_bnd_keys:
if brk_bnd_key & rad_neighs:
beta_bnd_keys += (brk_bnd_key, )
for brk_bnd_key in beta_bnd_keys:
prds_gra = remove_bonds(rct_gra, [brk_bnd_key])
prd_gras = connected_components(prds_gra)
if len(prd_gras) == 2:
prd_gras = sort_reagents(prd_gras)
forw_tsg = ts.graph(rct_gra,
frm_bnd_keys=[],
brk_bnd_keys=[brk_bnd_key])
back_tsg = ts.graph(prds_gra,
frm_bnd_keys=[brk_bnd_key],
brk_bnd_keys=[])
# Create the reaction object
rxns.append(
Reaction(
rxn_cls=par.ReactionClass.Typ.BETA_SCISSION,
forw_tsg=forw_tsg,
back_tsg=back_tsg,
rcts_keys=list(map(atom_keys, rct_gras)),
prds_keys=list(map(atom_keys, prd_gras)),
))
if viable_only:
rxns = filter_viable_reactions(rxns)
return ts_unique(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__insertion():
""" test graph.reac.insertion
"""
# CH2CH2 + HOO => CH3CH3OO
rct_cgr = ({
0: ('C', 2, None),
1: ('C', 2, None),
2: ('O', 1, None),
3: ('O', 0, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({2, 3}): (1, None)
})
prd_cgr = ({
0: ('C', 3, None),
1: ('C', 2, None),
2: ('O', 0, None),
3: ('O', 0, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({1, 3}): (1, None),
frozenset({2, 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.insertion(rct_cgrs, prd_cgrs)
assert tras
assert rct_idxs
assert prd_idxs
print("insertion")
for tra in tras:
print(tra)
assert graph.backbone_isomorphic(graph.trans.apply(tra, rct_cgr),
prd_cgr)
# CH3CH3 + :C=O => CH3C(=O)CH3 (CO insertion)
rct_cgr = ({
0: ('C', 3, None),
1: ('C', 3, None),
2: ('C', 0, None),
3: ('O', 0, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({2, 3}): (1, None)
})
prd_cgr = ({
0: ('C', 3, None),
1: ('C', 3, None),
2: ('C', 0, None),
3: ('O', 0, None)
}, {
frozenset({0, 2}): (1, None),
frozenset({2, 3}): (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.insertion(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)
# CH3CH3 + O=C=O => CH3C(=O)OCH3 (CO2 insertion)
rct_cgr = ({
0: ('C', 3, None),
1: ('C', 3, None),
2: ('C', 0, None),
3: ('O', 0, None),
4: ('O', 0, None)
}, {
frozenset({0, 1}): (1, None),
frozenset({2, 3}): (1, None),
frozenset({2, 4}): (1, None)
})
prd_cgr = ({
0: ('C', 3, None),
1: ('C', 3, None),
2: ('C', 0, None),
3: ('O', 0, None),
4: ('O', 0, None)
}, {
frozenset({0, 2}): (1, None),
frozenset({1, 4}): (1, None),
frozenset({2, 3}): (1, None),
frozenset({2, 4}): (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.insertion(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)
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)