workerthread.cpp

/**
 * \file /gui/workerthread.cpp
 * \date 8/5/2017
 * \author Olivier Langella
 * \brief worker thread
 */

/*******************************************************************************
* Copyright (c) 2017 Olivier Langella <olivier.langella@u-psud.fr>.
*
* This file is part of XTPcpp.
*
*     XTPcpp is free software: you can redistribute it and/or modify
*     it under the terms of the GNU General Public License as published by
*     the Free Software Foundation, either version 3 of the License, or
*     (at your option) any later version.
*
*     XTPcpp 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 General Public License for more details.
*
*     You should have received a copy of the GNU General Public License
*     along with XTPcpp.  If not, see <http://www.gnu.org/licenses/>.
*
* Contributors:
*     Olivier Langella <olivier.langella@u-psud.fr> - initial API and implementation
******************************************************************************/

#include "workerthread.h"
#include <odsstream/odsdocwriter.h>
#include <pappsomspp/pappsoexception.h>
#include <QDebug>
#include "../output/masschroqml.h"
#include "../output/proticdbml.h"
#include "../output/ods/odsexport.h"
#include "files/xpipfile.h"
#include "mainwindow.h"
#include "project_view/projectwindow.h"
#include "../core/tandem_run/tandembatchprocess.h"
#include "../core/tandem_run/tandemcondorprocess.h"
#include <QSettings>

WorkerThread::WorkerThread(MainWindow * p_main_window)
{
    _p_main_window = p_main_window;
    qDebug() << "WorkerThread::WorkerThread begin MainWindow";

    _p_work_monitor = new WorkMonitor();

#if QT_VERSION >= 0x050000
    // Qt5 code
    //worker message
    connect(_p_work_monitor, &WorkMonitor::workerMessage, p_main_window,&MainWindow::doDisplayLoadingMessage);
    connect(_p_work_monitor, &WorkMonitor::workerMessagePercent, p_main_window,&MainWindow::doDisplayLoadingMessagePercent);
    connect(_p_work_monitor, &WorkMonitor::workerAppendText, p_main_window,&MainWindow::doWorkerAppendText);
    connect(_p_work_monitor, &WorkMonitor::workerSetText, p_main_window,&MainWindow::doWorkerSetText);
    connect(_p_work_monitor, &WorkMonitor::workerJobFinished, p_main_window,&MainWindow::doDisplayJobFinished);

    connect(p_main_window, &MainWindow::operateXpipFile, this,&WorkerThread::doXpipFileLoad);
    connect(this, &WorkerThread::projectReady, p_main_window,&MainWindow::doProjectReady);

    connect(p_main_window, &MainWindow::operateLoadingResults, this,&WorkerThread::doLoadingResults);

    connect(p_main_window, &MainWindow::operateRunningXtandem, this,&WorkerThread::doRunningXtandem);
    connect(this, &WorkerThread::loadingMessage, p_main_window,&MainWindow::doDisplayLoadingMessage);
    connect(this, &WorkerThread::projectNotReady, p_main_window,&MainWindow::doProjectNotReady);

    //grouping
    connect(p_main_window, &MainWindow::operateGrouping, this,&WorkerThread::doGrouping);
    connect(this, &WorkerThread::groupingFinished, p_main_window,&MainWindow::doGroupingFinished);
    //masschroq write
    connect(p_main_window, &MainWindow::operateWritingMassChroqFile, this,&WorkerThread::doWritingMassChroqFile);
    //protic write
    connect(p_main_window, &MainWindow::operateWritingProticFile, this,&WorkerThread::doWritingProticFile);
    //writing ODS file :
    connect(p_main_window, &MainWindow::operateWritingOdsFile, this,&WorkerThread::doWritingOdsFile);
    connect(this, &WorkerThread::operationFailed, p_main_window,&MainWindow::doOperationFailed);
    connect(this, &WorkerThread::operationFinished, p_main_window,&MainWindow::doOperationFinished);

#else
// Qt4 code
    //worker message
    connect(_p_work_monitor, SIGNAL(workerMessage(QString)), p_main_window,SLOT(doDisplayLoadingMessage(QString)));
    connect(_p_work_monitor, SIGNAL(workerMessage(QString, int)), p_main_window,SLOT(doDisplayLoadingMessage(QString, int)));
    connect(_p_work_monitor, SIGNAL(workerAppendText(char *)), p_main_window,SLOT(doWorkerAppendText(char *)));

    connect(p_main_window, SIGNAL(operateXpipFile(QString)), this,SLOT(doXpipFileLoad(QString)));
    connect(this, SIGNAL(projectReady(ProjectSp)), p_main_window,SLOT(doProjectReady(ProjectSp)));
    connect(p_main_window, SIGNAL(operateLoadingResults(bool,AutomaticFilterParameters,QStringList)), this,SLOT(doLoadingResults(bool,AutomaticFilterParameters,QStringList)));

    connect(p_main_window, SIGNAL(operateRunningXtandem(TandemRunBatch)), this,SLOT(doRunningXtandem(TandemRunBatch)));
    connect(this, SIGNAL(loadingMessage(QString)), p_main_window,SLOT(doDisplayLoadingMessage(QString)));
    connect(this, SIGNAL(projectNotReady(QString)), p_main_window,SLOT(doProjectNotReady(QString)));

    //grouping
    connect(p_main_window, SIGNAL(operateGrouping(ProjectSp)), this,SLOT(doGrouping(ProjectSp)));
    connect(this, SIGNAL(groupingFinished()), p_main_window,SLOT(doGroupingFinished()));
    //masschroq write
    connect(p_main_window, SIGNAL(operateWritingMassChroqFile(QString, ProjectSp)), this,SLOT(doWritingMassChroqFile(QString, ProjectSp)));
    //protic write
    connect(p_main_window, SIGNAL(operateWritingProticFile(QString,ProjectSp)), this,SLOT(doWritingProticFile(QString,ProjectSp)));
    //writing ODS file :
    connect(p_main_window, SIGNAL(operateWritingOdsFile(QString, ProjectSp)), this,SLOT(doWritingOdsFile(QString, ProjectSp)));
    connect(this, SIGNAL(operationFailed(QString)), p_main_window,SLOT(doOperationFailed(QString)));
    connect(this, SIGNAL(operationFinished()), p_main_window,SLOT(doOperationFinished()));
#endif

    qDebug() << "WorkerThread::WorkerThread end MainWindow";
}

WorkerThread::WorkerThread(ProjectWindow * p_project_window)
{
    qDebug() << "WorkerThread::WorkerThread begin ProjectWindow";

    _p_work_monitor = new WorkMonitor();

#if QT_VERSION >= 0x050000
    // Qt5 code

    //worker message
    connect(_p_work_monitor, &WorkMonitor::workerMessage, p_project_window,&ProjectWindow::doDisplayLoadingMessage);
    connect(_p_work_monitor, &WorkMonitor::workerMessagePercent, p_project_window,&ProjectWindow::doDisplayLoadingMessagePercent);
    connect(this, &WorkerThread::loadingMessage, p_project_window,&ProjectWindow::doDisplayLoadingMessage);
    //grouping
    connect(p_project_window, &ProjectWindow::operateGrouping, this,&WorkerThread::doGrouping);
    connect(this, &WorkerThread::groupingFinished, p_project_window,&ProjectWindow::doGroupingFinished);


    //PTM grouping on IdentificationGroup
    connect(p_project_window, &ProjectWindow::operatePtmGroupingOnIdentification, this,&WorkerThread::doPtmGroupingOnIdentification);
    connect(this, &WorkerThread::ptmGroupingOnIdentificationFinished, p_project_window,&ProjectWindow::refreshPtmGroup);

    //grouping on IdentificationGroup
    connect(p_project_window, &ProjectWindow::operateGroupingOnIdentification, this,&WorkerThread::doGroupingOnIdentification);
    connect(this, &WorkerThread::groupingOnIdentificationFinished, p_project_window,&ProjectWindow::refreshGroup);

    connect(this, &WorkerThread::operationFailed, p_project_window,&ProjectWindow::doOperationFailed);
    connect(this, &WorkerThread::operationFinished, p_project_window,&ProjectWindow::doOperationFinished);

#else
// Qt4 code
    qDebug() << "WorkerThread::WorkerThread Qt4 code";

    //worker message
    connect(_p_work_monitor, SIGNAL(workerMessage(QString)), p_project_window,SLOT(doDisplayLoadingMessage(QString)));
    connect(_p_work_monitor, SIGNAL(workerMessage(QString, int)), p_project_window,SLOT(doDisplayLoadingMessage(QString, int)));

    connect(this, SIGNAL(loadingMessage(QString)), p_project_window,SLOT(doDisplayLoadingMessage(QString)));
    //grouping
    connect(p_project_window, SIGNAL(operateGrouping(ProjectSp)), this,SLOT(doGrouping(ProjectSp)));
    connect(this, SIGNAL(groupingFinished()), p_project_window,SLOT(doGroupingFinished()));


    //PTM grouping on IdentificationGroup
    connect(p_project_window, SIGNAL(operatePtmGroupingOnIdentification(IdentificationGroup *)), this,SLOT(doPtmGroupingOnIdentification(IdentificationGroup *)));
    connect(this, SIGNAL(ptmGroupingOnIdentificationFinished(IdentificationGroup *)), p_project_window,SLOT(refreshPtmGroup(IdentificationGroup *)));

    //grouping on IdentificationGroup
    connect(p_project_window, SIGNAL(operateGroupingOnIdentification(IdentificationGroup *, GroupingType)), this,SLOT(doGroupingOnIdentification(IdentificationGroup *, GroupingType)));
    connect(this, SIGNAL(groupingOnIdentificationFinished(IdentificationGroup *)), p_project_window,SLOT(refreshGroup(IdentificationGroup *)));

    connect(this, SIGNAL(operationFailed(QString)), p_project_window,SLOT(doOperationFailed(QString)));
    connect(this, SIGNAL(operationFinished()), p_project_window,SLOT(doOperationFinished()));

#endif
    qDebug() << "WorkerThread::WorkerThread end ProjectWindow";
}

WorkerThread::~WorkerThread()
{
    qDebug() << "WorkerThread::WorkerThread destructor";
}

void WorkerThread::doXpipFileLoad(QString filename) {
    qDebug() << "WorkerThread::doXpipFileLoad begin "<< filename;
    try {
        QFileInfo new_xpip_file(filename);
        emit loadingMessage(tr("loading XPIP file"));
        qDebug() << "WorkerThread::doXpipFileLoad new_xpip_file "<< new_xpip_file.absoluteFilePath();
        XpipFile xpip_file(new_xpip_file);
        ProjectSp project_sp = xpip_file.getProjectSp(_p_work_monitor);

        emit projectReady(project_sp);

    }
    catch (pappso::PappsoException & error) {
        emit projectNotReady(tr("Error while reading XPIP file :\n%1").arg(error.qwhat()));
    }

    qDebug() << "WorkerThread::doXpipFileLoad end";
}

void WorkerThread::doPtmGroupingOnIdentification(IdentificationGroup * p_identification_group) {
    qDebug() << "WorkerThread::doPtmGroupingOnIdentification begin ";
    try {
        emit loadingMessage(tr("computing PTM islands"));
        try {
            p_identification_group->startPtmGrouping();

        }
        catch (pappso::PappsoException exception_pappso) {
            emit operationFailed(tr("Error computing PTM islands : %1").arg(exception_pappso.qwhat()));
        }
        catch (std::exception exception_std) {
            emit operationFailed(tr("Error computing PTM islands : %1").arg(exception_std.what()));
        }
        emit loadingMessage(tr("computing PTM islands finished"));
        emit ptmGroupingOnIdentificationFinished(p_identification_group);
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while computing PTM islands :\n%1").arg(error.qwhat()));
    }
    qDebug() << "WorkerThread::doPtmGroupingOnIdentification end ";
}

void WorkerThread::doGroupingOnIdentification(IdentificationGroup * p_identification_group, GroupingType grouping_type) {
    qDebug() << "WorkerThread::doGroupingOnIdentification begin ";
    try {
        emit loadingMessage(tr("grouping proteins"));
        try {
            p_identification_group->startGrouping(grouping_type, _p_work_monitor);

        }
        catch (pappso::PappsoException exception_pappso) {
            emit operationFailed(tr("Error grouping identification : %1").arg(exception_pappso.qwhat()));
        }
        catch (std::exception exception_std) {
            emit operationFailed(tr("Error grouping identification : %1").arg(exception_std.what()));
        }
        emit loadingMessage(tr("grouping proteins finished"));
        emit groupingOnIdentificationFinished(p_identification_group);
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while grouping :\n%1").arg(error.qwhat()));
    }
    qDebug() << "WorkerThread::doGroupingOnIdentification end ";
}
void WorkerThread::doGrouping(ProjectSp project_sp) {
    qDebug() << "WorkerThread::doGrouping begin ";
    try {
        emit loadingMessage(tr("grouping proteins"));
        try {
            project_sp.get()->startGrouping(_p_work_monitor);

        }
        catch (pappso::PappsoException exception_pappso) {
            emit operationFailed(tr("Error grouping project : %1").arg(exception_pappso.qwhat()));
        }
        catch (std::exception exception_std) {
            emit operationFailed(tr("Error grouping project : %1").arg(exception_std.what()));
        }
        emit loadingMessage(tr("grouping proteins finished"));
        emit groupingFinished();
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while grouping :\n%1").arg(error.qwhat()));
    }
    qDebug() << "WorkerThread::doGrouping end ";
}
void WorkerThread::doWritingOdsFile(QString filename, ProjectSp project_sp) {

    try {
        emit loadingMessage(tr("writing ODS file, please wait"));
        OdsDocWriter writer(filename);
        OdsExport export_ods(project_sp.get());
        export_ods.write(&writer, _p_work_monitor);
        writer.close();
        emit operationFinished();
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while writing ODS file :\n%1").arg(error.qwhat()));
    }
}


void WorkerThread::doWritingMassChroqFile(QString filename, ProjectSp project_sp) {

    try {
        emit loadingMessage(tr("writing MassChroqML file, please wait"));
        MassChroQml output(filename);
        output.write(project_sp);
        output.close();
        emit operationFinished();
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while writing MassChroqML file :\n%1").arg(error.qwhat()));
    }
}

void WorkerThread::doWritingProticFile(QString filename, ProjectSp project_sp) {

    try {
        emit loadingMessage(tr("writing PROTICdbML file, please wait"));
        ProticdbMl output(filename);
        output.write(project_sp);
        output.close();
        emit operationFinished();
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while writing PROTICdbML file :\n%1").arg(error.qwhat()));
    }
}

void WorkerThread::doLoadingResults(bool is_individual, AutomaticFilterParameters param, QStringList file_list) {

    qDebug() << "WorkerThread::doLoadingResults begin ";
    try {
        if (file_list.size() == 0) {
            throw pappso::PappsoException(QObject::tr("file list is empty"));
        }
        ProjectSp project_sp = Project().makeProjectSp();
        project_sp.get()->setCombineMode(!is_individual);

        _p_work_monitor->setProgressMaximumValue(file_list.size());
        int i=0;
        for (QString filename : file_list) {
            _p_work_monitor->message(tr("loading result file %1 (%2 on %3)").arg(filename).arg(i).arg(file_list.size()), i);
            project_sp.get()->readResultFile(filename);
            i++;
        }

        emit loadingMessage(tr("filtering proteins"));
        project_sp.get()->updateAutomaticFilters(param);
        qDebug() << "WorkerThread::doLoadingResults emit projectReady(project_sp) ";
        emit projectReady(project_sp);

    }
    catch (pappso::PappsoException & error) {
        qDebug() << "WorkerThread::doLoadingResults error ";
        emit projectNotReady(tr("Error while reading result files :\n%1").arg(error.qwhat()));
    }
    qDebug() << "WorkerThread::doLoadingResults end ";
}
void WorkerThread::doRunningXtandem(TandemRunBatch tandem_run_batch) {
    qDebug() << "WorkerThread::doRunningXtandem begin ";
    try {
        emit loadingMessage(tr("Running X!Tandem, please wait"));
        qDebug() <<  "WorkerThread::doRunningXtandem tandem_run_batch " << tandem_run_batch._tandem_bin_path;

        QSettings settings;
        bool use_htcondor = settings.value("tandem/use_HTCondor", "false").toBool();

        if (use_htcondor) {
           TandemCondorProcess xt_process (_p_main_window ,_p_work_monitor, tandem_run_batch);
            xt_process.run();
        }
        else {
            TandemBatchProcess xt_process (_p_main_window ,_p_work_monitor, tandem_run_batch);
            xt_process.run();
         }

        emit operationFinished();
    }
    catch (pappso::PappsoException & error) {
        emit operationFailed(tr("Error while running X!Tandem job :\n%1").arg(error.qwhat()));
    }
    qDebug() << "WorkerThread::doRunningXtandem end ";
}