C++ QueryMolecule::isRSite方法代码示例

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);
        }
    }

}

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;
}

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;
}