/**
* If no isomorphism is found the result is empty vector
*
* @param container
* @return
*/
public List<List<IAtom>> getAllIsomorphismMappings(IAtomContainer container) {
if (query == null) return null;
target = container;
FlagStoreIsomorphismNode = true;
isomorphismNodes.clear();
List<List<IAtom>> result = new ArrayList<List<IAtom>>();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) {
List<IAtom> v = new ArrayList<IAtom>();
v.add(target.getAtom(i));
result.add(v);
}
}
return result;
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
executeSequence(false);
if (isomorphismFound) {
// Getting the data from the all stored Nodes
for (int k = 0; k < isomorphismNodes.size(); k++) {
Node node = isomorphismNodes.get(k);
List<IAtom> v = new ArrayList<IAtom>();
for (int i = 0; i < node.atoms.length; i++) v.add(node.atoms[i]);
result.add(v);
}
}
return result;
}
/**
* This function returns null if no isomorphism is found
*
* @param container
* @return
*/
public List<IAtom> getIsomorphismMapping(IAtomContainer container) {
if (query == null) return null;
target = container;
FlagStoreIsomorphismNode = true;
isomorphismNodes.clear();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) {
List<IAtom> v = new ArrayList<IAtom>();
v.add(target.getAtom(i));
return (v);
}
}
return null;
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
executeSequence(true);
if (isomorphismFound) {
// Getting the data from the Node
Node node = isomorphismNodes.get(0);
List<IAtom> v = new ArrayList<IAtom>();
for (int i = 0; i < node.atoms.length; i++) v.add(node.atoms[i]);
return (v);
} else return (null);
}
public void printDebugInfo() {
System.out.println("Query Atoms Topological Layers");
for (int i = 0; i < query.getAtomCount(); i++)
System.out.println("" + i + " " + query.getAtom(i).getProperty(TopLayer.TLProp).toString());
System.out.println();
System.out.println("Query Sequence");
for (int i = 0; i < sequence.size(); i++) System.out.println(sequence.get(i).toString(query));
}
public List<IBond> generateBondMapping(IAtomContainer container, List<IAtom> atomMapping) {
if (query == null) return null;
List<IBond> v = new ArrayList<IBond>();
for (int i = 0; i < query.getBondCount(); i++) {
IAtom qa0 = query.getBond(i).getAtom(0);
IAtom qa1 = query.getBond(i).getAtom(1);
IAtom a0 = atomMapping.get(query.getAtomNumber(qa0));
IAtom a1 = atomMapping.get(query.getAtomNumber(qa1));
v.add(container.getBond(a0, a1));
}
return (v);
}
void expandNode(Node node) {
// System.out.println(node.toString(target));
QuerySequenceElement el = sequence.get(node.sequenceElNum);
if (el.center == null) // This node describers a bond that closes a ring
{
// Checking whether this bond is present in the target
IAtom tAt0 = node.atoms[query.getAtomNumber(el.atoms[0])];
IAtom tAt1 = node.atoms[query.getAtomNumber(el.atoms[1])];
IBond tBo = target.getBond(tAt0, tAt1);
if (tBo != null)
if (el.bonds[0].matches(tBo)) {
node.sequenceElNum++;
// stack.push(node);
if (node.sequenceElNum == sequence.size()) {
// The node is not added in the stack if the end of the sequence is reached
isomorphismFound = true;
if (FlagStoreIsomorphismNode) isomorphismNodes.add(node);
} else stack.push(node);
}
} else {
targetAt.clear();
IAtom tAt = node.atoms[el.centerNum];
List<IAtom> conAt = target.getConnectedAtomsList(tAt);
for (int i = 0; i < conAt.size(); i++) {
if (!containsAtom(node.atoms, conAt.get(i))) targetAt.add(conAt.get(i));
}
if (el.atoms.length <= targetAt.size()) generateNodes(node);
}
}
void executeSequence(boolean stopAtFirstMapping) {
isomorphismFound = false;
stack.clear();
// Initial nodes
QuerySequenceElement el = sequence.get(0);
for (int k = 0; k < target.getAtomCount(); k++) {
IAtom at = target.getAtom(k);
if (el.center.matches(at)) {
Node node = new Node();
node.sequenceElNum = 0;
node.nullifyAtoms(query.getAtomCount());
node.atoms[el.centerNum] = at;
stack.push(node);
}
}
// Expanding the tree of all possible mappings
if (stopAtFirstMapping) {
while (!stack.isEmpty()) {
expandNode(stack.pop());
if (isomorphismFound) break;
}
} else {
while (!stack.isEmpty()) expandNode(stack.pop());
}
}
private boolean checkQuery(IQueryAtomContainer query) {
if (!(query instanceof PharmacophoreQuery)) return false;
HashMap<String, String> map = new HashMap<String, String>();
for (int i = 0; i < query.getAtomCount(); i++) {
IQueryAtom atom = (IQueryAtom) query.getAtom(i);
if (!(atom instanceof PharmacophoreQueryAtom)) return false;
PharmacophoreQueryAtom pqatom = (PharmacophoreQueryAtom) atom;
String label = pqatom.getSymbol();
String smarts = pqatom.getSmarts();
if (!map.containsKey(label)) map.put(label, smarts);
else {
if (!map.get(label).equals(smarts)) return false;
}
}
return true;
}
public boolean checkIsomorphismAtPosition(IAtomContainer container, int atomNum) {
if ((atomNum < 0) || (atomNum >= container.getAtomCount())) return false;
target = container;
FlagStoreIsomorphismNode = false;
isomorphismNodes.clear();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
return qa.matches(target.getAtom(atomNum));
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
executeSequenceAtPos(atomNum);
if (isomorphismFound) return true;
return false;
}
boolean singleAtomIsomorphism() {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
isomorphismFound = false;
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) {
isomorphismFound = true;
break;
}
}
return (isomorphismFound);
}
public boolean hasIsomorphism(IAtomContainer container) {
target = container;
FlagStoreIsomorphismNode = false;
isomorphismNodes.clear();
if (query.getAtomCount() == 1) return (singleAtomIsomorphism());
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
executeSequence(true);
return (isomorphismFound);
}
public List<Integer> getIsomorphismPositions(IAtomContainer container) {
target = container;
FlagStoreIsomorphismNode = false;
isomorphismNodes.clear();
List<Integer> v = new ArrayList<Integer>();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) v.add(new Integer(i));
}
return (v);
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
for (int i = 0; i < target.getAtomCount(); i++) {
executeSequenceAtPos(i);
if (isomorphismFound) v.add(new Integer(i));
}
return (v);
}
void executeSequenceAtPos(int pos) {
isomorphismFound = false;
stack.clear();
// Initial node
QuerySequenceElement el = sequence.get(0);
IAtom at = target.getAtom(pos);
if (el.center.matches(at)) {
Node node = new Node();
node.sequenceElNum = 0;
node.nullifyAtoms(query.getAtomCount());
node.atoms[el.centerNum] = at;
stack.push(node);
}
// Expanding the tree of all possible mappings
while (!stack.isEmpty()) {
expandNode(stack.pop());
if (isomorphismFound) break;
}
}
private boolean hasAngleConstraints(IQueryAtomContainer query) {
for (IBond bond : query.bonds()) {
if (bond instanceof PharmacophoreQueryAngleBond) return true;
}
return false;
}
void setQueryAtomSequence(IQueryAtom firstAt) {
IQueryAtom firstAtom;
QuerySequenceElement seqEl;
TopLayer topLayer;
// List<IQueryAtom> curAddedAtoms = new List<IQueryAtom>();
int n;
if (firstAt == null) firstAtom = (IQueryAtom) query.getFirstAtom();
else firstAtom = firstAt;
sequence.clear();
sequencedAtoms.clear();
sequencedBondAt1.clear();
sequencedBondAt2.clear();
// Set first sequence atom
sequencedAtoms.add(firstAtom);
seqEl = new QuerySequenceElement();
seqEl.center = firstAtom;
topLayer = (TopLayer) firstAtom.getProperty(TopLayer.TLProp);
n = topLayer.atoms.size();
seqEl.atoms = new IQueryAtom[n];
seqEl.bonds = new IQueryBond[n];
for (int i = 0; i < n; i++) {
sequencedAtoms.add((IQueryAtom) topLayer.atoms.get(i));
seqEl.atoms[i] = (IQueryAtom) topLayer.atoms.get(i);
seqEl.bonds[i] = (IQueryBond) topLayer.bonds.get(i);
addSeqBond(seqEl.center, seqEl.atoms[i]);
}
sequence.add(seqEl);
// Sequencing the entire query structure
Stack<QuerySequenceElement> stack = new Stack<QuerySequenceElement>();
stack.push(seqEl);
while (!stack.empty()) {
// curAddedAtoms.clear();
QuerySequenceElement curSeqAt = stack.pop();
for (int i = 0; i < curSeqAt.atoms.length; i++) {
topLayer = (TopLayer) curSeqAt.atoms[i].getProperty(TopLayer.TLProp);
if (topLayer.atoms.size() == 1)
continue; // it is terminal atom and no further sequencing should be done
int a[] = getSeqAtomsInLayer(topLayer);
n = 0;
for (int k = 0; k < a.length; k++) if (a[k] == 0) n++;
if (n > 0) {
seqEl = new QuerySequenceElement();
seqEl.center = curSeqAt.atoms[i];
seqEl.atoms = new IQueryAtom[n];
seqEl.bonds = new IQueryBond[n];
sequence.add(seqEl);
stack.add(seqEl);
}
int j = 0;
for (int k = 0; k < a.length; k++) {
if (a[k] == 0) {
seqEl.atoms[j] = (IQueryAtom) topLayer.atoms.get(k);
seqEl.bonds[j] = (IQueryBond) topLayer.bonds.get(k);
addSeqBond(seqEl.center, seqEl.atoms[j]);
sequencedAtoms.add(seqEl.atoms[j]);
// curAddedAtoms.add(seqEl.atoms[j]);
j++;
} else {
if (curSeqAt.center == topLayer.atoms.get(k)) continue;
// Check whether bond(curSeqAt.atoms[i]-topLayer.atoms.get(k))
// is already sequenced
if (getSeqBond(curSeqAt.atoms[i], topLayer.atoms.get(k)) != -1) continue;
// topLayer.atoms.get(k) atom is already sequenced.
// Therefore sequnce element of 'bond' type is registered.
// newSeqEl is not added in the stack (this is not needed for this bond)
QuerySequenceElement newSeqEl = new QuerySequenceElement();
newSeqEl.center = null;
newSeqEl.atoms = new IQueryAtom[2];
newSeqEl.bonds = new IQueryBond[1];
newSeqEl.atoms[0] = curSeqAt.atoms[i];
newSeqEl.atoms[1] = (IQueryAtom) topLayer.atoms.get(k);
addSeqBond(newSeqEl.atoms[0], newSeqEl.atoms[1]);
newSeqEl.bonds[0] = (IQueryBond) topLayer.bonds.get(k);
sequence.add(newSeqEl);
}
}
}
}
for (int i = 0; i < sequence.size(); i++) sequence.get(i).setAtomNums(query);
}