MaterialItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/MaterialItems.cpp
//! @brief     Implements class MaterialItems
//!
//! @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/MaterialItems.h"
#include "Base/Util/Assert.h"
#include "GUI/Model/Sample/MaterialItem.h"
#include "GUI/Support/XML/Serialize.h"
#include <QColor>
#include <QUuid>
#include <random>
 
namespace {
 
QColor suggestMaterialColor(const QString& name)
{
    if (name.contains("Vacuum"))
        return QColor(179, 242, 255);
    if (name.contains("Substrate"))
        return QColor(205, 102, 0);
    if (name.contains("Default"))
        return QColor(Qt::green);
    if (name.contains("Particle"))
        return QColor(146, 198, 255);
 
    // return a random color
    static std::random_device r;
    std::default_random_engine re(r());
    std::uniform_int_distribution<int> ru(0, 255);
 
    return QColor(ru(re), ru(re), ru(re));
}
 
} // namespace
 
 
MaterialItems::MaterialItems(QObject* parent)
    : QObject(parent)
{
}
 
MaterialItems::~MaterialItems()
{
    clear();
}
 
void MaterialItems::clear()
{
    qDeleteAll(m_materialItems);
    m_materialItems.clear();
}
 
void MaterialItems::addMaterial(MaterialItem* material)
{
    addMaterial(material, true);
}
 
void MaterialItems::addMaterial(MaterialItem* material, bool signalAdding)
{
    ASSERT(material);
    material->disconnect(this);
    m_materialItems << material;
    connect(material, &MaterialItem::dataChanged, this, [=] { emit materialChanged(material); });
 
    if (signalAdding)
        emit materialAddedOrRemoved();
}
 
MaterialItems* MaterialItems::createCopy() const
{
    auto* result = new MaterialItems();
 
    for (const auto* m : m_materialItems)
        result->addMaterial(new MaterialItem(*m));
 
    return result;
}
 
MaterialItem* MaterialItems::addRefractiveMaterial(const QString& name, double delta, double beta)
{
    auto* materialItem = new MaterialItem();
    materialItem->setMatItemName(name);
    materialItem->setColor(suggestMaterialColor(name));
    materialItem->setRefractiveIndex(delta, beta);
    addMaterial(materialItem);
 
    return materialItem;
}
 
MaterialItem* MaterialItems::addSLDMaterial(const QString& name, double sld, double abs_term)
{
    auto* materialItem = new MaterialItem();
    materialItem->setMatItemName(name);
    materialItem->setColor(suggestMaterialColor(name));
    materialItem->setScatteringLengthDensity(complex_t(sld, abs_term));
    addMaterial(materialItem);
 
    return materialItem;
}
 
MaterialItem* MaterialItems::materialFromName(const QString& name) const
{
    for (auto* materialItem : m_materialItems)
        if (materialItem->matItemName() == name)
            return materialItem;
 
    return nullptr;
}
 
MaterialItem* MaterialItems::materialFromIdentifier(const QString& identifier) const
{
    for (auto* materialItem : m_materialItems)
        if (materialItem->identifier() == identifier)
            return materialItem;
 
    return nullptr;
}
 
MaterialItem* MaterialItems::insertCopy(const MaterialItem& material)
{
    auto* newMaterial = new MaterialItem(material);
    newMaterial->createNewIdentifier();
    newMaterial->setMatItemName(material.matItemName() + " (copy)");
    addMaterial(newMaterial);
 
    return newMaterial;
}
 
const QVector<MaterialItem*>& MaterialItems::materialItems() const
{
    return m_materialItems;
}
 
MaterialItem* MaterialItems::defaultMaterial() const
{
    ASSERT(!materialItems().isEmpty());
    return materialItems().front();
}
 
void MaterialItems::removeMaterial(const QString& identifier)
{
    removeMaterial(materialFromIdentifier(identifier));
}
 
void MaterialItems::removeMaterial(MaterialItem* materialItem)
{
    m_materialItems.removeAll(materialItem);
    delete materialItem;
    emit materialAddedOrRemoved();
}
 
void MaterialItems::serialize(Streamer& s)
{
    if (s.xmlReader())
        clear();
    s.assertVersion(0);
    Serialize::rwVector(s, "MaterialItems", m_materialItems);
}
 
void MaterialItems::initFrom(const MaterialItems& from)
{
    // update existing to new contents (do not delete and recreate to keep references valid)
    for (auto* destItem : m_materialItems)
        if (auto* fromItem = from.materialFromIdentifier(destItem->identifier()))
            destItem->updateFrom(*fromItem);
 
    bool anyAddedOrRemoved = false;
 
    // remove non-existing
    auto* iter = m_materialItems.begin();
    while (iter != m_materialItems.end())
        if (!from.materialFromIdentifier((*iter)->identifier())) {
            delete *iter;
            iter = m_materialItems.erase(iter);
            anyAddedOrRemoved = true;
        } else
            iter++;
 
    // copy new ones
    for (const auto* m : from.materialItems())
        if (!materialFromIdentifier(m->identifier())) {
            addMaterial(new MaterialItem(*m), false);
            anyAddedOrRemoved = true;
        }
 
    // copy order
    QVector<MaterialItem*> tmp;
    for (const auto* m : from.materialItems())
        tmp << materialFromIdentifier(m->identifier());
    m_materialItems = tmp;
 
    if (anyAddedOrRemoved)
        emit materialAddedOrRemoved();
}
 
bool MaterialItems::operator==(const MaterialItems& other) const
{
    if (m_materialItems.size() != other.m_materialItems.size())
        return false;
 
    for (int i = 0; i < m_materialItems.size(); i++)
        if (*m_materialItems[i] != *other.m_materialItems[i])
            return false;
 
    return true;
}
 
bool MaterialItems::operator!=(const MaterialItems& other) const
{
    return !operator==(other);
}