ParticleLayoutItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/ParticleLayoutItem.cpp
//! @brief     Implements class ParticleLayoutItem
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Sample/ParticleLayoutItem.h"
#include "GUI/Model/CatSample/InterferenceItemCatalog.h"
#include "GUI/Model/CatSample/ItemWithParticlesCatalog.h"
#include "GUI/Model/Sample/InterferenceItems.h"
#include "GUI/Model/Sample/Lattice2DItems.h"
#include "GUI/Model/Sample/MesoCrystalItem.h"
#include "GUI/Model/Sample/ParticleCompositionItem.h"
#include "GUI/Model/Sample/ParticleItem.h"
#include "GUI/Support/XML/Serialize.h"
 
ParticleLayoutItem::ParticleLayoutItem(const MaterialItems* materials)
    : m_materials(materials)
{
    m_ownDensity.init("Total particle density",
                      "Number of particles per area (particle surface density).\n "
                      "Should be defined for disordered and 1d-ordered particle collections.",
                      0.01, Unit::nanometerMinus2, 10, RealLimits::nonnegative(), "density");
    m_weight.init("Weight",
                  "Weight of this particle layout.\nShould be used when multiple layouts define "
                  "different domains in the sample.",
                  1.0, Unit::unitless, "weight");
 
    m_interference.init<InterferenceItemCatalog>("Interference function", "", "interference");
}
 
DoubleDescriptor ParticleLayoutItem::ownDensity() const
{
    return m_ownDensity;
}
 
DoubleDescriptor ParticleLayoutItem::totalDensity() const
{
    // create descriptor with same value as own density, then change the getter and setter
    DoubleDescriptor d = ownDensity();
    d.set = [=](double d) {
        if (!totalDensityIsDefinedByInterference())
            const_cast<DoubleProperty*>(&m_ownDensity)->set(d);
    };
    d.get = [=]() { return totalDensityValue(); };
    d.path = [=]() { return m_ownDensity.uid() + "/totalDensity"; };
    return d;
}
 
double ParticleLayoutItem::totalDensityValue() const
{
    if (!totalDensityIsDefinedByInterference())
        return m_ownDensity;
 
    ASSERT(m_interference.get());
 
    if (const auto* interLatticeItem =
            dynamic_cast<const Interference2DAbstractLatticeItem*>(m_interference.get())) {
        Lattice2DItem* latticeItem = interLatticeItem->latticeType().currentItem();
        try {
            const double area = latticeItem->unitCellArea();
            return area == 0.0 ? 0.0 : 1.0 / area;
        } catch (const std::exception&) {
            // nothing to do here; new exception will be caught during job execution
            return 0.0;
        }
    }
 
    if (const auto* hd = dynamic_cast<const InterferenceHardDiskItem*>(m_interference.get()))
        return hd->density();
 
    ASSERT(false);
}
 
DoubleDescriptor ParticleLayoutItem::weight() const
{
    return m_weight;
}
 
QVector<ItemWithParticles*> ParticleLayoutItem::particles() const
{
    return m_particles;
}
 
void ParticleLayoutItem::addParticle(ItemWithParticles* particle)
{
    m_particles << particle;
}
 
void ParticleLayoutItem::removeParticle(ItemWithParticles* particle)
{
    m_particles.removeAll(particle);
    delete particle;
}
 
QVector<ItemWithParticles*> ParticleLayoutItem::containedItemsWithParticles() const
{
    QVector<ItemWithParticles*> result;
    for (auto* p : m_particles)
        result << p << p->containedItemsWithParticles();
    return result;
}
 
SelectionDescriptor<InterferenceItem*> ParticleLayoutItem::interference() const
{
    return m_interference;
}
 
void ParticleLayoutItem::setInterference(InterferenceItem* interference)
{
    m_interference.set(interference);
}
 
void ParticleLayoutItem::removeInterference()
{
    m_interference.set(nullptr);
}
 
bool ParticleLayoutItem::totalDensityIsDefinedByInterference() const
{
    return dynamic_cast<const Interference2DAbstractLatticeItem*>(m_interference.get())
           || dynamic_cast<const InterferenceHardDiskItem*>(m_interference.get());
}
 
void ParticleLayoutItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_ownDensity);
    Serialize::rwProperty(s, m_weight);
    Serialize::rwSelected<InterferenceItemCatalog>(s, m_interference);
    Serialize::rwCatalogized<ItemWithParticlesCatalog>(s, "Particles", m_particles, m_materials);
}