void MoleculePiSystemsMatcher::_calcConnectivity (Molecule &mol, Array<int> &conn)
{
conn.clear_resize(mol.vertexEnd());
conn.zerofill();
for (int e = mol.edgeBegin(); e != mol.edgeEnd(); e = mol.edgeNext(e))
{
int bond_order = mol.getBondOrder(e);
const Edge &edge = mol.getEdge(e);
conn[edge.beg] += bond_order;
conn[edge.end] += bond_order;
}
for (int v = mol.vertexBegin(); v != mol.vertexEnd(); v = mol.vertexNext(v))
if (!mol.isPseudoAtom(v) && !mol.isRSite(v))
conn[v] += mol.getImplicitH(v);
}
void CmfSaver::_encodeAtom (Molecule &mol, int idx, const int *mapping)
{
int number = 0;
if (mol.isPseudoAtom(idx))
{
const char *str = mol.getPseudoAtom(idx);
size_t len = strlen(str);
if (len < 1)
throw Error("empty pseudo-atom");
if (len > 255)
throw Error("pseudo-atom labels %d characters long are not supported (255 is the limit)", len);
_encode(CMF_PSEUDOATOM);
_encode((byte)len);
do
{
_encode(*str);
} while (*(++str) != 0);
}
else if (mol.isRSite(idx))
{
int bits = mol.getRSiteBits(idx);
if (bits > 255)
{
_encode(CMF_RSITE_EXT);
_output->writePackedUInt((unsigned int)bits);
}
else
{
_encode(CMF_RSITE);
_encode(bits);
}
}
else
{
number = mol.getAtomNumber(idx);
if (number <= 0 || number >= ELEM_MAX)
throw Error("unexpected atom label");
_encode(number);
}
int charge = mol.getAtomCharge(idx);
if (charge != 0)
{
int charge2 = charge - CMF_MIN_CHARGE;
if (charge2 < 0 || charge2 >= CMF_NUM_OF_CHARGES)
{
_encode(CMF_CHARGE_EXT);
int charge3 = charge + 128;
if (charge3 < 0 || charge >= 256)
throw Error("unexpected atom charge: %d", charge);
_encode(charge3);
}
else
_encode(charge2 + CMF_CHARGES);
}
int isotope = mol.getAtomIsotope(idx);
if (isotope > 0)
{
int deviation = isotope - Element::getDefaultIsotope(number);
if (deviation == 0)
_encode(CMF_ISOTOPE_ZERO);
else if (deviation == 1)
_encode(CMF_ISOTOPE_PLUS1);
else if (deviation == 2)
_encode(CMF_ISOTOPE_PLUS2);
else if (deviation == -1)
_encode(CMF_ISOTOPE_MINUS1);
else if (deviation == -2)
_encode(CMF_ISOTOPE_MINUS2);
else
{
deviation += 100;
if (deviation < 0 || deviation > 255)
throw Error("unexpected %s isotope: %d", Element::toString(number), isotope);
_encode(CMF_ISOTOPE_OTHER);
_encode(deviation);
}
}
int radical = 0;
if (!mol.isPseudoAtom(idx) && !mol.isRSite(idx))
{
try
{
radical = mol.getAtomRadical(idx);
}
catch (Element::Error)
{
}
}
if (radical > 0)
{
if (radical == RADICAL_SINGLET)
_encode(CMF_RADICAL_SINGLET);
else if (radical == RADICAL_DOUBLET)
_encode(CMF_RADICAL_DOUBLET);
else if (radical == RADICAL_TRIPLET)
_encode(CMF_RADICAL_TRIPLET);
else
throw Error("bad radical value: %d", radical);
}
MoleculeStereocenters &stereo = mol.stereocenters;
int stereo_type = stereo.getType(idx);
if (stereo_type == MoleculeStereocenters::ATOM_ANY)
_encode(CMF_STEREO_ANY);
else if (stereo_type != 0)
{
bool rigid;
int code;
const int *pyramid = stereo.getPyramid(idx);
if (pyramid[3] == -1)
rigid = MoleculeStereocenters::isPyramidMappingRigid(pyramid, 3, mapping);
else
rigid = MoleculeStereocenters::isPyramidMappingRigid(pyramid, 4, mapping);
if (stereo_type == MoleculeStereocenters::ATOM_ABS)
code = CMF_STEREO_ABS_0;
else
{
int group = stereo.getGroup(idx);
if (group < 1 || group > CMF_MAX_STEREOGROUPS)
throw Error("stereogroup number %d out of range", group);
if (stereo_type == MoleculeStereocenters::ATOM_AND)
code = CMF_STEREO_AND_0 + group - 1;
else // stereo_type == MoleculeStereocenters::ATOM_OR
code = CMF_STEREO_OR_0 + group - 1;
}
if (!rigid)
// CMF_STEREO_*_0 -> CMF_STEREO_*_1
code += CMF_MAX_STEREOGROUPS * 2 + 1;
_encode(code);
}
if (mol.allene_stereo.isCenter(idx))
{
int left, right, parity, subst[4];
mol.allene_stereo.getByAtomIdx(idx, left, right, subst, parity);
if (subst[1] != -1 && mapping[subst[1]] != -1 && mapping[subst[1]] < mapping[subst[0]])
parity = 3 - parity;
if (subst[3] != -1 && mapping[subst[3]] != -1 && mapping[subst[3]] < mapping[subst[2]])
parity = 3 - parity;
if (parity == 1)
_encode(CMF_STEREO_ALLENE_0);
else
_encode(CMF_STEREO_ALLENE_1);
}
int impl_h = 0;
if (!mol.isPseudoAtom(idx) && !mol.isRSite(idx) && Molecule::shouldWriteHCount(mol, idx))
{
try
{
impl_h = mol.getImplicitH(idx);
if (impl_h < 0 || impl_h > CMF_MAX_IMPLICIT_H)
throw Error("implicit hydrogen count %d out of range", impl_h);
_encode(CMF_IMPLICIT_H + impl_h);
}
catch (Element::Error)
{
}
}
if (!mol.isRSite(idx) && !mol.isPseudoAtom(idx))
{
if (mol.getAtomAromaticity(idx) == ATOM_AROMATIC && (charge != 0 || (number != ELEM_C && number != ELEM_O)))
{
try
{
int valence = mol.getAtomValence(idx);
if (valence < 0 || valence > CMF_MAX_VALENCE)
{
_encode(CMF_VALENCE_EXT);
_output->writePackedUInt(valence);
}
else
_encode(CMF_VALENCE + valence);
}
catch (Element::Error)
{
}
}
}
int i;
for (i = 1; i <= mol.attachmentPointCount(); i++)
{
int j, aidx;
for (j = 0; (aidx = mol.getAttachmentPoint(i, j)) != -1; j++)
if (aidx == idx)
{
_encode(CMF_ATTACHPT);
_encode(i);
}
}
if (atom_flags != 0)
{
int i, flags = atom_flags[idx];
for (i = 0; i < CMF_NUM_OF_ATOM_FLAGS; i++)
if (flags & (1 << i))
_encode(CMF_ATOM_FLAGS + i);
}
if (save_highlighting)
if (mol.isAtomHighlighted(idx))
_encode(CMF_HIGHLIGHTED);
}
void MoleculeAutomorphismSearch::_calculateHydrogensAndDegree (Molecule &mol)
{
_hcount.clear_resize(mol.vertexEnd());
_degree.clear_resize(mol.vertexEnd());
_degree.zerofill();
for (int i = mol.vertexBegin(); i != mol.vertexEnd(); i = mol.vertexNext(i))
{
if (mol.isRSite(i) || mol.isPseudoAtom(i) || mol.isTemplateAtom(i))
_hcount[i] = 0;
else
_hcount[i] = mol.getImplicitH_NoThrow(i, -1);
if (_hcount[i] < 0)
{
if (mol.getAtomAromaticity(i) == ATOM_AROMATIC)
{
if (mol.getAtomNumber(i) == ELEM_C && mol.getAtomCharge(i) == 0)
{
if (mol.getVertex(i).degree() == 3)
_hcount[i] = 0;
else if (mol.getVertex(i).degree() == 2)
_hcount[i] = 1;
}
else if (mol.getAtomNumber(i) == ELEM_O && mol.getAtomCharge(i) == 0)
_hcount[i] = 0;
else
{
if (!allow_undefined)
// This code will throw an error with a good explanation
_hcount[i] = mol.getImplicitH(i);
else
// Make number of hydrogens unique in order to make such atoms unique
_hcount[i] = 101 + i;
}
}
else
{
// Number of atoms are underfined, but all the properties like
// connectivity, charge, and etc., and this mean that such
// atoms are comparable even.
// For example, this cis-trans bond is invalid even if the number
// of hydrogens are undefined: CC=C(N(C)=O)N(C)=O
_hcount[i] = 100; // Any big number.
// Later this number can be increased including neighbour hydrogens,
// and this is correct, because nitrogens in these molecules are different:
// C[N](C)=O and [H][N]([H])(C)(C)=O
}
}
const Vertex &vertex = mol.getVertex(i);
_degree[i] = 0;
if (ignored_vertices != 0 && ignored_vertices[i])
continue;
for (int j = vertex.neiBegin(); j != vertex.neiEnd(); j = vertex.neiNext(j))
{
if (mol.getAtomNumber(vertex.neiVertex(j)) == ELEM_H &&
mol.getAtomIsotope(vertex.neiVertex(j)) == 0)
_hcount[i]++;
if (ignored_vertices == 0 || ignored_vertices[vertex.neiVertex(j)] == 0)
_degree[i]++;
}
}
// Compute independent components if the canonical ordering is not required
_independent_component_index.clear_resize(mol.vertexEnd());
if (!find_canonical_ordering)
{
// We can mark different connected components as independent
GraphDecomposer decomposer(mol);
decomposer.decompose();
_independent_component_index.copy(decomposer.getDecomposition());
}
else
_independent_component_index.fffill();
}