JobModel.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Model/JobModel.cpp
//! @brief     Implements class JobModel
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Model/JobModel.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Device/PointwiseAxisItem.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Model/JobFunctions.h"
#include "GUI/Model/Model/JobQueueData.h"
#include "GUI/Model/Model/ParameterTreeUtils.h"
#include "GUI/Model/Model/SessionXML.h"
#include "GUI/Model/Sample/ItemWithMaterial.h"
#include "GUI/Model/Sample/MultiLayerItem.h"
 
JobModel::JobModel(QObject* parent)
    : SessionModel(GUI::Session::XML::JobModelTag, parent)
    , m_queue_data(nullptr)
{
    m_queue_data = new JobQueueData(this);
    connect(m_queue_data, &JobQueueData::focusRequest, this, &JobModel::focusRequest);
    connect(m_queue_data, &JobQueueData::globalProgress, this, &JobModel::globalProgress);
    setObjectName(GUI::Session::XML::JobModelTag);
}
JobModel::~JobModel()
{
    delete m_queue_data;
}
 
JobItem* JobModel::getJobItemForIdentifier(const QString& identifier)
{
    for (auto* jobItem : jobItems())
        if (jobItem->getIdentifier() == identifier)
            return jobItem;
 
    return nullptr;
}
 
//! Main method to add a job
JobItem* JobModel::addJob(const MultiLayerItem* sampleItem, const InstrumentItem* instrumentItem,
                          const RealDataItem* realDataItem, const SimulationOptionsItem& optionItem)
{
    ASSERT(sampleItem);
    ASSERT(instrumentItem);
 
    auto* jobItem = insertItem<JobItem>();
    jobItem->setItemName(generateJobName());
    jobItem->setIdentifier(QUuid::createUuid().toString());
 
    jobItem->copySampleIntoJob(sampleItem);
    GUI::Model::JobFunctions::setupJobItemInstrument(jobItem, instrumentItem);
 
    jobItem->copySimulationOptionsIntoJob(optionItem);
 
    ParameterTreeBuilder(jobItem, true).build();
 
    GUI::Model::JobFunctions::setupJobItemOutput(jobItem);
 
    if (realDataItem)
        GUI::Model::JobFunctions::setupJobItemForFit(jobItem, realDataItem);
 
    return jobItem;
}
 
QVector<JobItem*> JobModel::jobItems() const
{
    return topItems<JobItem>();
}
 
//! restore instrument and sample model from backup for given JobItem
void JobModel::restore(JobItem* jobItem)
{
    jobItem->parameterContainerItem()->restoreBackupValues();
}
 
bool JobModel::hasUnfinishedJobs()
{
    if (m_queue_data->hasUnfinishedJobs())
        return true;
 
    for (auto* jobItem : jobItems())
        if (jobItem->getStatus() == JobStatus::Fitting)
            return true;
 
    return false;
}
 
void JobModel::clear()
{
    for (auto* job : jobItems())
        removeJob(job);
 
    SessionModel::clear();
}
 
QVector<SessionItem*> JobModel::nonXMLItems() const
{
    QVector<SessionItem*> result;
 
    for (auto* jobItem : topItems<JobItem>()) {
        if (auto* intensityItem = jobItem->dataItem())
            result.push_back(intensityItem);
 
        if (auto* real_data = dynamic_cast<RealDataItem*>(jobItem->realDataItem())) {
            if (auto* data_item = real_data->dataItem())
                result.push_back(data_item);
            if (auto* native_data = real_data->nativeData())
                result.push_back(native_data);
        }
    }
 
    return result;
}
 
void JobModel::readFrom(QXmlStreamReader* reader, MessageService* messageService /*= 0*/)
{
    SessionModel::readFrom(reader, messageService);
 
    // Set & check instrument links. JobItem and realDataItem have to reference the same instrument
    // (which is the one contained in this job item, not contained in the instrument model)
    for (auto* jobItem : jobItems()) {
        if (RealDataItem* refItem = jobItem->realDataItem())
            refItem->linkToInstrument(jobItem->instrumentItem());
 
        // Create the not stored parameter tuning tree
        ParameterTreeBuilder(jobItem, false).build();
    }
}
 
void JobModel::runJob(JobItem* jobItem)
{
    m_queue_data->runJob(jobItem);
}
 
void JobModel::cancelJob(JobItem* jobItem)
{
    m_queue_data->cancelJob(jobItem->getIdentifier());
}
 
void JobModel::removeJob(JobItem* jobItem)
{
    ASSERT(jobItem);
    m_queue_data->removeJob(jobItem->getIdentifier());
 
    removeRows(jobItem->index().row(), 1, QModelIndex());
}
 
QString JobModel::generateJobName()
{
    int maxJobIndex = 0;
    for (const auto* jobItem : jobItems()) {
        if (jobItem->itemName().startsWith("job"))
            maxJobIndex = std::max(maxJobIndex, jobItem->itemName().mid(3).toInt());
    }
    return QString("job%1").arg(maxJobIndex + 1);
}