RealSpaceBuilderUtils.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Realspace/RealSpaceBuilderUtils.cpp
//! @brief     Implements GUI::RealSpace::BuilderUtils namespace
//!
//! @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/RealSpaceBuilderUtils.h"
#include "Base/Const/Units.h"
#include "Base/Util/Assert.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Model/Sample/MesoCrystalItem.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/Particle3DContainer.h"
#include "GUI/View/Realspace/RealSpaceBuilder.h"
#include "GUI/View/Realspace/RealSpaceCanvas.h"
#include "GUI/View/Realspace/RealSpaceMesoCrystalUtils.h"
#include "GUI/View/Realspace/TransformTo3D.h"
#include "Resample/Particle/ReParticle.h"
#include "Sample/Particle/MesoCrystal.h"
#include "Sample/Particle/Particle.h"
#include "Sample/Particle/ParticleCoreShell.h"
 
namespace {
 
const double layerBorderWidth = 10.0;
 
const IFormFactor* getUnderlyingFormFactor(const IFormFactor* ff)
{
    // TRUE as long as ff is of ReParticle (or its derived) type
    while (dynamic_cast<const ReParticle*>(ff))
        ff = dynamic_cast<const ReParticle*>(ff)->formfactor_at_bottom();
    const auto* ffb = dynamic_cast<const IFormFactor*>(ff);
    ASSERT(ffb);
    return ffb;
}
 
R3 to_kvector(const QVector3D& origin)
{
    return R3(static_cast<double>(origin.x()), static_cast<double>(origin.y()),
              static_cast<double>(origin.z()));
}
 
} // namespace
 
 
GUI::RealSpace::BuilderUtils::BuilderUtils(
    std::function<QColor(const QString&)> fnColorFromMaterialName)
    : m_fnColorFromMaterialName(fnColorFromMaterialName)
{
    ASSERT(fnColorFromMaterialName);
}
 
// compute cumulative abundances of particles
QVector<double>
GUI::RealSpace::BuilderUtils::computeCumulativeAbundances(const ParticleLayoutItem& layoutItem)
{
    // Retrieving abundances of particles
    double total_abundance = 0.0;
    QVector<double> cumulative_abundances;
 
    for (auto* particle : layoutItem.particles()) {
        total_abundance += particle->abundance();
 
        cumulative_abundances.append(total_abundance);
    }
 
    return cumulative_abundances;
}
 
void GUI::RealSpace::BuilderUtils::populateParticlesAtLatticePositions(
    const std::vector<std::vector<double>>& lattice_positions,
    const std::vector<Particle3DContainer>& particle3DContainer_vector,
    GUI::RealSpace::Model* model, const SceneGeometry& sceneGeometry,
    const RealSpaceBuilder* builder3D)
{
    double layer_size = sceneGeometry.layerSize;
    double layer_thickness = sceneGeometry.topOrBottomLayerThickness;
 
    for (std::vector<double> position : lattice_positions) {
        // for random selection of particles based on their abundances
        double rand_num = (rand() / static_cast<double>(RAND_MAX)); // (between 0 and 1)
        int k = 0;
 
        for (const auto& particle3DContainer : particle3DContainer_vector) {
            if (rand_num <= particle3DContainer.cumulativeAbundance()) {
                // lattice position + location (TO BE ADDED)
                double pos_x = position[0];
                double pos_y = position[1];
                double pos_z = 0;
 
                if (std::abs(pos_x) <= layer_size - layerBorderWidth
                    && std::abs(pos_y) <= layer_size - layerBorderWidth
                    && std::abs(pos_z) <= layer_thickness) {
                    builder3D->populateParticleFromParticle3DContainer(
                        model, particle3DContainer,
                        QVector3D(static_cast<float>(position[0]), static_cast<float>(position[1]),
                                  static_cast<float>(0)));
                }
                break;
            }
            ++k;
        }
    }
}
 
// Implement Rotation of a 3D particle using parameters from IRotation Object
GUI::RealSpace::Vector3D
GUI::RealSpace::BuilderUtils::implementParticleRotationfromIRotation(const IRotation*& rotation)
{
    double alpha = 0.0;
    double beta = 0.0;
    double gamma = 0.0;
 
    if (const auto* rotX = dynamic_cast<const RotationX*>(rotation)) {
        beta = rotX->angle(); // about x-axis
    } else if (const auto* rotY = dynamic_cast<const RotationY*>(rotation)) {
        alpha = Units::deg2rad(90.0);
        beta = rotY->angle(); // about y-axis
        gamma = Units::deg2rad(-90.0);
    } else if (const auto* rotZ = dynamic_cast<const RotationZ*>(rotation)) {
        alpha = rotZ->angle(); // about z-axis
    } else if (const auto* rotEuler = dynamic_cast<const RotationEuler*>(rotation)) {
        alpha = rotEuler->alpha();
        beta = rotEuler->beta();
        gamma = rotEuler->gamma();
    }
    return GUI::RealSpace::Vector3D(static_cast<float>(alpha), static_cast<float>(beta),
                                    static_cast<float>(gamma));
}
 
void GUI::RealSpace::BuilderUtils::applyParticleTransformations(
    const Particle& particle, GUI::RealSpace::Particles::Particle& particle3D, const R3& origin)
{
    // rotation
    GUI::RealSpace::Vector3D particle_rotate;
    const IRotation* rotation = particle.rotation();
 
    if (rotation)
        particle_rotate = implementParticleRotationfromIRotation(rotation);
 
    // translation
    float x = static_cast<float>(particle.particlePosition().x());
    float y = static_cast<float>(particle.particlePosition().y());
    float z = static_cast<float>(particle.particlePosition().z());
    GUI::RealSpace::Vector3D position(x + static_cast<float>(origin.x()),
                                      y + static_cast<float>(origin.y()),
                                      z + static_cast<float>(origin.z()));
 
    // If the particle belongs to a particle composition, along with the particle's
    // intrinsic transformations, position() and rotation() methods also account for the
    // translation and rotation (if present) of the particle composition as the
    // particleComposition's decompose() method already does this
 
    particle3D.addTransform(particle_rotate, position);
}
 
void GUI::RealSpace::BuilderUtils::applyParticleCoreShellTransformations(
    const Particle& particle, GUI::RealSpace::Particles::Particle& particle3D,
    const ParticleCoreShell& particleCoreShell, const R3& origin)
{
    std::unique_ptr<Particle> P_clone(particle.clone()); // clone of the current particle
 
    // rotation
    GUI::RealSpace::Vector3D particle_rotate;
    const IRotation* rotationCoreShell = particleCoreShell.rotation();
 
    if (rotationCoreShell)
        P_clone->rotate(*rotationCoreShell);
 
    const IRotation* rotation = P_clone->rotation();
 
    if (rotation)
        particle_rotate = implementParticleRotationfromIRotation(rotation);
 
    // translation
    R3 positionCoreShell = particleCoreShell.particlePosition();
 
    P_clone->translate(positionCoreShell);
 
    GUI::RealSpace::Vector3D position(
        static_cast<float>(P_clone->particlePosition().x() + origin.x()),
        static_cast<float>(P_clone->particlePosition().y() + origin.y()),
        static_cast<float>(P_clone->particlePosition().z() + origin.z()));
 
    particle3D.transform(particle_rotate, position);
}
 
void GUI::RealSpace::BuilderUtils::applyParticleColor(
    const Particle& particle, GUI::RealSpace::Particles::Particle& particle3D, double alpha)
{
    // assign correct color to the particle from the knowledge of its material
    const Material* particle_material = particle.material();
    auto color =
        m_fnColorFromMaterialName(QString::fromStdString(particle_material->materialName()));
    color.setAlphaF(alpha);
    particle3D.color = color;
}
 
std::vector<Particle3DContainer>
GUI::RealSpace::BuilderUtils::particle3DContainerVector(const ParticleLayoutItem& layoutItem,
                                                        const QVector3D& origin)
{
    std::vector<Particle3DContainer> particle3DContainer_vector;
 
    double total_abundance = computeCumulativeAbundances(layoutItem).last();
 
    double cumulative_abundance = 0;
 
    for (auto* particleItem : layoutItem.particles()) {
        Particle3DContainer particle3DContainer;
 
        if (const auto* pItem = dynamic_cast<ParticleItem*>(particleItem)) {
            auto particle = pItem->createParticle();
            particle3DContainer = singleParticle3DContainer(*particle, total_abundance, origin);
        } else if (const auto* coreShellItem = dynamic_cast<ParticleCoreShellItem*>(particleItem)) {
            // If there is no CORE or SHELL to populate inside ParticleCoreShellItem
            if (!coreShellItem->core() || !coreShellItem->shell())
                continue;
            auto particleCoreShell = coreShellItem->createParticleCoreShell();
            particle3DContainer =
                particleCoreShell3DContainer(*particleCoreShell, total_abundance, origin);
        } else if (const auto* compositionItem =
                       dynamic_cast<ParticleCompositionItem*>(particleItem)) {
            // If there is no particle to populate inside ParticleCompositionItem
            if (!compositionItem->particles().empty())
                continue;
            auto particleComposition = compositionItem->createParticleComposition();
            particle3DContainer =
                particleComposition3DContainer(*particleComposition, total_abundance, origin);
        } else if (const auto* mesoCrystalItem = dynamic_cast<MesoCrystalItem*>(particleItem)) {
            // If there is no particle to populate inside MesoCrystalItem
            if (!mesoCrystalItem->basisParticle())
                continue;
            particle3DContainer = GUI::RealSpace::BuilderUtils::mesoCrystal3DContainer(
                *mesoCrystalItem, total_abundance, origin);
        }
 
        cumulative_abundance += particle3DContainer.cumulativeAbundance();
        particle3DContainer.setCumulativeAbundance(cumulative_abundance);
        particle3DContainer_vector.emplace_back(particle3DContainer);
    }
 
    return particle3DContainer_vector;
}
 
Particle3DContainer GUI::RealSpace::BuilderUtils::singleParticle3DContainer(
    const Particle& particle, double total_abundance, const QVector3D& origin)
{
    std::unique_ptr<Particle> P_clone(particle.clone()); // clone of the particle
 
    const IFormFactor* ff = getUnderlyingFormFactor(P_clone->formfactor_at_bottom());
 
    auto particle3D = GUI::View::TransformTo3D::createParticlefromFormfactor(ff);
    applyParticleTransformations(*P_clone, *particle3D, to_kvector(origin));
    applyParticleColor(*P_clone, *particle3D);
 
    Particle3DContainer singleParticle3DContainer;
    singleParticle3DContainer.addParticle(particle3D.release(), false);
    singleParticle3DContainer.setCumulativeAbundance(P_clone->abundance() / total_abundance);
    singleParticle3DContainer.setParticleType("Particle");
 
    return singleParticle3DContainer;
}
 
Particle3DContainer GUI::RealSpace::BuilderUtils::particleCoreShell3DContainer(
    const ParticleCoreShell& particleCoreShell, double total_abundance, const QVector3D& origin)
{
    // clone of the particleCoreShell
    std::unique_ptr<ParticleCoreShell> PCS_clone(particleCoreShell.clone());
 
    const auto* coreff = getUnderlyingFormFactor(PCS_clone->coreParticle()->formfactor_at_bottom());
    const auto* shellff =
        getUnderlyingFormFactor(PCS_clone->shellParticle()->formfactor_at_bottom());
 
    auto coreParticle3D = GUI::View::TransformTo3D::createParticlefromFormfactor(coreff);
    auto shellParticle3D = GUI::View::TransformTo3D::createParticlefromFormfactor(shellff);
 
    // core
    applyParticleCoreShellTransformations(*PCS_clone->coreParticle(), *coreParticle3D, *PCS_clone,
                                          to_kvector(origin));
    applyParticleColor(*PCS_clone->coreParticle(), *coreParticle3D);
 
    // shell (set an alpha value of 0.5 for transparency)
    applyParticleCoreShellTransformations(*PCS_clone->shellParticle(), *shellParticle3D, *PCS_clone,
                                          to_kvector(origin));
    applyParticleColor(*PCS_clone->shellParticle(), *shellParticle3D, 0.5);
 
    Particle3DContainer particleCoreShell3DContainer;
 
    particleCoreShell3DContainer.addParticle(coreParticle3D.release(), false); // index 0
    particleCoreShell3DContainer.addParticle(shellParticle3D.release(), true); // index 1
    particleCoreShell3DContainer.setCumulativeAbundance(PCS_clone->abundance() / total_abundance);
    particleCoreShell3DContainer.setParticleType("ParticleCoreShell");
 
    return particleCoreShell3DContainer;
}
 
Particle3DContainer GUI::RealSpace::BuilderUtils::particleComposition3DContainer(
    const ParticleComposition& particleComposition, double total_abundance, const QVector3D& origin)
{
    // clone of the particleComposition
    std::unique_ptr<ParticleComposition> PC_clone(particleComposition.clone());
 
    Particle3DContainer result;
 
    for (const auto& pc_particle : PC_clone->decompose()) {
        ASSERT(pc_particle);
        Particle3DContainer particle3DContainer;
        // no abundances are associated with the individual components of ParticleComposition
        if (const auto* p = dynamic_cast<const ParticleCoreShell*>(pc_particle.get())) {
            particle3DContainer = particleCoreShell3DContainer(*p, 1.0, origin);
        } else if (dynamic_cast<const MesoCrystal*>(pc_particle.get())) {
            // TODO: Implement method to populate MesoCrystal from CORE and NOT from MesoCrystalItem
            // as it is done currently in GUI::RealSpace::BuilderUtils::mesoCrystal3DContainer
            std::ostringstream ostr;
            ostr << "Sorry, MesoCrystal inside ParticleComposition not yet implemented";
            ostr << "\n\nStay tuned!";
            throw std::runtime_error(ostr.str());
        } else if (const auto* p = dynamic_cast<const Particle*>(pc_particle.get()))
            particle3DContainer = singleParticle3DContainer(*p, 1.0, origin);
        else
            ASSERT(0);
 
        // add particles from 3Dcontainer of core-shell/particle into result
        for (size_t i = 0; i < particle3DContainer.containerSize(); ++i) {
            result.addParticle(particle3DContainer.createParticle(i).release(),
                               particle3DContainer.particle3DBlend(i));
        }
    }
    // set the correct abundance for the entire ParticleComposition
    result.setCumulativeAbundance(PC_clone->abundance() / total_abundance);
    result.setParticleType("ParticleComposition");
    return result;
}
 
Particle3DContainer GUI::RealSpace::BuilderUtils::mesoCrystal3DContainer(
    const MesoCrystalItem& mesoCrystalItem, double total_abundance, const QVector3D& origin)
{
    RealSpaceMesoCrystal mesoCrystalUtils(&mesoCrystalItem, total_abundance, origin,
                                          m_fnColorFromMaterialName);
 
    Particle3DContainer mesoCrystal3DContainer = mesoCrystalUtils.populateMesoCrystal();
 
    return mesoCrystal3DContainer;
}