FragmenterTask.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2022 Marco Foscato <marco.foscato@uib.no>
 * 
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.fragmenter;
 
import java.io.File;
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
 
import denoptim.io.DenoptimIO;
import denoptim.programs.fragmenter.FragmenterParameters;
import denoptim.task.Task;
import denoptim.utils.TaskUtils;
 
public class FragmenterTask extends Task
{   
    private File inputFile;
    
    private File preliminaryResults;
    
    protected String results = null;
   
    protected FragmenterParameters settings;
    
    private Logger logger = null;
    
    private String logFilePathname = "unset";
 
//------------------------------------------------------------------------------
    
    public FragmenterTask(File inputFile, FragmenterParameters settings,
            int id) throws SecurityException, IOException
    {
        super(TaskUtils.getUniqueTaskIndex());
        this.id = id;
        this.inputFile = inputFile;
        this.settings = settings;
        this.logger = Logger.getLogger("FragmenterTask-"+id);
        
        //Create the task-specific logger
        int n = logger.getHandlers().length;
        for (int i=0; i<n; i++)
        {
            logger.removeHandler(logger.getHandlers()[0]);
        }
 
        this.logFilePathname = getLogFileName(settings,id);
        FileHandler fileHdlr = new FileHandler(logFilePathname);
        SimpleFormatter formatterTxt = new SimpleFormatter();
        fileHdlr.setFormatter(formatterTxt);
        logger.setUseParentHandlers(false);
        logger.addHandler(fileHdlr);
        logger.setLevel(settings.getLogger().getLevel());
        String header = "Started logging for FragmenterTask-"+id ;
        logger.log(Level.INFO,header);
    }
    
//------------------------------------------------------------------------------
 
    static String getInputFileName(FragmenterParameters settings, int i)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "structuresBatch-" + i + ".sdf";
    }
    
//------------------------------------------------------------------------------
    
    public String getLogFilePathname()
    {
        return logFilePathname;
    }
    
//------------------------------------------------------------------------------
    
    public String getResultFile()
    {
        return results;
    }
    
//------------------------------------------------------------------------------
 
    static String getConfirmedFormulaFileName(FragmenterParameters settings, int i)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "structuresNoMissingAtoms-" + i + ".sdf";
    }
    
//------------------------------------------------------------------------------
 
    static String getPreFilteredFileName(FragmenterParameters settings, int i)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "structuresPreFiltered-" + i + ".sdf";
    }
    
//------------------------------------------------------------------------------
 
    static String getFragmentsFileName(FragmenterParameters settings, int i)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "Fragments-" + i + ".sdf";
    }
    
//------------------------------------------------------------------------------
 
    static String getFragmentsFileName(FragmenterParameters settings)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "Fragments.sdf";
    }
    
//------------------------------------------------------------------------------
 
    static String getResultsFileName(FragmenterParameters settings)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "Results.sdf";
    }
    
//------------------------------------------------------------------------------
 
    private static String getLogFileName(FragmenterParameters settings, int i)
    {
        return settings.getWorkDirectory() + DenoptimIO.FS 
                + "FragmenterTask-" + i + ".log";
    }
 
//------------------------------------------------------------------------------
    
    @Override
    public Object call() throws Exception
    {
        // Preliminary check for missing atoms by elemental analysis
        if (settings.doCheckFormula())
        {
            logger.log(Level.INFO,"Starting elemental analysis");
            File newResultsFile = new File(getConfirmedFormulaFileName(settings,
                    id));
            FragmenterTools.checkElementalAnalysisAgainstFormula(inputFile,
                    newResultsFile, logger);
            preliminaryResults = newResultsFile;
        } else {
            preliminaryResults = inputFile;
        }
 
        // Pre-fragmentation filter
        if (settings.doPreFilter())
        {
            logger.log(Level.INFO,"Pre-filtering structures");
            File newResultsFile = new File(getPreFilteredFileName(settings, id));
            FragmenterTools.filterStrucutresBySMARTS(inputFile, 
                    settings.getPreFiltrationSMARTS(), newResultsFile, logger);
            preliminaryResults = newResultsFile;
        }
 
        // Fragmentation of structures
        if (settings.doFragmentation())
        {
            logger.log(Level.INFO,"Fragmentation of structures");
            File newResultsFile = new File(getFragmentsFileName(settings, id));
            boolean producedSomething = FragmenterTools.fragmentation(inputFile, 
                    settings, newResultsFile,logger);
            if (!producedSomething)
            {
                completed = true;
                return null;
            }
            preliminaryResults = newResultsFile;
        }
        
        if (!settings.doFragmentation() && settings.doFiltering())
        {
            logger.log(Level.INFO,"Filtering fragments");
            File newResultsFile = new File(getFragmentsFileName(settings, id));
            FragmenterTools.manageFragmentCollection(inputFile, settings, 
                    newResultsFile, logger);
            preliminaryResults = newResultsFile;
        }
        
        // Final message
        results = preliminaryResults.getAbsolutePath();
        if (settings.getNumTasks()>1)
        {
            logger.log(Level.INFO,"Fragmenter task " + id + " completed.");
        } else {
            logger.log(Level.INFO,"Results available in "+results);
        }
        
        // We stop the logger's file handler to remove the lock file.
        for (Handler h : logger.getHandlers()) 
        {
            if (h instanceof FileHandler) {
                logger.removeHandler(h);
                h.close();
            }
        }
        
        completed = true;
        return results;
    }
 
//------------------------------------------------------------------------------
 
}