MaterialItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/MaterialItem.cpp
//! @brief     Implements class MaterialItem
//!
//! @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/Sample/MaterialItem.h"
#include "Base/Util/Assert.h"
#include "GUI/Model/Descriptor/VectorDescriptor.h"
#include "GUI/Support/XML/Serialize.h"
#include "GUI/Support/XML/UtilXML.h"
#include "GUI/Util/DeserializationException.h"
#include "Sample/Material/MaterialFactoryFuncs.h"
#include <QColor>
#include <QUuid>
#include <QXmlStreamReader>
 
namespace {
 
namespace Tags {
 
const QString Color("Color");
const QString Id("Id");
const QString Name("Name");
const QString Delta("Delta");
const QString Beta("Beta");
const QString Sld("Sld");
const QString Magnetization("Magnetization");
 
} // namespace Tags
 
} // namespace
 
#define m_delta std::get<Refractive>(m_data).delta
#define m_beta std::get<Refractive>(m_data).beta
 
#define m_real std ::get<complex_t>(m_data).real()
#define m_imag std ::get<complex_t>(m_data).imag()
 
MaterialItem::MaterialItem()
    : m_data(Refractive(0.0, 0.0))
{
    m_color = Qt::red;
    m_id = QUuid::createUuid().toString();
}
 
MaterialItem::MaterialItem(const MaterialItem& other)
    : QObject()
    , m_name(other.m_name)
    , m_id(other.m_id)
    , m_color(other.m_color)
    , m_data(other.m_data)
    , m_magnetization(other.m_magnetization)
{
}
 
void MaterialItem::setRefractiveIndex(const double delta, const double beta)
{
    const Refractive r(delta, beta);
    if (hasRefractiveIndex() && std::get<Refractive>(m_data) == r)
        return;
 
    m_data = r;
    emit dataChanged();
}
 
void MaterialItem::setScatteringLengthDensity(const complex_t sld)
{
    if (!hasRefractiveIndex() && std::get<complex_t>(m_data) == sld)
        return;
 
    m_data = sld;
    emit dataChanged();
}
 
DoubleDescriptor MaterialItem::delta()
{
    ASSERT(hasRefractiveIndex());
    const auto setter = [=](double v) {
        if (m_delta != v) {
            m_delta = v;
            emit dataChanged();
        }
    };
 
    DoubleDescriptor d(
        "Delta", "Delta of refractive index (n = 1 - delta + i*beta)", 3, RealLimits::limitless(),
        setter, [=] { return m_delta; }, Unit::unitless);
    d.path = [=] { return uidForDescriptor("delta"); };
    return d;
}
 
DoubleDescriptor MaterialItem::beta()
{
    ASSERT(hasRefractiveIndex());
    const auto setter = [=](double v) {
        if (m_beta != v) {
            m_beta = v;
            emit dataChanged();
        }
    };
 
    DoubleDescriptor d(
        "Beta", "Beta of refractive index (n = 1 - delta + i*beta)", 3, RealLimits::limitless(),
        setter, [=] { return m_beta; }, Unit::unitless);
    d.path = [=] { return uidForDescriptor("beta"); };
    return d;
}
 
DoubleDescriptor MaterialItem::sldRe()
{
    ASSERT(!hasRefractiveIndex());
    const auto setter = [=](double v) {
        if (m_real != v) {
            std::get<complex_t>(m_data).real(v);
            emit dataChanged();
        }
    };
 
    DoubleDescriptor d(
        "SLD, real", "Real part of SLD (SLD = real - i*imag), AA^{-2}", 3, RealLimits::limitless(),
        setter, [=] { return m_real; }, Unit::unitless);
    d.path = [=] { return uidForDescriptor("re"); };
    return d;
}
 
DoubleDescriptor MaterialItem::sldIm()
{
    ASSERT(!hasRefractiveIndex());
    const auto setter = [=](double v) {
        if (m_imag != v) {
            std::get<complex_t>(m_data).imag(v);
            emit dataChanged();
        }
    };
 
    DoubleDescriptor d(
        "SLD, imaginary", "Imaginary part of SLD (SLD = real - i*imag), AA^{-2}", 3,
        RealLimits::limitless(), setter, [=] { return m_imag; }, Unit::unitless);
    d.path = [=] { return uidForDescriptor("im"); };
    return d;
}
 
VectorDescriptor MaterialItem::magnetizationVector()
{
    VectorDescriptor d("Magnetization", "Magnetization (A/m)", "A/m");
 
    d.x.set = [=](double v) {
        if (m_magnetization.x() != v) {
            m_magnetization.setX(v);
            emit dataChanged();
        }
    };
    d.x.get = [=]() { return m_magnetization.x(); };
    d.x.path = [=] { return uidForDescriptor("mx"); };
 
    d.y.set = [=](double v) {
        if (m_magnetization.y() != v) {
            m_magnetization.setY(v);
            emit dataChanged();
        }
    };
    d.y.get = [=]() { return m_magnetization.y(); };
    d.y.path = [=] { return uidForDescriptor("my"); };
 
    d.z.set = [=](double v) {
        if (m_magnetization.z() != v) {
            m_magnetization.setZ(v);
            emit dataChanged();
        }
    };
    d.z.get = [=]() { return m_magnetization.z(); };
    d.z.path = [=] { return uidForDescriptor("mz"); };
    d.uid = [=] { return uidForDescriptor("magnetization"); };
    return d;
}
 
bool MaterialItem::hasRefractiveIndex() const
{
    return std::holds_alternative<Refractive>(m_data);
}
 
QString MaterialItem::matItemName() const
{
    return m_name;
}
 
void MaterialItem::setMatItemName(const QString& name)
{
    if (m_name != name) {
        m_name = name;
        emit dataChanged();
    }
}
 
QString MaterialItem::identifier() const
{
    return m_id;
}
 
void MaterialItem::setIdentifier(const QString& id)
{
    m_id = id;
    // no "emit dataChanged()" here
}
 
void MaterialItem::createNewIdentifier()
{
    m_id = QUuid::createUuid().toString();
    // no "emit dataChanged()" here
}
 
QColor MaterialItem::color() const
{
    return m_color;
}
 
void MaterialItem::setColor(const QColor& color)
{
    if (m_color != color) {
        m_color = color;
        emit dataChanged();
    }
}
 
R3 MaterialItem::magnetization() const
{
    return m_magnetization;
}
 
void MaterialItem::setMagnetization(const R3& magnetization)
{
    if (m_magnetization != magnetization) {
        m_magnetization = magnetization;
        emit dataChanged();
    }
}
 
std::unique_ptr<Material> MaterialItem::createMaterial() const
{
    if (hasRefractiveIndex())
        return std::make_unique<Material>(
            RefractiveMaterial(matItemName().toStdString(), m_delta, m_beta, m_magnetization));
 
    return std::make_unique<Material>(
        MaterialBySLD(matItemName().toStdString(), m_real, m_imag, m_magnetization));
}
 
void MaterialItem::writeContentTo(QXmlStreamWriter* writer) const
{
    GUI::Session::XML::writeAttribute(writer, GUI::Session::XML::Version, int(1));
 
    GUI::Session::XML::writeAttribute(writer, Tags::Id, m_id);
    GUI::Session::XML::writeAttribute(writer, Tags::Color, m_color);
    GUI::Session::XML::writeAttribute(writer, Tags::Name, m_name);
    GUI::Session::XML::writeAttribute(writer, Tags::Magnetization, m_magnetization);
 
    if (hasRefractiveIndex()) {
        GUI::Session::XML::writeAttribute(writer, Tags::Delta, m_delta);
        GUI::Session::XML::writeAttribute(writer, Tags::Beta, m_beta);
    } else
        GUI::Session::XML::writeAttribute(writer, Tags::Sld, std::get<complex_t>(m_data));
}
 
void MaterialItem::readContentFrom(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();
 
    GUI::Session::XML::readAttribute(reader, Tags::Id, &m_id);
    GUI::Session::XML::readAttribute(reader, Tags::Color, &m_color);
    GUI::Session::XML::readAttribute(reader, Tags::Name, &m_name);
    GUI::Session::XML::readAttribute(reader, Tags::Magnetization, &m_magnetization);
    if (reader->attributes().hasAttribute(Tags::Delta)) {
        double d, b;
        GUI::Session::XML::readAttribute(reader, Tags::Delta, &d);
        GUI::Session::XML::readAttribute(reader, Tags::Beta, &b);
        m_data = Refractive(d, b);
    } else {
        complex_t c;
        GUI::Session::XML::readAttribute(reader, Tags::Sld, &c);
        m_data = c;
    }
}
 
void MaterialItem::serialize(Streamer& s)
{
    bool hasRefractive = hasRefractiveIndex();
    double val1 = hasRefractiveIndex() ? delta() : sldRe();
    double val2 = hasRefractiveIndex() ? beta() : sldIm();
 
    s.assertVersion(0);
    Serialize::rwValue(s, "name", m_name);
    Serialize::rwValue(s, "id", m_id);
    Serialize::rwValue(s, "color", m_color);
    Serialize::rwValue(s, "magnetization", m_magnetization);
    Serialize::rwValue(s, "refr", hasRefractive);
    Serialize::rwValue(s, "val1", val1);
    Serialize::rwValue(s, "val2", val2);
 
    if (s.xmlReader()) {
        if (hasRefractive)
            m_data = Refractive(val1, val2);
        else
            m_data = complex_t(val1, val2);
    }
}
 
void MaterialItem::updateFrom(const MaterialItem& other)
{
    if (operator!=(other)) {
        m_name = other.m_name;
        m_color = other.m_color;
        m_data = other.m_data;
        m_magnetization = other.m_magnetization;
        emit dataChanged();
    }
}
 
QString MaterialItem::uidForDescriptor(const QString& lastPart) const
{
    return "material/" + identifier() + "/" + lastPart;
}
 
bool MaterialItem::operator!=(const MaterialItem& other) const
{
    return !operator==(other);
}
 
bool MaterialItem::operator==(const MaterialItem& other) const
{
    if (hasRefractiveIndex()) {
        if (std::get<Refractive>(m_data) != std::get<Refractive>(other.m_data))
            return false;
    } else if (std::get<complex_t>(m_data) != std::get<complex_t>(other.m_data))
        return false;
 
 
    return (m_id == other.m_id) && (m_name == other.m_name) && (m_color == other.m_color)
           && (m_magnetization == other.m_magnetization);
}