def _compute_sas(mol: Mol, sa_model: Dict[int, float]) -> float:
fp = rdMolDescriptors.GetMorganFingerprint(mol, 2)
fps = fp.GetNonzeroElements()
score1 = 0.
nf = 0
# for bitId, v in fps.items():
for bitId, v in fps.items():
nf += v
sfp = bitId
score1 += sa_model.get(sfp, -4) * v
score1 /= nf
# features score
nAtoms = mol.GetNumAtoms()
nChiralCenters = len(FindMolChiralCenters(mol, includeUnassigned=True))
ri = mol.GetRingInfo()
nSpiro = rdMolDescriptors.CalcNumSpiroAtoms(mol)
nBridgeheads = rdMolDescriptors.CalcNumBridgeheadAtoms(mol)
nMacrocycles = 0
for x in ri.AtomRings():
if len(x) > 8:
nMacrocycles += 1
sizePenalty = nAtoms**1.005 - nAtoms
stereoPenalty = math.log10(nChiralCenters + 1)
spiroPenalty = math.log10(nSpiro + 1)
bridgePenalty = math.log10(nBridgeheads + 1)
macrocyclePenalty = 0.
# ---------------------------------------
# This differs from the paper, which defines:
# macrocyclePenalty = math.log10(nMacrocycles+1)
# This form generates better results when 2 or more macrocycles are present
if nMacrocycles > 0:
macrocyclePenalty = math.log10(2)
score2 = 0. - sizePenalty - stereoPenalty - spiroPenalty - bridgePenalty - macrocyclePenalty
# correction for the fingerprint density
# not in the original publication, added in version 1.1
# to make highly symmetrical molecules easier to synthetise
score3 = 0.
if nAtoms > len(fps):
score3 = math.log(float(nAtoms) / len(fps)) * .5
sascore = score1 + score2 + score3
# need to transform "raw" value into scale between 1 and 10
min = -4.0
max = 2.5
sascore = 11. - (sascore - min + 1) / (max - min) * 9.
# smooth the 10-end
if sascore > 8.:
sascore = 8. + math.log(sascore + 1. - 9.)
if sascore > 10.:
sascore = 10.0
elif sascore < 1.:
sascore = 1.0
return sascore
def ring_infraction(molecule: Chem.Mol) -> bool:
"""
Checks if a given molecule fails the ring infraction filters.
"""
ring_allene = molecule.HasSubstructMatch(Chem.MolFromSmarts('[R]=[R]=[R]'))
macro_cycle = max([len(j) for j in molecule.GetRingInfo().AtomRings()]) > 6
double_bond_in_small_ring = molecule.HasSubstructMatch(Chem.MolFromSmarts('[r3,r4]=[r3,r4]'))
return ring_allene or macro_cycle or double_bond_in_small_ring
def _CalculateChivnch(mol: Chem.Mol, NumCyc=3):
"""Calculate valence molecular connectivity chi index for cycles of n."""
accum = 0.0
deltas = _HallKierDeltas(mol, skipHs=0)
for tup in mol.GetRingInfo().AtomRings():
cAccum = 1.0
if len(tup) == NumCyc:
for idx in tup:
cAccum *= deltas[idx]
if cAccum:
accum += 1. / numpy.sqrt(cAccum)
return accum
def _CalculateChinch(mol: Chem.Mol, NumCycle=3):
"""Calculate molecular connectivity chi index for cycles of n."""
accum = 0.0
deltas = [x.GetDegree() for x in mol.GetAtoms()]
for tup in mol.GetRingInfo().AtomRings():
cAccum = 1.0
if len(tup) == NumCycle:
for idx in tup:
cAccum *= deltas[idx]
if cAccum:
accum += 1. / numpy.sqrt(cAccum)
return accum
def _penalized_logp_atomrings(mol: Mol, dataset: str):
log_p = Descriptors.MolLogP(mol)
sa_score = sascorer.calculateScore(mol)
cycle_list = mol.GetRingInfo().AtomRings()
largest_ring_size = max([len(j) for j in cycle_list]) if cycle_list else 0
cycle_score = max(largest_ring_size - 6, 0)
log_p = (log_p - LOGP_MEAN) / LOGP_STD
sa_score = (sa_score - SASCORE_MEAN) / SASCORE_STD
cycle_score = (cycle_score - ATOMRING_CYCLESCORE_MEAN) / ATOMRING_CYCLESCORE_STD
return log_p - sa_score - cycle_score
def get_max_ring_size(mol: Mol) -> int:
"""Return the maximum ring size of a molecule. If the molecule is linear, 0 is returned.
Parameters:
===========
mol: The input molecule
Returns:
========
The maximal ring size of the input molecule
"""
ring_sizes = [len(x) for x in mol.GetRingInfo().AtomRings()]
try:
return max(ring_sizes)
except ValueError:
return 0
def get_all_path_between(
mol: Chem.Mol,
atom_idx_1: int,
atom_idx_2: int,
ignore_cycle_basis: bool = False,
):
"""Get all simple path between two atoms of a molecule
Args:
mol (Chem.Mol): a molecule
atom_idx_1 (int): Atom index 1.
atom_idx_2 (int): Atom index 2.
ignore_cycle_basis: Whether to ignore cycle basis.
Defaults to False.
Returns:
[type]: [description]
"""
nx = _get_networkx()
adj = Chem.rdmolops.GetAdjacencyMatrix(mol)
G = nx.Graph(adj)
path = nx.all_simple_paths(G, source=atom_idx_1, target=atom_idx_2)
if ignore_cycle_basis:
rings = [set(x) for x in mol.GetRingInfo().AtomRings()]
final_path = []
for p in path:
reject_path = False
for r in rings:
if r.issubset(set(p)):
reject_path = True
break
if not reject_path:
final_path.append(p)
path = final_path
return list(path)
def build_atom_features(mol: Chem.Mol) -> List[Any]:
hydrogen_donor = Chem.MolFromSmarts(
"[$([N;!H0;v3,v4&+1]),$([O,S;H1;+0]),n&H1&+0]")
hydrogen_acceptor = Chem.MolFromSmarts(
"[$([O,S;H1;v2;!$(*-*=[O,N,P,S])]),$([O,S;H0;v2]),$([O,S;-]),$([N;v3;!$(N-*=[O,N,P,S])]),"
"n&H0&+0,$([o,s;+0;!$([o,s]:n);!$([o,s]:c:n)])]")
acidic = Chem.MolFromSmarts("[$([C,S](=[O,S,P])-[O;H1,-1])]")
basic = Chem.MolFromSmarts(
"[#7;+,$([N;H2&+0][$([C,a]);!$([C,a](=O))]),$([N;H1&+0]([$([C,a]);!$([C,a](=O))])[$([C,a]);"
"!$([C,a](=O))]),$([N;H0&+0]([C;!$(C(=O))])([C;!$(C(=O))])[C;!$(C(=O))])]"
)
hydrogen_donor_match = sum(mol.GetSubstructMatches(hydrogen_donor), ())
hydrogen_acceptor_match = sum(mol.GetSubstructMatches(hydrogen_acceptor),
())
acidic_match = sum(mol.GetSubstructMatches(acidic), ())
basic_match = sum(mol.GetSubstructMatches(basic), ())
ring_info = mol.GetRingInfo()
return [
get_atom_features(atom, hydrogen_acceptor_match, hydrogen_donor_match,
acidic_match, basic_match, ring_info)
for atom in mol.GetAtoms()
]
def collapse_ring(self, mol: Chem.Mol) -> Chem.Mol:
"""
Collapses a ring(s) into a single dummy atom(s).
Stores data as JSON in the atom.
:param mol:
:return:
"""
self.store_positions(mol)
mol = Chem.RWMol(mol)
conf = mol.GetConformer()
center_idxs = []
morituri = []
old2center = defaultdict(list)
for atomset in mol.GetRingInfo().AtomRings():
morituri.extend(atomset)
neighs = []
neighbonds = []
bonds = []
xs = []
ys = []
zs = []
elements = []
# add elemental ring
c = mol.AddAtom(Chem.Atom('C'))
center_idxs.append(c)
central = mol.GetAtomWithIdx(c)
name = mol.GetProp('_Name') if mol.HasProp('_Name') else '???'
central.SetProp('_ori_name', name),
# get data for storage
for i in atomset:
old2center[i].append(c)
atom = mol.GetAtomWithIdx(i)
neigh_i = [a.GetIdx() for a in atom.GetNeighbors()]
neighs.append(neigh_i)
bond = [mol.GetBondBetweenAtoms(i, j).GetBondType().name for j in neigh_i]
bonds.append(bond)
pos = conf.GetAtomPosition(i)
xs.append(pos.x)
ys.append(pos.y)
zs.append(pos.z)
elements.append(atom.GetSymbol())
# store data in elemental ring
central.SetIntProp('_ori_i', -1)
central.SetProp('_ori_is', json.dumps(atomset))
central.SetProp('_neighbors', json.dumps(neighs))
central.SetProp('_xs', json.dumps(xs))
central.SetProp('_ys', json.dumps(ys))
central.SetProp('_zs', json.dumps(zs))
central.SetProp('_elements', json.dumps(elements))
central.SetProp('_bonds', json.dumps(bonds))
conf.SetAtomPosition(c, Point3D(*[sum(axis) / len(axis) for axis in (xs, ys, zs)]))
for atomset, center_i in zip(mol.GetRingInfo().AtomRings(), center_idxs):
# bond to elemental ring
central = mol.GetAtomWithIdx(center_i)
neighss = json.loads(central.GetProp('_neighbors'))
bondss = json.loads(central.GetProp('_bonds'))
for neighs, bonds in zip(neighss, bondss):
for neigh, bond in zip(neighs, bonds):
if neigh not in atomset:
bt = getattr(Chem.BondType, bond)
if neigh not in morituri:
mol.AddBond(center_i, neigh, bt)
else:
for other_center_i in old2center[neigh]:
if center_i != other_center_i:
if not mol.GetBondBetweenAtoms(center_i, other_center_i):
mol.AddBond(center_i, other_center_i, bt)
break
else:
raise ValueError(f'Cannot find what {neigh} became')
for i in sorted(set(morituri), reverse=True):
mol.RemoveAtom(self._get_new_index(mol, i))
return mol.GetMol()
