RealDataItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Data/RealDataItem.cpp
//! @brief     Implements class RealDataItem
//!
//! @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/Data/RealDataItem.h"
#include "Device/Data/DataUtils.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Data/JobItemUtils.h"
#include "GUI/Model/Data/ProjectionItems.h"
#include "GUI/Model/Data/SpecularDataItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Device/MaskItems.h"
#include "GUI/Support/IO/AbstractDataLoader1D.h"
#include "GUI/Support/IO/DataLoaders1D.h"
#include "GUI/Support/IO/ImportDataInfo.h"
#include "GUI/Support/IO/ItemFileNameUtils.h"
#include "GUI/Util/DeserializationException.h"
#include "GUI/Util/Error.h"
 
RealDataItem::RealDataItem()
    : SessionItem(M_TYPE)
{
    setItemName("undefined");
 
    // Registering this tag even without actual data item to avoid troubles in copying RealDataItem
    registerTag(T_INTENSITY_DATA, 1, 1,
                QStringList() << IntensityDataItem::M_TYPE << SpecularDataItem::M_TYPE);
    setDefaultTag(T_INTENSITY_DATA);
 
    addProperty(P_INSTRUMENT_ID, QString());
 
    registerTag(T_NATIVE_DATA, 1, 1,
                QStringList() << IntensityDataItem::M_TYPE << SpecularDataItem::M_TYPE);
    addProperty(P_NATIVE_DATA_UNITS, "nbins");
}
 
QString RealDataItem::dataName() const
{
    return itemName();
}
 
void RealDataItem::setDataName(const QString& name)
{
    setItemName(name);
}
 
IntensityDataItem* RealDataItem::intensityDataItem()
{
    return dynamic_cast<IntensityDataItem*>(dataItem());
}
 
const IntensityDataItem* RealDataItem::intensityDataItem() const
{
    return dynamic_cast<const IntensityDataItem*>(dataItem());
}
 
SpecularDataItem* RealDataItem::specularDataItem()
{
    return dynamic_cast<SpecularDataItem*>(dataItem());
}
 
const SpecularDataItem* RealDataItem::specularDataItem() const
{
    return dynamic_cast<const SpecularDataItem*>(dataItem());
}
 
DataItem* RealDataItem::dataItem()
{
    return const_cast<DataItem*>(static_cast<const RealDataItem*>(this)->dataItem());
}
 
const DataItem* RealDataItem::dataItem() const
{
    return dynamic_cast<const DataItem*>(getItem(T_INTENSITY_DATA));
}
 
DataItem* RealDataItem::nativeData()
{
    return const_cast<DataItem*>(static_cast<const RealDataItem*>(this)->nativeData());
}
 
const DataItem* RealDataItem::nativeData() const
{
    return dynamic_cast<const DataItem*>(getItem(T_NATIVE_DATA));
}
 
void RealDataItem::initNativeData()
{
    const size_t rank = isSpecularData() ? 1 : 2;
    initDataItem(rank, T_NATIVE_DATA);
}
 
QString RealDataItem::nativeDataUnits() const
{
    return getItemValue(P_NATIVE_DATA_UNITS).toString();
}
 
void RealDataItem::setNativeDataUnits(const QString& units)
{
    getItem(P_NATIVE_DATA_UNITS)->setValue(units);
}
 
void RealDataItem::removeNativeData()
{
    ASSERT(isSpecularData()); // not implemented for intensityDataItem
 
    if (nativeData() != nullptr)
        nativeData()->setDatafield(nullptr);
}
 
bool RealDataItem::hasNativeData() const
{
    return (nativeData() != nullptr) && (nativeData()->getDatafield() != nullptr);
}
 
const Datafield* RealDataItem::nativeDatafield() const
{
    return hasNativeData() ? nativeData()->getDatafield() : nullptr;
}
 
//! takes ownership of data
 
void RealDataItem::setNativeDatafield(Datafield* data)
{
    nativeData()->setDatafield(data); // takes ownership of odata
}
 
//! Creates and inserts a data item except if such item with same tag already exists.
//! Checks for rank compatibility if already existing.
//! No further initialization (like clearing the data etc).
 
void RealDataItem::initDataItem(size_t rank, const QString& tag)
{
    ASSERT(rank == 1 || rank == 2);
 
    const auto* dataItem = dynamic_cast<const DataItem*>(getItem(tag));
    if (dataItem != nullptr) {
        if ((rank == 1 && !dynamic_cast<const SpecularDataItem*>(dataItem))
            || (rank == 2 && !dynamic_cast<const IntensityDataItem*>(dataItem)))
            throw Error("Error in RealDataItem::initDataItem: trying to set data "
                        "incompatible with underlying data item");
    } else {
        if (rank == 1)
            model()->insertItem<SpecularDataItem>(this, 0, tag);
        else
            model()->insertItem<IntensityDataItem>(this, 0, tag);
 
        ASSERT(getItem(tag)
               && "Assertion failed in RealDataItem::initDataItem: inserting data item failed.");
    }
}
 
//! Sets Datafield to underlying item. Creates it if not existing.
 
void RealDataItem::setDatafield(Datafield* data)
{
    ASSERT(data && "Assertion failed in RealDataItem::setDatafield: passed data is nullptr");
 
    initDataItem(data->rank(), T_INTENSITY_DATA);
 
    dataItem()->setDatafield(data);
}
 
//! Sets imported data to underlying item. Creates it if not existing.
//! This is used for 1D import. For 2D import, use setDatafield.
 
void RealDataItem::setImportData(ImportDataInfo info)
{
    if (!info)
        return;
 
    const size_t data_rank = info.dataRank();
    initDataItem(data_rank, T_INTENSITY_DATA);
    initDataItem(data_rank, T_NATIVE_DATA);
 
    QString units_name = info.unitsLabel();
    auto output_data = info.clonedData();
 
    dataItem()->reset(std::move(info));
    setNativeDataUnits(units_name);
    item<DataItem>(T_NATIVE_DATA)->setDatafield(output_data.release());
}
 
void RealDataItem::initAsSpecularItem()
{
    const size_t rank = 1;
    initDataItem(rank, T_INTENSITY_DATA);
}
 
void RealDataItem::initAsIntensityItem()
{
    const size_t rank = 2;
    initDataItem(rank, T_INTENSITY_DATA);
}
 
bool RealDataItem::holdsDimensionalData() const
{
    return nativeDataUnits() != "nbins";
}
 
QString RealDataItem::instrumentId() const
{
    return getItemValue(P_INSTRUMENT_ID).toString();
}
 
void RealDataItem::unlinkFromInstrument()
{
    setItemValue(P_INSTRUMENT_ID, QString());
    updateToInstrument(nullptr);
}
 
void RealDataItem::linkToInstrument(const InstrumentItem* instrument)
{
    if (instrument) {
        setItemValue(P_INSTRUMENT_ID, instrument->id());
        updateToInstrument(instrument);
    } else
        unlinkFromInstrument();
}
 
std::vector<int> RealDataItem::shape() const
{
    const auto* data_item = dataItem();
    if (!data_item) {
        ASSERT(data_item);
        return {};
    }
    return data_item->shape();
}
 
bool RealDataItem::isIntensityData() const
{
    return intensityDataItem() != nullptr;
}
 
bool RealDataItem::isSpecularData() const
{
    return specularDataItem() != nullptr;
}
 
bool RealDataItem::hasImportErrors() const
{
    return (dataLoader() != nullptr) ? dataLoader()->numErrors() > 0 : false;
}
 
MaskContainerItem* RealDataItem::maskContainerItem()
{
    if (auto* intensity_data = intensityDataItem())
        return intensity_data->maskContainerItem();
    return nullptr;
}
 
void RealDataItem::setNativeFileName(const QString& filename)
{
    m_nativeFileName = filename;
}
 
QString RealDataItem::nativeFileName() const
{
    return m_nativeFileName;
}
 
QByteArray RealDataItem::serializeBinaryData() const
{
    QByteArray a;
    QDataStream s(&a, QIODevice::WriteOnly);
    s.setVersion(QDataStream::Qt_5_12);
 
    s << (quint8)1; // version
    s << m_nativeFileName;
 
    if (m_dataLoader) {
        s << m_dataLoader->persistentClassName();
        s << *m_dataLoader;
    } else
        s << QString(); // empty loader class name => no loader present
 
    return a;
}
 
void RealDataItem::deserializeBinaryData(const QByteArray& data)
{
    m_nativeFileName.clear();
    m_importSettings.clear();
    m_dataLoader.release();
 
    QDataStream s(data);
    s.setVersion(QDataStream::Qt_5_12);
 
    quint8 version;
    s >> version;
 
    if (version == 1) {
        s >> m_nativeFileName;
        QString persistentLoaderClassName;
        s >> persistentLoaderClassName;
        if (!persistentLoaderClassName.isEmpty()) {
            setDataLoader(
                DataLoaders1D::instance().createFromPersistentName(persistentLoaderClassName));
            // #baUserDefLoaders ++ implement userdefined loaders (may require new version!)
            if (!m_dataLoader)
                throw DeserializationException::tooNew();
            s >> *m_dataLoader;
            m_dataLoader->setRealDataItem(this);
        }
    } else
        throw DeserializationException::tooNew();
 
    if (s.status() != QDataStream::Ok)
        throw DeserializationException::streamError();
}
 
void RealDataItem::setDataLoader(AbstractDataLoader* loader)
{
    m_dataLoader.reset(loader);
    if (m_dataLoader)
        connect(m_dataLoader.get(), &AbstractDataLoader::contentsProcessed, this,
                &RealDataItem::importContentsProcessed);
}
 
AbstractDataLoader* RealDataItem::dataLoader() const
{
    return m_dataLoader.get();
}
 
bool RealDataItem::rotationAffectsSetup() const
{
    if (!isIntensityData()) // rotation only for 2D items possible
        return false;
 
    const bool hasLinkToInstrument = !instrumentId().isEmpty();
    if (hasLinkToInstrument)
        return true;
 
    if (intensityDataItem()->hasMasks())
        return true;
 
    if (intensityDataItem()->hasProjections())
        return true;
 
    return false;
}
 
void RealDataItem::rotateData()
{
    if (!isIntensityData()) // rotation only for 2D items possible
        return;
 
    // -- first break instrument link, clear masks and projections
    unlinkFromInstrument();
 
    if (MaskContainerItem* maskContainer = intensityDataItem()->maskContainerItem())
        maskContainer->clear();
 
    if (ProjectionContainerItem* projectionsContainer =
            intensityDataItem()->projectionContainerItem())
        projectionsContainer->model()->removeRows(0, projectionsContainer->numberOfChildren(),
                                                  projectionsContainer->index());
 
    // -- now rotate data
    auto* const input = intensityDataItem()->getDatafield();
    intensityDataItem()->setDatafield(
        DataUtils::Data::createRearrangedDataSet(*input, 1).release());
    intensityDataItem()->setAxesRangeToData();
}
 
//! Updates the name of file to store intensity data.
 
void RealDataItem::updateNonXMLDataFileNames()
{
    if (DataItem* item = dataItem())
        item->setFileName(GUI::Model::FilenameUtils::realDataFileName(dataName()));
    if (DataItem* item = nativeData())
        item->setFileName(GUI::Model::FilenameUtils::nativeDataFileName(dataName()));
}
 
void RealDataItem::updateToInstrument(const InstrumentItem* instrument)
{
    DataItem* data_item = dataItem();
    if (!data_item)
        return;
 
    if (instrument) {
        GUI::Model::JobItemUtils::setIntensityItemCoords(data_item, instrument);
        if (dataItem())
            dataItem()->updateCoords(instrument);
        return;
    }
 
    // instrument == nullptr => unlinking => going back to native data
    if (isSpecularData()) {
        if (hasNativeData()) {
            std::unique_ptr<Datafield> native_data(nativeData()->getDatafield()->clone());
            const QString units_label = nativeDataUnits();
            data_item->reset(ImportDataInfo(std::move(native_data), units_label));
        } else {
            specularDataItem()->setDatafield(nullptr);
        }
    } else {
        auto* native_data_item = nativeData();
        auto* data_source = native_data_item ? native_data_item : data_item;
 
        std::unique_ptr<Datafield> native_data(data_source->getDatafield()->clone());
        const QString units_label = nativeDataUnits();
        data_item->reset(ImportDataInfo(std::move(native_data), units_label));
    }
}