RealSpaceBuilder.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Realspace/RealSpaceBuilder.cpp
//! @brief     Implements class RealSpaceBuilder
//!
//! @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/View/Realspace/RealSpaceBuilder.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Model/Sample/InterferenceItems.h"
#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 "GUI/View/Realspace/IPositionBuilder.h"
#include "GUI/View/Realspace/Particle3DContainer.h"
#include "GUI/View/Realspace/RealSpaceBuilderUtils.h"
#include "GUI/View/Realspace/RealSpaceCanvas.h"
#include "GUI/View/Realspace/TransformTo3D.h"
#include "GUI/ba3d/model/model.h"
#include "Sample/Aggregate/Interferences.h"
#include "Sample/Particle/Particle.h"
#include "Sample/Particle/ParticleCoreShell.h"
 
namespace {
 
std::vector<std::vector<double>> generatePositions(const ParticleLayoutItem& layoutItem,
                                                   double layerSize, double density)
{
    auto* interferenceItem = layoutItem.interference().currentItem();
    if (interferenceItem) {
        auto interference = interferenceItem->createInterference();
 
        if (auto* p = dynamic_cast<Interference1DLattice*>(interference.get()))
            return Lattice1DPositionBuilder(p).generatePositions(layerSize, density);
 
        if (auto* p = dynamic_cast<Interference2DLattice*>(interference.get()))
            return Lattice2DPositionBuilder(p).generatePositions(layerSize, density);
 
        if (auto* p = dynamic_cast<Interference2DParaCrystal*>(interference.get()))
            return ParaCrystal2DPositionBuilder(p).generatePositions(layerSize, density);
 
        if (auto* p = dynamic_cast<InterferenceFinite2DLattice*>(interference.get()))
            return Finite2DLatticePositionBuilder(p).generatePositions(layerSize, density);
 
        if (auto* p = dynamic_cast<InterferenceRadialParaCrystal*>(interference.get()))
            return RadialParacrystalPositionBuilder(p).generatePositions(layerSize, density);
    }
 
    return RandomPositionBuilder().generatePositions(layerSize, density);
}
 
} // namespace
 
 
RealSpaceBuilder::RealSpaceBuilder(std::function<QColor(const QString&)> fnColorFromMaterialName)
{
    m_builderUtils = std::make_unique<RealSpace::BuilderUtils>(fnColorFromMaterialName);
}
 
void RealSpaceBuilder::populate(RealSpace::Model* model, ItemForRealSpace item,
                                const SceneGeometry& sceneGeometry,
                                const RealSpace::Camera::Position& cameraPosition) const
{
    // default value of cameraPosition is in RealSpaceBuilder.h
    model->defCamPos = cameraPosition;
 
    if (const auto* p = std::get_if<MultiLayerItem*>(&item))
        populateMultiLayer(model, **p, sceneGeometry);
    else if (const auto* p = std::get_if<LayerItem*>(&item))
        populateLayer(model, **p, sceneGeometry);
    else if (const auto* p = std::get_if<ParticleLayoutItem*>(&item))
        populateLayout(model, **p, sceneGeometry);
    else if (const auto* p = std::get_if<ItemWithParticles*>(&item))
        populateParticleFromParticleItem(model, **p);
}
 
void RealSpaceBuilder::populateMultiLayer(GUI::RealSpace::Model* model,
                                          const MultiLayerItem& mlayerItem,
                                          const SceneGeometry& sceneGeometry,
                                          const QVector3D&) const
{
    double total_height(0.0);
    int index(0);
    for (LayerItem* layer : mlayerItem.layers()) {
        bool isTopLayer = index == 0;
        populateLayer(model, *layer, sceneGeometry,
                      QVector3D(0, 0, static_cast<float>(-total_height)), isTopLayer);
 
        if (index != 0)
            total_height += GUI::View::TransformTo3D::visualLayerThickness(*layer, sceneGeometry);
 
        ++index;
    }
}
 
void RealSpaceBuilder::populateLayer(GUI::RealSpace::Model* model, const LayerItem& layerItem,
                                     const SceneGeometry& sceneGeometry, const QVector3D& origin,
                                     const bool isTopLayer) const
{
    auto layer = GUI::View::TransformTo3D::createLayer(layerItem, sceneGeometry, origin);
    if (layer && !isTopLayer)
        model->addBlend(layer.release());
 
    for (ParticleLayoutItem* layout : layerItem.layouts())
        populateLayout(model, *layout, sceneGeometry, origin);
}
 
void RealSpaceBuilder::populateLayout(GUI::RealSpace::Model* model,
                                      const ParticleLayoutItem& layoutItem,
                                      const SceneGeometry& sceneGeometry,
                                      const QVector3D& origin) const
{
    // If there is no particle to populate
    if (layoutItem.particles().empty())
        return;
 
    double layer_size = sceneGeometry.layerSize;
    double total_density = layoutItem.totalDensity();
 
    auto particle3DContainer_vector = m_builderUtils->particle3DContainerVector(layoutItem, origin);
 
    const auto latticePositions = generatePositions(layoutItem, layer_size, total_density);
    m_builderUtils->populateParticlesAtLatticePositions(
        latticePositions, particle3DContainer_vector, model, sceneGeometry, this);
}
 
void RealSpaceBuilder::populateParticleFromParticleItem(RealSpace::Model* model,
                                                        const ItemWithParticles& particleItem) const
{
    Particle3DContainer particle3DContainer;
    if (const auto* pItem = dynamic_cast<const ParticleItem*>(&particleItem)) {
        auto particle = pItem->createParticle();
        particle3DContainer = m_builderUtils->singleParticle3DContainer(*particle);
    } else if (const auto* particleCoreShellItem =
                   dynamic_cast<const ParticleCoreShellItem*>(&particleItem)) {
        // If there is no CORE or SHELL to populate inside ParticleCoreShellItem
        if (!particleCoreShellItem->core() || !particleCoreShellItem->shell())
            return;
        auto particleCoreShell = particleCoreShellItem->createParticleCoreShell();
        particle3DContainer = m_builderUtils->particleCoreShell3DContainer(*particleCoreShell);
    } else if (const auto* particleCompositionItem =
                   dynamic_cast<const ParticleCompositionItem*>(&particleItem)) {
        // If there is no particle to populate inside ParticleCompositionItem
        if (!particleCompositionItem->particles().empty())
            return;
        auto particleComposition = particleCompositionItem->createParticleComposition();
        particle3DContainer = m_builderUtils->particleComposition3DContainer(*particleComposition);
    } else if (const auto* mesoCrystalItem = dynamic_cast<const MesoCrystalItem*>(&particleItem)) {
        // If there is no particle to populate inside MesoCrystalItem
        if (!mesoCrystalItem->basisParticle())
            return;
        particle3DContainer = m_builderUtils->mesoCrystal3DContainer(*mesoCrystalItem);
    }
 
    populateParticleFromParticle3DContainer(model, particle3DContainer);
}
 
void RealSpaceBuilder::populateParticleFromParticle3DContainer(
    RealSpace::Model* model, const Particle3DContainer& particle3DContainer,
    const QVector3D& lattice_position) const
{
    if (particle3DContainer.containerSize()) {
        for (size_t i = 0; i < particle3DContainer.containerSize(); ++i) {
            auto particle3D = particle3DContainer.createParticle(i);
            particle3D->addTranslation(lattice_position);
            if (particle3D) {
                if (!particle3DContainer.particle3DBlend(i))
                    model->add(particle3D.release());
                else
                    model->addBlend(particle3D.release()); // use addBlend() for transparent object
            }
        }
    }
}