JobItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Job/JobItem.cpp
//! @brief     Implements class JobItem
//!
//! @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/Job/JobItem.h"
#include "Base/Util/Assert.h"
#include "GUI/Model/CatDevice/InstrumentItemCatalog.h"
#include "GUI/Model/Data/Data1DViewItem.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Data/JobItemUtils.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Data/SpecularDataItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Job/FitSuiteItem.h"
#include "GUI/Model/Sample/ItemWithMaterial.h"
#include "GUI/Support/IO/ItemFileNameUtils.h"
#include "GUI/Support/XML/Streamer.h"
#include "GUI/Support/XML/UtilXML.h"
#include "GUI/Util/DeserializationException.h"
#include "GUI/Util/Error.h"
 
namespace {
namespace Tags {
 
const QString SimulationOptions("SimulationOptions");
const QString Materials("Materials");
const QString ParameterContainer("ParameterContainer");
const QString Sample("Sample");
const QString Instrument("Instrument");
 
} // namespace Tags
} // namespace
 
JobItem::JobItem()
    : SessionItem(M_TYPE)
{
    setItemName(M_TYPE);
    addProperty(P_IDENTIFIER, QString());
    addProperty(P_INSTRUMENT_NAME, QString())->setEditable(false);
    addProperty(P_WITH_FITTING, false);
 
    addProperty(P_STATUS, jobStatusToString(JobStatus::Idle))->setEditable(false);
 
    addProperty(P_BEGIN_TIME, QString())->setEditable(false);
    addProperty(P_END_TIME, QString())->setEditable(false);
 
    addProperty(P_COMMENTS, QString());
    addProperty(P_PROGRESS, 0);
    addProperty(P_PRESENTATION_TYPE, QVariant::Type::Invalid);
 
    registerTag(T_OUTPUT, 1, 1, {IntensityDataItem::M_TYPE, SpecularDataItem::M_TYPE});
    registerTag(T_REALDATA, 1, 1, {RealDataItem::M_TYPE});
    registerTag(T_DATAVIEW, 1, 1, {Data1DViewItem::M_TYPE});
 
    registerTag(T_FIT_SUITE, 1, 1, {FitSuiteItem::M_TYPE});
}
 
JobItem::~JobItem()
{
    emit jobDestroyed();
}
 
QString JobItem::getIdentifier() const
{
    return getItemValue(P_IDENTIFIER).toString();
}
 
void JobItem::setIdentifier(const QString& identifier)
{
    setItemValue(P_IDENTIFIER, identifier);
    emit jobIdentifierChanged(identifier);
}
 
QString JobItem::jobName() const
{
    return itemName();
}
 
void JobItem::setJobName(const QString& name)
{
    setItemName(name);
    updateIntensityDataFileName();
    emit jobNameChanged(name);
}
 
IntensityDataItem* JobItem::intensityDataItem()
{
    return dynamic_cast<IntensityDataItem*>(getItem(T_OUTPUT));
}
 
DataItem* JobItem::dataItem()
{
    return dynamic_cast<DataItem*>(getItem(T_OUTPUT));
}
 
JobStatus JobItem::getStatus() const
{
    return jobStatusFromString(getItemValue(P_STATUS).toString());
}
 
void JobItem::setStatus(const JobStatus status)
{
    setItemValue(P_STATUS, jobStatusToString(status));
    if (status == JobStatus::Failed) {
        if (DataItem* intensityItem = dataItem()) {
            if (intensityItem->getDatafield())
                intensityItem->getDatafield()->setAllTo(0.0);
            emit intensityItem->emitDataChanged();
        }
    }
    emit jobStatusChanged(status);
}
 
bool JobItem::isIdle() const
{
    return getStatus() == JobStatus::Idle;
}
 
bool JobItem::isRunning() const
{
    return getStatus() == JobStatus::Running;
}
 
bool JobItem::isCompleted() const
{
    return getStatus() == JobStatus::Completed;
}
 
bool JobItem::isCanceled() const
{
    return getStatus() == JobStatus::Canceled;
}
 
bool JobItem::isFailed() const
{
    return getStatus() == JobStatus::Failed;
}
 
bool JobItem::isFitting() const
{
    return getStatus() == JobStatus::Fitting;
}
 
bool JobItem::isValidForFitting()
{
    return isTag(T_REALDATA) && getItem(T_REALDATA);
}
 
QDateTime JobItem::beginTime() const
{
    return QDateTime::fromString(getItemValue(P_BEGIN_TIME).toString(), Qt::ISODateWithMs);
}
 
void JobItem::setBeginTime(const QDateTime& begin_time)
{
    setItemValue(P_BEGIN_TIME, begin_time.toString(Qt::ISODateWithMs));
    emit jobBeginTimeChanged(begin_time);
}
 
QDateTime JobItem::endTime() const
{
    return QDateTime::fromString(getItemValue(P_END_TIME).toString(), Qt::ISODateWithMs);
}
 
void JobItem::setEndTime(const QDateTime& end_time)
{
    setItemValue(P_END_TIME, end_time.toString(Qt::ISODateWithMs));
    emit jobEndTimeChanged(end_time);
}
 
std::optional<size_t> JobItem::duration() const
{
    QDateTime begin_time = beginTime();
    QDateTime end_time = endTime();
    if (begin_time.isValid() && end_time.isValid() && begin_time < end_time)
        return begin_time.msecsTo(end_time);
    return std::nullopt;
}
 
QString JobItem::getComments() const
{
    return getItemValue(P_COMMENTS).toString();
}
 
void JobItem::setComments(const QString& comments)
{
    setItemValue(P_COMMENTS, comments);
    emit jobCommentsChanged(comments);
}
 
int JobItem::getProgress() const
{
    return getItemValue(P_PROGRESS).toInt();
}
 
void JobItem::setProgress(int progress)
{
    setItemValue(P_PROGRESS, progress);
    emit jobProgressChanged(progress);
}
 
bool JobItem::runImmediately() const
{
    return simulationOptionsItem().runImmediately();
}
 
bool JobItem::runInBackground() const
{
    return simulationOptionsItem().runInBackground();
}
 
MultiLayerItem* JobItem::sampleItem()
{
    return &m_sampleItem;
}
 
MultiLayerItem* JobItem::copySampleIntoJob(const MultiLayerItem* sample)
{
    m_sampleItem.initFrom(sample);
    return &m_sampleItem;
}
 
InstrumentItem* JobItem::instrumentItem() const
{
    return m_instrument.get();
}
 
Instrument2DItem* JobItem::instrument2DItem()
{
    auto* result = dynamic_cast<Instrument2DItem*>(m_instrument.get());
    ASSERT(result);
    return result;
}
 
InstrumentItem* JobItem::copyInstrumentIntoJob(const InstrumentItem* instrument)
{
    m_instrument.reset(instrument->createCopy());
    return m_instrument.get();
}
 
void JobItem::setResults(const SimulationResult& result)
{
    GUI::Model::JobItemUtils::setResults(dataItem(), result);
    updateIntensityDataFileName();
}
 
FitSuiteItem* JobItem::fitSuiteItem()
{
    return dynamic_cast<FitSuiteItem*>(getItem(T_FIT_SUITE));
}
 
FitSuiteItem* JobItem::createFitSuiteItem()
{
    if (getItem(T_FIT_SUITE))
        throw Error("JobItem::createFitSuiteItem() -> Error. Attempt to create "
                    "a second FitSuiteItem.");
 
    return model()->insertItem<FitSuiteItem>(this, -1, T_FIT_SUITE);
}
 
ParameterContainerItem* JobItem::parameterContainerItem()
{
    return const_cast<ParameterContainerItem*>(
        static_cast<const JobItem*>(this)->parameterContainerItem());
}
 
const ParameterContainerItem* JobItem::parameterContainerItem() const
{
    return &m_parameterContainer;
}
 
FitParameterContainerItem* JobItem::fitParameterContainerItem()
{
    if (FitSuiteItem* item = fitSuiteItem())
        return item->fitParameterContainerItem();
 
    return nullptr;
}
 
RealDataItem* JobItem::realDataItem()
{
    return dynamic_cast<RealDataItem*>(getItem(JobItem::T_REALDATA));
}
 
RealDataItem* JobItem::copyRealDataIntoJob(const RealDataItem* real_data)
{
    return model()->copyItem(real_data, this, T_REALDATA);
}
 
RealDataItem* JobItem::createRealDataItem()
{
    return model()->insertItem<RealDataItem>(this, -1, T_REALDATA);
}
 
Data1DViewItem* JobItem::dataItemView()
{
    return dynamic_cast<Data1DViewItem*>(getItem(JobItem::T_DATAVIEW));
}
 
void JobItem::addDataViewItem(Data1DViewItem* data_view)
{
    insertChild(-1, data_view, T_DATAVIEW);
}
 
Data1DViewItem* JobItem::createDataViewItem()
{
    return model()->insertItem<Data1DViewItem>(this, -1, T_DATAVIEW);
}
 
QString JobItem::sampleName() const
{
    return m_sampleItem.sampleName();
}
 
QString JobItem::instrumentName() const
{
    return getItemValue(P_INSTRUMENT_NAME).toString();
}
 
void JobItem::setInstrumentName(const QString& name)
{
    setItemValue(P_INSTRUMENT_NAME, name);
    emit jobInstrumentNameChanged(name);
}
 
QString JobItem::presentationType() const
{
    return getItemValue(P_PRESENTATION_TYPE).toString();
}
 
void JobItem::setPresentationType(const QString& type)
{
    setItemValue(P_PRESENTATION_TYPE, type);
    emit jobPresentationTypeChanged(type);
}
 
void JobItem::writeNonSessionItems(QXmlStreamWriter* writer) const
{
    GUI::Session::XML::writeAttribute(writer, GUI::Session::XML::Version, int(1));
 
    writer->writeStartElement(Tags::SimulationOptions);
    m_simulationOptionsItem.writeContentTo(writer);
    writer->writeEndElement();
 
    Streamer(writer).write<InstrumentItemCatalog>(Tags::Instrument, m_instrument.get());
 
    writer->writeStartElement(Tags::Sample);
    m_sampleItem.writeContentTo(writer);
    writer->writeEndElement();
 
    writer->writeStartElement(Tags::ParameterContainer);
    m_parameterContainer.writeContentTo(writer);
    writer->writeEndElement();
}
 
void JobItem::readNonSessionItems(QXmlStreamReader* reader)
{
    const int version = reader->attributes().value(GUI::Session::XML::Version).toInt();
 
    if (version < 1)
        throw DeserializationException::tooOld();
 
    if (version > 1)
        throw DeserializationException::tooNew();
 
    while (reader->readNextStartElement()) {
        if (reader->name() == Tags::SimulationOptions) {
            m_simulationOptionsItem.readContentFrom(reader);
            GUI::Session::XML::gotoEndElementOfTag(reader, Tags::SimulationOptions);
        } else if (reader->name() == Tags::Instrument) {
            InstrumentItem* p = nullptr;
            Streamer(reader).read<InstrumentItemCatalog>(Tags::Instrument, p);
            m_instrument.reset(p);
        } else if (reader->name() == Tags::ParameterContainer) {
            m_parameterContainer.readContentFrom(reader);
            GUI::Session::XML::gotoEndElementOfTag(reader, Tags::ParameterContainer);
        } else if (reader->name() == Tags::Sample) {
            m_sampleItem.readContentFrom(reader);
            GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Sample);
        }
    }
}
 
bool JobItem::isSpecularJob() const
{
    return instrumentItem()->is<SpecularInstrumentItem>();
}
 
//! Updates the name of file to store intensity data.
 
void JobItem::updateIntensityDataFileName()
{
    if (DataItem* item = dataItem())
        item->setFileName(GUI::Model::FilenameUtils::jobResultsFileName(itemName()));
 
    if (RealDataItem* realItem = realDataItem()) {
        if (DataItem* item = realItem->dataItem())
            item->setFileName(GUI::Model::FilenameUtils::jobReferenceFileName(itemName()));
 
        if (DataItem* item = realItem->nativeData())
            item->setFileName(GUI::Model::FilenameUtils::jobNativeDataFileName(getIdentifier()));
    }
}
 
const SimulationOptionsItem& JobItem::simulationOptionsItem() const
{
    return m_simulationOptionsItem;
}
 
void JobItem::copySimulationOptionsIntoJob(const SimulationOptionsItem& options)
{
    m_simulationOptionsItem = options;
}