LayerItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/LayerItem.cpp
//! @brief     Implements class LayerItem
//!
//! @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/LayerItem.h"
#include "GUI/Model/Sample/MesoCrystalItem.h"
#include "GUI/Model/Sample/MultiLayerItem.h"
#include "GUI/Model/Sample/ParticleCompositionItem.h"
#include "GUI/Model/Sample/ParticleCoreShellItem.h"
#include "GUI/Model/Sample/ParticleItem.h"
#include "GUI/Model/Sample/ParticleLayoutItem.h"
#include <QColor>
 
namespace {
 
QVector<ItemWithMaterial*> layoutItemsWithMaterial(ParticleLayoutItem* layout)
{
    QVector<ItemWithMaterial*> result;
 
    QVector<ItemWithParticles*> itemsWithParticles{layout->particles()};
    while (!itemsWithParticles.empty()) {
        auto* item = itemsWithParticles.takeFirst();
        if (!item)
            continue;
 
        if (auto* p = dynamic_cast<ParticleCompositionItem*>(item))
            itemsWithParticles << p->particles();
        else if (auto* p = dynamic_cast<MesoCrystalItem*>(item))
            itemsWithParticles << p->basisParticle();
        else if (auto* p = dynamic_cast<ParticleItem*>(item))
            result << p;
        else if (auto* p = dynamic_cast<ParticleCoreShellItem*>(item)) {
            if (p->core())
                result << p->core();
            if (p->shell())
                result << p->shell();
        } else
            ASSERT(false);
    }
    return result;
}
 
} // namespace
 
LayerItem::LayerItem(const MaterialItems* materials)
    : ItemWithMaterial(materials)
{
    m_thickness.init("Thickness", "Thickness of the layer", 0.0, Unit::nanometer, 3,
                     RealLimits::lowerLimited(0.0), "thickness");
 
    m_numSlices.init("Number of slices",
                     "Number of horizontal slices.\n"
                     "Used for Average Layer Material calculations \n"
                     "when corresponding simulation option is set.",
                     1, Unit::unitless, RealLimits::lowerLimited(0.0), "slices");
 
    m_name = "Layer";
}
 
void LayerItem::setLayerName(const QString& name)
{
    m_name = name;
}
 
QString LayerItem::layerName() const
{
    return m_name;
}
 
QVector<ItemWithMaterial*> LayerItem::itemsWithMaterial()
{
    QVector<ItemWithMaterial*> result;
    result.push_back(this);
    for (auto* layout : layouts())
        result.append(layoutItemsWithMaterial(layout));
    return result;
}
 
QVector<ItemWithParticles*> LayerItem::itemsWithParticles() const
{
    QVector<ItemWithParticles*> result;
    for (auto* layout : layouts())
        result << layout->containedItemsWithParticles();
    return result;
}
 
DoubleDescriptor LayerItem::thickness() const
{
    return m_thickness;
}
 
SelectionDescriptor<LayerBasicRoughnessItem*> LayerItem::roughness()
{
    SelectionDescriptor<LayerBasicRoughnessItem*> d;
    d.label = "Top roughness";
    d.tooltip = "Roughness of top interface";
    d.options = QStringList{"No", "Basic"};
 
    d.currentIndexSetter = [=](int idx) {
        if (idx == 0)
            clearRoughness();
        else
            setBasicRoughness();
    };
 
    d.currentIndexGetter = [=]() { return m_topRoughness ? 1 : 0; };
    d.currentItem = [=] { return m_topRoughness.get(); };
    return d;
}
 
void LayerItem::setBasicRoughness()
{
    m_topRoughness.reset(new LayerBasicRoughnessItem);
}
 
void LayerItem::clearRoughness()
{
    m_topRoughness.reset();
}
 
UIntDescriptor LayerItem::numSlices() const
{
    return m_numSlices;
}
 
QVector<ParticleLayoutItem*> LayerItem::layouts() const
{
    return m_layouts;
}
 
ParticleLayoutItem* LayerItem::addLayout()
{
    m_layouts << new ParticleLayoutItem(m_materialItems);
    return m_layouts.back();
}
 
void LayerItem::removeLayout(ParticleLayoutItem* layout)
{
    m_layouts.removeAll(layout);
    delete layout;
}
 
QColor LayerItem::color() const
{
    return m_color;
}
 
void LayerItem::setColor(const QColor& color)
{
    m_color = color;
}
 
void LayerItem::setIsTopLayer(bool b)
{
    m_isTopLayer = b;
}
 
bool LayerItem::isTopLayer() const
{
    return m_isTopLayer;
}
 
void LayerItem::setIsBottomLayer(bool b)
{
    m_isBottomLayer = b;
}
 
bool LayerItem::isBottomLayer() const
{
    return m_isBottomLayer;
}
 
void LayerItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwValue(s, "Name", m_name);
    Serialize::rwValue(s, "Color", m_color);
    Serialize::rwValue(s, "MaterialIdentifier", m_materialIdentifier);
    Serialize::rwProperty(s, m_numSlices);
    Serialize::rwProperty(s, m_thickness);
    Serialize::rwOptional(s, "Roughness", m_topRoughness);
    Serialize::rwVector(s, "Layouts", m_layouts, m_materialItems);
}