def full_subgraph_isomorphism(gra1, gra2):
""" gra2 is fully isomorphic to a subgraph of gra1
"""
assert gra1 == explicit(gra1) and gra2 == explicit(gra2)
nxg1 = _networkx.from_graph(gra1)
nxg2 = _networkx.from_graph(gra2)
iso_dct = _networkx.subgraph_isomorphism(nxg1, nxg2)
return iso_dct
def full_isomorphism(gra1, gra2, igraph=False):
""" full graph isomorphism
"""
assert gra1 == explicit(gra1) and gra2 == explicit(gra2)
if igraph:
igr1 = _igraph.from_graph(gra1)
igr2 = _igraph.from_graph(gra2)
iso_dcts = _igraph.isomorphisms(igr1, igr2)
iso_dct = iso_dcts[0] if iso_dcts else None
else:
nxg1 = _networkx.from_graph(gra1)
nxg2 = _networkx.from_graph(gra2)
iso_dct = _networkx.isomorphism(nxg1, nxg2)
return iso_dct
def stereogenic_atom_keys(gra, assigned=False):
""" Find stereogenic atoms in this graph.
If the `assigned` flag is set to `False`, only unassigned stereogenic
atoms will be detected.
:param gra: the graph
:param assigned: Include atoms that already have stereo assignments?
:param assigned: bool
:returns: the stereogenic atom keys
:rtype: frozenset
"""
gra = without_bond_orders(gra)
gra = explicit(gra) # for simplicity, add the explicit hydrogens back in
atm_keys = dict_.keys_by_value(atom_bond_valences(gra), lambda x: x == 4)
if not assigned:
# Remove assigned stereo keys
atm_keys -= atom_stereo_keys(gra)
atm_ngb_keys_dct = atoms_neighbor_atom_keys(gra)
def _is_stereogenic(atm_key):
atm_ngb_keys = list(atm_ngb_keys_dct[atm_key])
pri_vecs = [
stereo_priority_vector(gra, atm_key, atm_ngb_key)
for atm_ngb_key in atm_ngb_keys
]
ret = not any(pv1 == pv2
for pv1, pv2 in itertools.combinations(pri_vecs, r=2))
return ret
ste_gen_atm_keys = frozenset(filter(_is_stereogenic, atm_keys))
return ste_gen_atm_keys
def _set_atom_stereo_from_geometry(gra, atm_keys, geo, geo_idx_dct):
assert gra == explicit(gra)
atm_pars = [
_atom_stereo_parity_from_geometry(gra, atm_key, geo, geo_idx_dct)
for atm_key in atm_keys]
gra = set_atom_stereo_parities(gra, dict(zip(atm_keys, atm_pars)))
return gra
def _set_bond_stereo_from_geometry(gra, bnd_keys, geo, geo_idx_dct):
assert gra == explicit(gra)
bnd_pars = [
_bond_stereo_parity_from_geometry(gra, bnd_key, geo, geo_idx_dct)
for bnd_key in bnd_keys]
gra = set_bond_stereo_parities(gra, dict(zip(bnd_keys, bnd_pars)))
return gra
def _gen3(ich):
if has_stereo(ich):
raise ValueError
gra = graph(ich, stereo=False)
gra = explicit(gra)
geo = automol.graph.embed.geometry(gra)
return geo
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 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 formula(gra):
""" Generate a stoichiometric formula dictionary from a molecular graph.
:param gra: molecular graph
:type gra: automol graph data structure
:type: dict[str: int]
"""
gra = explicit(gra)
syms = atom_symbols(gra).values()
fml = _util.formula(syms)
return fml
def stereogenic_bond_keys(gra, assigned=False):
""" Find stereogenic bonds in this graph.
If the `assigned` flag is set to `False`, only unassigned stereogenic
bonds will be detected.
:param gra: the graph
:param assigned: Include bonds that already have stereo assignments?
:param assigned: bool
:returns: the stereogenic bond keys
:rtype: frozenset
"""
gra = without_bond_orders(gra)
gra = explicit(gra) # for simplicity, add the explicit hydrogens back in
# get candidates: planar bonds
bnd_keys = sp2_bond_keys(gra)
if not assigned:
# remove bonds that already have stereo assignments
bnd_keys -= bond_stereo_keys(gra)
bnd_keys -= functools.reduce( # remove double bonds in small rings
frozenset.union, filter(lambda x: len(x) < 8, rings_bond_keys(gra)),
frozenset())
atm_ngb_keys_dct = atoms_neighbor_atom_keys(gra)
def _is_stereogenic(bnd_key):
atm1_key, atm2_key = bnd_key
def _is_symmetric_on_bond(atm_key, atm_ngb_key):
atm_ngb_keys = list(atm_ngb_keys_dct[atm_key] - {atm_ngb_key})
if not atm_ngb_keys: # C=:O:
ret = True
elif len(atm_ngb_keys) == 1: # C=N:-X
ret = False
else:
assert len(atm_ngb_keys) == 2 # C=C(-X)-Y
ret = (stereo_priority_vector(
gra, atm_key, atm_ngb_keys[0]) == stereo_priority_vector(
gra, atm_key, atm_ngb_keys[1]))
return ret
return not (_is_symmetric_on_bond(atm1_key, atm2_key)
or _is_symmetric_on_bond(atm2_key, atm1_key))
ste_gen_bnd_keys = frozenset(filter(_is_stereogenic, bnd_keys))
return ste_gen_bnd_keys
def geometry(gra, keys=None, ntries=5, max_dist_err=0.2):
""" sample a qualitatively-correct stereo geometry
:param gra: the graph, which may or may not have stereo
:param keys: graph keys, in the order in which they should appear in the
geometry
:param ntries: number of tries for finding a valid geometry
:param max_dist_err: maximum distance error convergence threshold
Qualitatively-correct means it has the right connectivity and the right
stero parities, but its bond lengths and bond angles may not be
quantitatively realistic
"""
assert gra == explicit(gra), (
"Graph => geometry conversion requires explicit hydrogens!\n"
"Use automol.graph.explicit() to convert to an explicit graph.")
# 0. Get keys and symbols
symb_dct = atom_symbols(gra)
keys = sorted(atom_keys(gra)) if keys is None else keys
symbs = tuple(map(symb_dct.__getitem__, keys))
# 1. Generate bounds matrices
lmat, umat = distance_bounds_matrices(gra, keys)
chi_dct = chirality_constraint_bounds(gra, keys)
pla_dct = planarity_constraint_bounds(gra, keys)
conv1_ = qualitative_convergence_checker_(gra, keys)
conv2_ = embed.distance_convergence_checker_(lmat, umat, max_dist_err)
def conv_(xmat, err, grad):
return conv1_(xmat, err, grad) & conv2_(xmat, err, grad)
# 2. Generate coordinates with correct stereo, trying a few times
for _ in range(ntries):
xmat = embed.sample_raw_distance_coordinates(lmat, umat, dim4=True)
xmat, conv = embed.cleaned_up_coordinates(
xmat, lmat, umat, pla_dct=pla_dct, chi_dct=chi_dct, conv_=conv_)
if conv:
break
if not conv:
raise error.FailedGeometryGenerationError
# 3. Generate a geometry data structure from the coordinates
xyzs = xmat[:, :3]
geo = _create.geom.from_data(symbs, xyzs, angstrom=True)
return geo
def to_index_based_stereo(sgr):
""" Convert a graph to index-based stereo assignments, where parities are
defined relative to the ordering of indices rather than the absolute stereo
priority.
:param sgr: a graph with absolute stereo assignments
:returns: a graph with index-based stereo assignments
"""
assert sgr == explicit(sgr), ("Not an explicit graph:\n{}".format(
string(sgr, one_indexed=False)))
abs_srt_keys_dct = atoms_stereo_sorted_neighbor_atom_keys(sgr)
atm_ste_keys = atom_stereo_keys(sgr)
bnd_ste_keys = bond_stereo_keys(sgr)
abs_atm_ste_par_dct = atom_stereo_parities(sgr)
abs_bnd_ste_par_dct = bond_stereo_parities(sgr)
idx_atm_ste_par_dct = {}
idx_bnd_ste_par_dct = {}
# Determine index-based stereo assignments for atoms
for atm_key in atm_ste_keys:
abs_srt_keys = abs_srt_keys_dct[atm_key]
idx_srt_keys = sorted(abs_srt_keys)
if automol.util.is_even_permutation(idx_srt_keys, abs_srt_keys):
idx_atm_ste_par_dct[atm_key] = abs_atm_ste_par_dct[atm_key]
else:
idx_atm_ste_par_dct[atm_key] = not abs_atm_ste_par_dct[atm_key]
# Determine index-based stereo assignments for bonds
for bnd_key in bnd_ste_keys:
atm1_key, atm2_key = sorted(bnd_key)
atm1_abs_srt_keys = abs_srt_keys_dct[atm1_key]
atm2_abs_srt_keys = abs_srt_keys_dct[atm2_key]
atm1_idx_srt_keys = sorted(atm1_abs_srt_keys)
atm2_idx_srt_keys = sorted(atm2_abs_srt_keys)
if not ((atm1_idx_srt_keys[0] != atm1_abs_srt_keys[0]) ^
(atm2_idx_srt_keys[0] != atm2_abs_srt_keys[0])):
idx_bnd_ste_par_dct[bnd_key] = abs_bnd_ste_par_dct[bnd_key]
else:
idx_bnd_ste_par_dct[bnd_key] = not abs_bnd_ste_par_dct[bnd_key]
sgr = set_atom_stereo_parities(sgr, idx_atm_ste_par_dct)
sgr = set_bond_stereo_parities(sgr, idx_bnd_ste_par_dct)
return sgr
def geometry(gra):
""" Convert a molecular graph to a molecular geometry.
:param gra: molecular graph
:type gra: automol graph data structure
:rtype: automol molecular geometry data structure
"""
symbs = atom_symbols(gra)
if len(symbs) != 1:
gra = explicit(gra)
geo = embed_geometry(gra)
else:
symb = list(symbs.values())[0]
# symb = list(symbs.keys())[0]
geo = ((symb, (0.00, 0.00, 0.00)), )
return geo
def _stereo_corrected_geometry(sgr, geo, geo_idx_dct):
""" correct the stereo parities of a geometry
(works iterately to handle cases of higher-order stereo)
"""
assert sgr == explicit(sgr)
gra = without_stereo_parities(sgr)
if has_stereo(sgr):
full_atm_ste_par_dct = atom_stereo_parities(sgr)
full_bnd_ste_par_dct = bond_stereo_parities(sgr)
atm_keys = set()
bnd_keys = set()
last_gra = None
while last_gra != gra:
last_gra = gra
atm_keys.update(stereogenic_atom_keys(gra))
bnd_keys.update(stereogenic_bond_keys(gra))
atm_ste_par_dct = {
atm_key: full_atm_ste_par_dct[atm_key]
for atm_key in atm_keys
}
bnd_ste_par_dct = {
bnd_key: full_bnd_ste_par_dct[bnd_key]
for bnd_key in bnd_keys
}
geo, gra = _atom_stereo_corrected_geometry(gra, atm_ste_par_dct,
geo, geo_idx_dct)
geo, gra = _bond_stereo_corrected_geometry(gra, bnd_ste_par_dct,
geo, geo_idx_dct)
return geo
def inchi(gra, stereo=True):
""" Generate an InChI string from a molecular graph.
:param gra: molecular graph
:type gra: automol graph data structure
:param stereo: parameter to include stereochemistry information
:type stereo: bool
:rtype: str
"""
ich = object_to_hardcoded_inchi_by_key('graph', gra, comp=_compare)
if ich is None:
if not stereo or not has_stereo(gra):
ich, _ = inchi_with_sort_from_geometry(gra)
ich = standard_form(ich, stereo=stereo)
else:
gra = explicit(gra)
geo, geo_idx_dct = fake_stereo_geometry(gra)
ich, _ = inchi_with_sort_from_geometry(gra,
geo=geo,
geo_idx_dct=geo_idx_dct)
return ich
def electron_count(gra, charge=0):
""" the number of electrons in the molecule
"""
atm_symb_dct = atom_symbols(explicit(gra))
nelec = sum(map(ptab.to_number, atm_symb_dct.values())) - charge
return nelec
def from_index_based_stereo(sgr):
""" Convert a graph from index-based stereo assignments back to absolute
stereo assignments, where parities are independent of atom ordering.
:param sgr: a graph with index-based stereo assignments
:returns: a graph with absolute stereo assignments
"""
assert sgr == explicit(sgr), ("Not an explicit graph:\n{}".format(
string(sgr, one_indexed=False)))
gra = without_stereo_parities(sgr)
if has_stereo(sgr):
atm_keys_pool = atom_stereo_keys(sgr)
bnd_keys_pool = bond_stereo_keys(sgr)
idx_atm_ste_par_dct = atom_stereo_parities(sgr)
idx_bnd_ste_par_dct = bond_stereo_parities(sgr)
atm_ngb_keys_dct = atoms_neighbor_atom_keys(sgr)
atm_keys = set()
bnd_keys = set()
last_gra = None
# Do the assignments iteratively to handle higher-order stereo
while last_gra != gra:
last_gra = gra
abs_atm_ste_par_dct = {}
abs_bnd_ste_par_dct = {}
atm_keys.update(stereogenic_atom_keys(gra) & atm_keys_pool)
bnd_keys.update(stereogenic_bond_keys(gra) & bnd_keys_pool)
# Determine absolute stereo assignments for atoms
for atm_key in atm_keys:
abs_srt_keys = atom_stereo_sorted_neighbor_atom_keys(
gra, atm_key, atm_ngb_keys_dct[atm_key])
idx_srt_keys = sorted(abs_srt_keys)
if automol.util.is_even_permutation(idx_srt_keys,
abs_srt_keys):
abs_atm_ste_par_dct[atm_key] = (
idx_atm_ste_par_dct[atm_key])
else:
abs_atm_ste_par_dct[atm_key] = (
not idx_atm_ste_par_dct[atm_key])
# Determine absolute stereo assignments for bonds
for bnd_key in bnd_keys:
atm1_key, atm2_key = sorted(bnd_key)
atm1_abs_srt_keys = atom_stereo_sorted_neighbor_atom_keys(
gra, atm1_key, atm_ngb_keys_dct[atm1_key] - bnd_key)
atm2_abs_srt_keys = atom_stereo_sorted_neighbor_atom_keys(
gra, atm2_key, atm_ngb_keys_dct[atm2_key] - bnd_key)
atm1_idx_srt_keys = sorted(atm1_abs_srt_keys)
atm2_idx_srt_keys = sorted(atm2_abs_srt_keys)
if not ((atm1_idx_srt_keys[0] != atm1_abs_srt_keys[0]) ^
(atm2_idx_srt_keys[0] != atm2_abs_srt_keys[0])):
abs_bnd_ste_par_dct[bnd_key] = (
idx_bnd_ste_par_dct[bnd_key])
else:
abs_bnd_ste_par_dct[bnd_key] = (
not idx_bnd_ste_par_dct[bnd_key])
gra = set_atom_stereo_parities(gra, abs_atm_ste_par_dct)
gra = set_bond_stereo_parities(gra, abs_bnd_ste_par_dct)
atm_ste_keys = atom_stereo_keys(gra)
bnd_ste_keys = bond_stereo_keys(gra)
assert atm_ste_keys == atm_keys_pool, (
"Index-based to absolute stereo conversion failed:\n"
"{} != {}".format(str(atm_ste_keys), str(atm_keys_pool)))
assert bnd_ste_keys == bnd_keys_pool, (
"Index-based to absolute stereo conversion failed:\n"
"{} != {}".format(str(bnd_ste_keys), str(bnd_keys_pool)))
return gra
