ParameterTreeItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Job/ParameterTreeItems.cpp
//! @brief     Implements classes for ParameterTreeItems
//!
//! @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/ParameterTreeItems.h"
#include "GUI/Model/Descriptor/VectorDescriptor.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Sample/MaterialItem.h"
#include "GUI/Model/Sample/MaterialItems.h"
#include "GUI/Support/XML/UtilXML.h"
#include "GUI/Util/DeserializationException.h"
#include "GUI/Util/Path.h"
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
 
namespace {
 
namespace Tags {
 
const QString BackupValues("BackupValues");
const QString BackupValue("BackupValue");
const QString Link("Link");
const QString Value("Value");
 
} // namespace Tags
 
ParameterItem* findParameterItem(QObject* item, const QString& link)
{
    ASSERT(item);
    if (auto* parameter = dynamic_cast<ParameterItem*>(item))
        if (parameter->link() == link)
            return parameter;
 
    for (auto* child : item->children())
        if (auto* p = findParameterItem(child, link))
            return p;
 
    return nullptr;
}
 
} // namespace
 
 
ParameterLabelItem::ParameterLabelItem(QObject* parent)
    : QObject(parent)
{
}
 
ParameterLabelItem::ParameterLabelItem(const QString& title, QObject* parent)
    : QObject(parent)
    , m_title(title)
{
}
 
QString ParameterLabelItem::title() const
{
    return m_title;
}
 
void ParameterLabelItem::setTitle(const QString& title)
{
    m_title = title;
}
 
ParameterItem::ParameterItem(QObject* parent)
    : QObject(parent)
{
}
 
// ----------------------------------------------------------------------------
 
 
QString ParameterItem::title() const
{
    return m_title;
}
 
void ParameterItem::setTitle(const QString& title)
{
    m_title = title;
}
 
double ParameterItem::valueOfLink() const
{
    return m_d.get();
}
 
//! Sets current value to the original PropertyItem of MultiLayerItem/InstrumentItem.
 
void ParameterItem::propagateValueToLink(double newValue)
{
    m_d.set(newValue);
}
 
void ParameterItem::linkToDescriptor(DoubleDescriptor d)
{
    m_link = d.path();
    m_d = d;
}
 
void ParameterItem::linkToSessionItem(SessionItem* item)
{
    m_link = GUI::Util::Path::getPathFromIndex(item->index());
    m_d = DoubleDescriptor(item, "");
}
 
RealLimits ParameterItem::limitsOfLink() const
{
    return m_d.limits;
}
 
int ParameterItem::decimalsOfLink() const
{
    return m_d.decimals;
}
 
QString ParameterItem::link() const
{
    return m_link;
}
 
QString ParameterItem::titleForFitItem() const
{
    QString result = m_title;
 
    auto* p = parent();
    while (p) {
        if (const auto* pLabel = dynamic_cast<ParameterLabelItem*>(p))
            result.push_front(pLabel->title() + "/");
        p = p->parent();
    }
 
    return result;
}
 
// ----------------------------------------------------------------------------
 
ParameterContainerItem::ParameterContainerItem()
{
    m_parameterTreeRoot.reset(new QObject());
}
 
void ParameterContainerItem::writeContentTo(QXmlStreamWriter* writer) const
{
    GUI::Session::XML::writeAttribute(writer, GUI::Session::XML::Version, int(1));
 
    writer->writeStartElement(Tags::BackupValues);
 
    for (auto v = m_backupValues.cbegin(); v != m_backupValues.cend(); v++) {
        writer->writeEmptyElement(Tags::BackupValue);
        GUI::Session::XML::writeAttribute(writer, Tags::Link, v.key());
        GUI::Session::XML::writeAttribute(writer, Tags::Value, v.value());
    }
    writer->writeEndElement();
}
 
void ParameterContainerItem::readContentFrom(QXmlStreamReader* reader)
{
    m_backupValues.clear();
    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().toString() == Tags::BackupValues) {
            while (reader->readNextStartElement()) {
                ASSERT(reader->name().toString() == Tags::BackupValue);
                QString link;
                double d;
                GUI::Session::XML::readAttribute(reader, Tags::Link, &link);
                GUI::Session::XML::readAttribute(reader, Tags::Value, &d);
                m_backupValues[link] = d;
                reader->skipCurrentElement();
            }
        }
    }
}
 
void ParameterContainerItem::setBackupValue(const QString& link, double d)
{
    m_backupValues[link] = d;
}
 
void ParameterContainerItem::restoreBackupValue(QObject* item)
{
    ASSERT(item);
    if (auto* parameter = dynamic_cast<ParameterItem*>(item))
        if (m_backupValues.contains(parameter->link()))
            parameter->propagateValueToLink(m_backupValues[parameter->link()]);
 
    for (auto* child : item->children())
        restoreBackupValue(child);
}
 
void ParameterContainerItem::restoreBackupValues()
{
    for (auto* child : m_parameterTreeRoot->children())
        restoreBackupValue(child);
}
 
ParameterItem* ParameterContainerItem::findParameterItem(const QString& link) const
{
    return ::findParameterItem(m_parameterTreeRoot.get(), link);
}
 
QObject* ParameterContainerItem::parameterTreeRoot()
{
    return m_parameterTreeRoot.get();
}