void MangoSubstructure::_correctQueryStereo (QueryMolecule &query)
{
// Remove stereobond marks that are connected with R-groups
for (int v = query.vertexBegin();
v != query.vertexEnd();
v = query.vertexNext(v))
{
if (!query.isRSite(v))
continue;
const Vertex &vertex = query.getVertex(v);
for (int nei = vertex.neiBegin();
nei != vertex.neiEnd();
nei = vertex.neiNext(nei))
{
int edge = vertex.neiEdge(nei);
if (query.cis_trans.getParity(edge) != 0)
query.cis_trans.setParity(edge, 0);
}
}
MoleculeRGroups &rgroups = query.rgroups;
int n_rgroups = rgroups.getRGroupCount();
for (int i = 1; i <= n_rgroups; i++)
{
PtrPool<BaseMolecule> &frags = rgroups.getRGroup(i).fragments;
for (int j = frags.begin(); j != frags.end(); j = frags.next(j))
{
QueryMolecule &fragment = frags[j]->asQueryMolecule();
_correctQueryStereo(fragment);
}
}
}
void MoleculePiSystemsMatcher::_markMappedPiSystems (QueryMolecule &query,
const int *mapping)
{
for (int qv = query.vertexBegin();
qv != query.vertexEnd();
qv = query.vertexNext(qv))
{
int v = mapping[qv];
if (v < 0)
continue; // Such vertex must be ignored
int pi_system_idx = _atom_pi_system_idx[v];
if (pi_system_idx == _NOT_IN_PI_SYSTEM)
continue;
if (!_pi_systems[pi_system_idx].initialized)
_extractPiSystem(pi_system_idx);
_Pi_System &pi_system = _pi_systems[pi_system_idx];
if (!pi_system.pi_system_mapped)
{
pi_system.pi_system_mapped = true;
pi_system.localizer->unfixAll();
}
}
}
QueryMoleculeAromatizer::QueryMoleculeAromatizer (QueryMolecule &molecule, const AromaticityOptions &options) :
AromatizerBase(molecule),
TL_CP_GET(_pi_labels),
TL_CP_GET(_aromatic_cycles)
{
_pi_labels.clear_resize(molecule.vertexEnd());
_aromatic_cycles.clear();
_aromatic_cycles.reserve(100);
_mode = FUZZY;
_collecting = false;
_options = options;
}
bool MoleculePiSystemsMatcher::_fixAtoms (QueryMolecule &query, const int *mapping)
{
// Fix charges
for (int qv = query.vertexBegin();
qv != query.vertexEnd();
qv = query.vertexNext(qv))
{
int v = mapping[qv];
if (v < 0)
continue; // Such vertex must be ignored
int pi_system_idx = _atom_pi_system_idx[v];
if (pi_system_idx == _NOT_IN_PI_SYSTEM)
continue;
_Pi_System &pi_system = _pi_systems[pi_system_idx];
QueryMolecule::Atom &qatom = query.getAtom(qv);
int pv = pi_system.inv_mapping[v];
int charge = query.getAtomCharge(qv);
if (charge != CHARGE_UNKNOWN)
{
bool ret = pi_system.localizer->fixAtomCharge(pv, charge);
if (!ret)
return false;
}
else if (qatom.hasConstraint(QueryMolecule::ATOM_CHARGE))
throw Error("Unsupported atom charge specified");
int valence = query.getExplicitValence(qv);
if (valence != -1)
{
bool ret = pi_system.localizer->fixAtomConnectivity(pv, valence);
if (!ret)
return false;
}
else if (qatom.hasConstraint(QueryMolecule::ATOM_VALENCE))
throw Error("Unsupported atom charge specified");
}
return true;
}
bool QueryMoleculeAromatizer::_aromatizeBonds (QueryMolecule &mol, int additional_atom, const AromaticityOptions &options)
{
bool aromatized = false;
// Mark edges that can be aromatic in some matching
aromatized |= _aromatizeBondsFuzzy(mol, options);
// Aromatize all aromatic cycles
aromatized |= _aromatizeBondsExact(mol, options);
MoleculeRGroups &rgroups = mol.rgroups;
int n_rgroups = rgroups.getRGroupCount();
// Check if r-groups are attached with single bonds
QS_DEF(Array<bool>, rgroups_attached_single);
rgroups_attached_single.clear();
for (int v = mol.vertexBegin(); v != mol.vertexEnd(); v = mol.vertexNext(v))
{
if (v == additional_atom)
continue;
if (mol.isRSite(v))
{
// Check if neighbor bonds are single
const Vertex &vertex = mol.getVertex(v);
for (int nei = vertex.neiBegin(); nei != vertex.neiEnd(); nei = vertex.neiNext(nei))
{
int edge = vertex.neiEdge(nei);
QueryMolecule::Bond &bond = mol.getBond(edge);
// DP TODO: implement smth. like Node::possibleOtherValueExcept() ...
bool can_be_double = bond.possibleValue(QueryMolecule::BOND_ORDER, BOND_DOUBLE);
bool can_be_triple = bond.possibleValue(QueryMolecule::BOND_ORDER, BOND_TRIPLE);
bool can_be_arom = bond.possibleValue(QueryMolecule::BOND_ORDER, BOND_AROMATIC);
if (can_be_double || can_be_triple || can_be_arom)
{
QS_DEF(Array<int>, sites);
mol.getAllowedRGroups(v, sites);
for (int j = 0; j < sites.size(); j++)
{
rgroups_attached_single.expandFill(sites[j] + 1, true);
rgroups_attached_single[sites[j]] = false;
}
}
}
}
}
rgroups_attached_single.expandFill(n_rgroups + 1, true);
for (int i = 1; i <= n_rgroups; i++)
{
PtrPool<BaseMolecule> &frags = rgroups.getRGroup(i).fragments;
for (int j = frags.begin(); j != frags.end(); j = frags.next(j))
{
QueryMolecule &fragment = frags[j]->asQueryMolecule();
aromatized |= _aromatizeRGroupFragment(fragment, rgroups_attached_single[i], options);
}
}
return aromatized;
}
QueryMoleculeAromatizer::QueryMoleculeAromatizer (QueryMolecule &molecule, const AromaticityOptions &options) :
AromatizerBase(molecule),
CP_INIT,
TL_CP_GET(_pi_labels),
TL_CP_GET(_aromatic_cycles)
{
_pi_labels.clear_resize(molecule.vertexEnd());
_aromatic_cycles.clear();
_aromatic_cycles.reserve(100);
_mode = FUZZY;
_collecting = false;
_options = options;
}
void QueryMoleculeAromatizer::precalculatePiLabels ()
{
for (int v_idx = _basemol.vertexBegin();
v_idx < _basemol.vertexEnd();
v_idx = _basemol.vertexNext(v_idx))
_pi_labels[v_idx] = _getPiLabel(v_idx);
}
bool QueryMoleculeAromatizer::_checkVertex (int v_idx)
{
return _pi_labels[v_idx].canBeAromatic();
}
bool QueryMoleculeAromatizer::_isCycleAromatic (const int *cycle, int cycle_len)
{
QueryMolecule &query = (QueryMolecule &)_basemol;
// Single/double bond can't be aromatic and Check if cycle wasn't aromatic
bool all_aromatic = true;
for (int i = 0; i < cycle_len; i++)
{
int a = cycle[i], b = cycle[(i + 1) % cycle_len];
int e_idx = _basemol.findEdgeIndex(a, b);
if (!query.possibleBondOrder(e_idx, BOND_AROMATIC))
all_aromatic = false;
}
if (all_aromatic)
return false;
PiValue cycle_sum(0, 0);
// Check Huckel's rule
for (int i = 0; i < cycle_len; i++)
{
PiValue &cur = _pi_labels[cycle[i]];
if (cur.min == -1 || cur.max == -1)
throw Error("interal error in _isCycleAromatic");
cycle_sum.max += cur.max;
cycle_sum.min += cur.min;
}
// Check Huckel's rule
if (_mode == EXACT)
{
if (cycle_sum.min != cycle_sum.max)
return false;
int sum = cycle_sum.min;
// Check if cycle have pi-lables sum 4n+2 for drawn query
if (sum % 4 != 2)
return false;
return true;
}
//
// Fuzzy mode: check if circle can have 4n-2 value
//
if (cycle_sum.max - cycle_sum.min > 3)
return true;
int residue_min = (cycle_sum.min + 2) % 4;
int residue_max = (cycle_sum.max + 2) % 4;
if (residue_min == 0 || residue_min > residue_max)
return true;
return false;
}
bool MoleculeSubstructureMatcher::_shouldUnfoldTargetHydrogens (QueryMolecule &query, bool is_fragment, bool disable_folding_query_h)
{
int i, j;
for (i = query.vertexBegin(); i != query.vertexEnd(); i = query.vertexNext(i))
{
// skip R-atoms
if (query.isRSite(i))
continue;
if (query.possibleAtomNumberAndIsotope(i, ELEM_H, 0))
{
const Vertex &vertex = query.getVertex(i);
// Degree 2 or higher => definilely not a hydrogen
if (vertex.degree() > 1)
continue;
// Can be lone hydrogen?
if (vertex.degree() == 0)
return true;
// degree is 1 at this point
int edge_idx = vertex.neiEdge(vertex.neiBegin());
// is it is double or triple bond => not hydrogen
if (query.getBondOrder(edge_idx) > 1)
continue;
// ring bond?
if (query.getBondTopology(edge_idx) == TOPOLOGY_RING)
continue;
// can be something other than hydrogen?
if (query.getAtomNumber(i) == -1)
return true;
if (is_fragment && i == query.vertexBegin())
// If first atom in a fragment is hydrogen then hydrogens should
// be unfolded because of the matching logic: when fragment will be
// matched this first hydrogen should match some atom.
// If hydrogens is not be unfolded in this case then
// [$([#1][N])]C will not match NC.
return true;
// If we need to find all embeddings then query hydrogens cannot be ignored:
// For example, if we are searching number of matcher for N-[#1] in N then
// it should 3 instead of 1
if (disable_folding_query_h)
return true;
// Check if hydrogen forms a cis-trans bond or stereocenter
int nei_vertex_idx = vertex.neiVertex(vertex.neiBegin());
if (query.stereocenters.exists(nei_vertex_idx))
return true;
// For example for this query hydrogens should be unfolded: [H]\\C=C/C
const Vertex &nei_vertex = query.getVertex(nei_vertex_idx);
for (int nei = nei_vertex.neiBegin(); nei != nei_vertex.neiEnd(); nei = nei_vertex.neiNext(nei))
{
int edge = nei_vertex.neiEdge(nei);
if (query.cis_trans.getParity(edge) != 0)
return true;
}
}
if (_shouldUnfoldTargetHydrogens_A(&query.getAtom(i), is_fragment, disable_folding_query_h))
return true;
}
MoleculeRGroups &rgroups = query.rgroups;
int n_rgroups = rgroups.getRGroupCount();
for (i = 1; i <= n_rgroups; i++)
{
PtrPool<BaseMolecule> &frags = rgroups.getRGroup(i).fragments;
for (j = frags.begin(); j != frags.end(); j = frags.next(j))
if (_shouldUnfoldTargetHydrogens(frags[j]->asQueryMolecule(), is_fragment, disable_folding_query_h))
return true;
}
return false;
}