CuttingRule.java

Go to the documentation of this file.

package denoptim.programs.fragmenter;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import org.openscience.cdk.interfaces.IAtom;
import org.openscience.cdk.interfaces.IAtomContainer;
import org.openscience.cdk.isomorphism.Mappings;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.graph.APClass;
import denoptim.utils.ManySMARTSQuery;
import denoptim.utils.MoleculeUtils;
 
public class CuttingRule
{
    private String ruleName;
    
    private APClass apc0;
    
    private APClass apc1;
 
    private String smartsAtm0;
    
    private String smartsAtm1;
    
    private String smartsBnd;
 
    private int priority;
 
    private List<String> opts;
 
 
//------------------------------------------------------------------------------
 
    public CuttingRule(String ruleName, String smartsAtm0, String smartsAtm1, 
            String smartsBnd, int priority, List<String> opts)
    {
        this.ruleName = ruleName;
        if (ruleName.isEmpty() || ruleName.isBlank())
            throw new IllegalArgumentException("ruleName cannot be '" 
                    + ruleName + "'");
        if (smartsAtm0.isEmpty() || smartsAtm0.isBlank())
            throw new IllegalArgumentException("SMARTS for atom cannot be '" 
                    + smartsAtm0 + "'");
        if (smartsAtm1.isEmpty() || smartsAtm1.isBlank())
            throw new IllegalArgumentException("SMARTS for atom cannot be '" 
                    + smartsAtm1 + "'");
        if (smartsBnd.isEmpty() || smartsBnd.isBlank())
            throw new IllegalArgumentException("SMARTS for bond cannot be '" 
                    + smartsBnd + "'");
        this.smartsAtm0 = smartsAtm0;
        this.smartsAtm1 = smartsAtm1;
        this.smartsBnd = smartsBnd;
        this.priority = priority;
        this.opts = opts;
        try
        {
            apc0 = APClass.make(ruleName + DENOPTIMConstants.SEPARATORAPPROPSCL
                    + "0");
            apc1 = APClass.make(ruleName + DENOPTIMConstants.SEPARATORAPPROPSCL 
                    + "1");
        } catch (DENOPTIMException e)
        {
            //cannot happen
        }
    }
 
//------------------------------------------------------------------------------
 
    public String getName()
    {
        return ruleName;
    }
    
 
//------------------------------------------------------------------------------
    
   public int getPriority()
   {
       return priority;
   }
 
//------------------------------------------------------------------------------
 
    public APClass getAPClass0()
    {
        return apc0;
    }
 
//------------------------------------------------------------------------------
 
    public APClass getAPClass1()
    {
        if (this.isSymmetric())
            return apc0;
        else
            return apc1;
    }
 
//------------------------------------------------------------------------------
 
    public APClass getComplementaryAPClass(APClass apc)
    {
        if (this.isSymmetric() && apc.equals(apc0))
        {
            return apc0;
        } else if (!this.isSymmetric() && apc.equals(apc0)) {
            return apc1;
        } else if (!this.isSymmetric() && apc.equals(apc1)) {
            return apc0;
        } else {
            return null;
        }
    }
 
//------------------------------------------------------------------------------
 
    public String getWholeSMARTSRule()
    {
        return smartsAtm0+smartsBnd+smartsAtm1;
    }
 
//------------------------------------------------------------------------------
 
    public String getSMARTSAtom0()
    {
        return smartsAtm0;
    }
 
//------------------------------------------------------------------------------
 
    public String getSMARTSAtom1()
    {
        return smartsAtm1;
    }
 
//------------------------------------------------------------------------------
 
    public String getSMARTSBnd()
    {
        return smartsBnd;
    }
 
//------------------------------------------------------------------------------
 
    public boolean hasOptions()
    {
        if (opts.size() > 0)
            return true;
        else
            return false;
    }
 
//------------------------------------------------------------------------------
 
    public boolean isHAPTO()
    {
        if (opts.contains("HAPTO"))
            return true;
        else
            return false;
    }
 
//------------------------------------------------------------------------------
 
    public boolean isSymmetric()
    {
        if (smartsAtm0.equals(smartsAtm1))
            return true;
        else
            return false;
    }
 
//------------------------------------------------------------------------------
 
    public List<String> getOptions()
    {
        return opts;
    }
 
//------------------------------------------------------------------------------
 
    public int getBondOrder()
    {
        int res = -1;
    
        //Easy case
        String s = smartsBnd;
        if (s.contains("!@"))
        {
            s = s.substring(0,s.indexOf("!@"));
        }
        if (s.equals("-"))
            res = 1;
        else if (s.equals("="))
            res = 2;
        else if (s.equals("#"))
            res = 3;
        return res;
    
        // well, in general it's not so easy...
        //TODO make it more general.
    }
 
//------------------------------------------------------------------------------
 
    public boolean involvesMetal()
    {
        for (String el : DENOPTIMConstants.ALL_METALS)
        {
            if (smartsAtm0.contains(el))
            {
            return true;
            }
        }
 
        //analyze atom 1
        for (String el : DENOPTIMConstants.ALL_METALS)
        {
            if (smartsAtm1.contains(el))
            {
                return true;
            }
        }
        return false;
    }
 
//------------------------------------------------------------------------------
 
    public String toString()
    {
        String str = ruleName+"_"+smartsAtm0+smartsBnd+smartsAtm1+
                "_priority:"+priority+
                "_opts:"+opts;
        return str;
    }
    
//------------------------------------------------------------------------------
    
    @Override
    public boolean equals(Object o)
    {
        if (!(o instanceof CuttingRule))
            return false;
                
        CuttingRule other = (CuttingRule) o;
        if (!this.getName().equals(other.getName()))
            return false;
        if (!this.getSMARTSAtom0().equals(other.getSMARTSAtom0()))
            return false;
        if (!this.getSMARTSAtom1().equals(other.getSMARTSAtom1()))
            return false;
        if (!this.getSMARTSBnd().equals(other.getSMARTSBnd()))
            return false;
        if (this.getPriority() != other.getPriority())
            return false;
        if (this.getOptions().size() != other.getOptions().size())
            return false;
        for (int i=0; i<this.getOptions().size(); i++)
        {
            if (!this.getOptions().get(i).equals(other.getOptions().get(i)))
                return false;
        }
        return true;
    }
 
//------------------------------------------------------------------------------
    
    public Boolean satisfiesOptions(MatchedBond matchedBond, Logger logger)
    {
        IAtom atmS = matchedBond.getAtmSubClass0();
        IAtom atmT = matchedBond.getAtmSubClass1();
        IAtomContainer mol = atmS.getContainer();
        int idxSInMol = mol.indexOf(atmS);
        int idxTInMol = mol.indexOf(atmT);
        
        boolean hasHapto = false;
        boolean checkRings = false;
        int minSzRing = -1;
        boolean checkOMRings = false;
        int minSzOMRing = -1;
        for (String opt : opts)
        {
            if (opt.startsWith("HAPTO"))
                hasHapto = true;
            
            if (opt.startsWith("RING>"))
            {
                checkRings = true;
                minSzRing = Integer.parseInt(opt.replace("RING>","").trim());
                
            } else if (opt.startsWith("OMRING"))
            {
                checkOMRings = true;
                minSzOMRing = Integer.parseInt(opt.replace("OMRING>","").trim());
            }
        }
        
        // from here it is all about OM/Ring, and these are both incompatible 
        // with HAPTO. So if we have HAPTO we should not test OM/Ring-options
        if (hasHapto)
            return true;
        
        // Build SMARTS queries for rings as large as needed to test criteria
        Map<String,String> allSmarts = new HashMap<String,String>();
        StringBuilder smartsBuilder = new StringBuilder();
        // "ring size" i = 1
        smartsBuilder.append(this.getSMARTSAtom0());
        smartsBuilder.append("1");
        smartsBuilder.append(this.getSMARTSBnd());
        // "ring size" i=2
        smartsBuilder.append(this.getSMARTSAtom1());
        smartsBuilder.append("~");
        // "ring size" from 3 and on
        for (int i=3; i<Math.max(minSzRing, minSzOMRing)+1; i++)
        {
            smartsBuilder.append("[*]~");
            allSmarts.put("ring"+i, smartsBuilder.toString()+"1");
        }
        
        // Find all rings matching the queries
        ManySMARTSQuery msq = new ManySMARTSQuery(mol, allSmarts);
        if (msq.hasProblems())
        {
            if (logger!=null)
            {
                logger.log(Level.WARNING, "Problem matching SMARTS for OM/RING "
                        + "options. Ignoring bond for which we cannot check if "
                        + "we satisfy OM/RING options. " + msq.getMessage());
            }
            return false;
        }
        
        for (int ringSize=3; ringSize<Math.max(minSzRing, minSzOMRing)+1; ringSize++)
        {
            String smartsName = "ring"+ringSize;
            if (msq.getNumMatchesOfQuery(smartsName) == 0)
            {
                continue;
            }
            
            // Get atoms matching cutting rule queries
            Mappings atomsInAllRings = msq.getMatchesOfSMARTS(smartsName);
            for (int[] atmsInOneRing : atomsInAllRings) 
            {
                if (atmsInOneRing[0]==idxSInMol && atmsInOneRing[1]==idxTInMol)
                {
                    boolean isOMRing = false;
                    for (int j=0; j<atmsInOneRing.length; j++)
                    {
                        IAtom atmInRing = mol.getAtom(atmsInOneRing[j]);
                        
                        if (MoleculeUtils.isElement(atmInRing) 
                                && DENOPTIMConstants.ALL_METALS.contains(
                                        atmInRing.getSymbol()))
                        {
                            isOMRing = true;
                            break;
                        }
                    }
                    if (!isOMRing && checkRings && ringSize<=minSzRing)
                    {
 
                        logger.log(Level.FINEST,"Bond between " + idxSInMol 
                                + " and " + idxTInMol + " matches SMARTS of "
                                + "cutting rule '" + this.ruleName 
                                + "', but does not satisfy "
                                + "RING>" + minSzRing + " as it is part of "
                                + "a " + ringSize + "-member organic-only ring.");
                        return false;
                    }
                    if (isOMRing && checkOMRings && ringSize<=minSzOMRing)
                    {
                        logger.log(Level.FINEST,"Bond between " + idxSInMol 
                                + " and " + idxTInMol + " matches SMARTS of "
                                + "cutting rule '" + this.ruleName 
                                + "', but does not satisfy "
                                + "OMRING>" + minSzOMRing + " as it is part of "
                                + "a " + ringSize + "-member ring including a "
                                + "metal.");
                        return false;
                    }
                }
            }
        }
        return true;
    }
 
//------------------------------------------------------------------------------
 
}