ItemizeSample.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/FromCore/ItemizeSample.cpp
//! @brief     Implements class GUISampleBuilder
//!
//! @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/FromCore/ItemizeSample.h"
#include "Base/Const/Units.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Model/Sample/LayerItem.h"
#include "GUI/Model/Sample/MaterialItem.h"
#include "GUI/Model/Sample/MaterialItems.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/Util/Error.h"
#include "Param/Node/NodeUtils.h"
#include "Sample/Aggregate/Interferences.h"
#include "Sample/Aggregate/ParticleLayout.h"
#include "Sample/HardParticle/HardParticles.h"
#include "Sample/Interface/LayerInterface.h"
#include "Sample/Interface/LayerRoughness.h"
#include "Sample/Multilayer/Layer.h"
#include "Sample/Multilayer/MultiLayer.h"
#include "Sample/Particle/Crystal.h"
#include "Sample/Particle/MesoCrystal.h"
#include "Sample/Particle/Particle.h"
#include "Sample/Particle/ParticleCoreShell.h"
#include "Sample/Scattering/Rotations.h"
 
using NodeUtils::ChildNodesOfType;
using NodeUtils::OnlyChildOfType;
 
namespace {
 
void setPDF1D(InterferenceRadialParaCrystalItem* item, const IProfile1D* ipdf)
{
    if (const auto* pdf = dynamic_cast<const Profile1DCauchy*>(ipdf)) {
        auto* pdfItem = new Profile1DCauchyItem();
        pdfItem->omega().set(pdf->omega());
        item->setPDFType(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DGauss*>(ipdf)) {
        auto* pdfItem = new Profile1DGaussItem();
        pdfItem->omega().set(pdf->omega());
        item->setPDFType(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DGate*>(ipdf)) {
        auto* pdfItem = new Profile1DGateItem();
        pdfItem->omega().set(pdf->omega());
        item->setPDFType(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DTriangle*>(ipdf)) {
        auto* pdfItem = new Profile1DTriangleItem();
        pdfItem->omega().set(pdf->omega());
        item->setPDFType(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DCosine*>(ipdf)) {
        auto* pdfItem = new Profile1DCosineItem();
        pdfItem->omega().set(pdf->omega());
        item->setPDFType(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DVoigt*>(ipdf)) {
        auto* pdfItem = new Profile1DVoigtItem();
        pdfItem->omega().set(pdf->omega());
        pdfItem->eta().set(pdf->eta());
        item->setPDFType(pdfItem);
    } else
        throw Error("GUI::Transform::FromCore::setPDF1D: -> Error");
}
 
// note: SetterPDF(1|2)Type are needed because template template parameter must be classes
 
template <class T>
struct SetterPDF1Type {
    T* operator()(Interference2DParaCrystalItem* item)
    {
        auto* p = new T();
        item->setPDF1Type(p);
        return p;
    }
};
 
template <class T>
struct SetterPDF2Type {
    T* operator()(Interference2DParaCrystalItem* item)
    {
        auto* p = new T();
        item->setPDF2Type(p);
        return p;
    }
};
 
template <template <class T> class setType>
void setPDF2D(Interference2DParaCrystalItem* item, const IProfile2D* pdf)
{
    if (const auto* pdf_cauchy = dynamic_cast<const Profile2DCauchy*>(pdf)) {
        Profile2DCauchyItem* pdfItem = setType<Profile2DCauchyItem>()(item);
        pdfItem->setOmegaX(pdf_cauchy->omegaX());
        pdfItem->setOmegaY(pdf_cauchy->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_cauchy->gamma()));
    } else if (const auto* pdf_gauss = dynamic_cast<const Profile2DGauss*>(pdf)) {
        Profile2DGaussItem* pdfItem = setType<Profile2DGaussItem>()(item);
        pdfItem->setOmegaX(pdf_gauss->omegaX());
        pdfItem->setOmegaY(pdf_gauss->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_gauss->gamma()));
    } else if (const auto* pdf_gate = dynamic_cast<const Profile2DGate*>(pdf)) {
        Profile2DGateItem* pdfItem = setType<Profile2DGateItem>()(item);
        pdfItem->setOmegaX(pdf_gate->omegaX());
        pdfItem->setOmegaY(pdf_gate->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_gate->gamma()));
    } else if (const auto* pdf_cone = dynamic_cast<const Profile2DCone*>(pdf)) {
        Profile2DConeItem* pdfItem = setType<Profile2DConeItem>()(item);
        pdfItem->setOmegaX(pdf_cone->omegaX());
        pdfItem->setOmegaY(pdf_cone->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_cone->gamma()));
    } else if (const auto* pdf_voigt = dynamic_cast<const Profile2DVoigt*>(pdf)) {
        Profile2DVoigtItem* pdfItem = setType<Profile2DVoigtItem>()(item);
        pdfItem->setOmegaX(pdf_voigt->omegaX());
        pdfItem->setOmegaY(pdf_voigt->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_voigt->gamma()));
        pdfItem->setEta(pdf_voigt->eta());
    } else
        throw Error("GUI::Transform::FromCore::setPDF2D: -> Error");
}
 
void setDecayFunction1D(Interference1DLatticeItem* item, const IProfile1D* ipdf)
{
    if (const auto* pdf = dynamic_cast<const Profile1DCauchy*>(ipdf)) {
        auto* pdfItem = new Profile1DCauchyItem();
        pdfItem->omega().set(pdf->omega());
        item->setDecayFunction(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DGauss*>(ipdf)) {
        auto* pdfItem = new Profile1DGaussItem();
        pdfItem->omega().set(pdf->omega());
        item->setDecayFunction(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DTriangle*>(ipdf)) {
        auto* pdfItem = new Profile1DTriangleItem();
        pdfItem->omega().set(pdf->omega());
        item->setDecayFunction(pdfItem);
    } else if (const auto* pdf = dynamic_cast<const Profile1DVoigt*>(ipdf)) {
        auto* pdfItem = new Profile1DVoigtItem();
        pdfItem->omega().set(pdf->omega());
        pdfItem->eta().set(pdf->eta());
        item->setDecayFunction(pdfItem);
    } else
        throw Error("GUI::Transform::FromCore::setDecayFunction1D: -> Error");
}
 
void setDecayFunction2D(Interference2DLatticeItem* item, const IProfile2D* pdf)
{
    if (const auto* pdf_cauchy = dynamic_cast<const Profile2DCauchy*>(pdf)) {
        auto* pdfItem = new Profile2DCauchyItem();
        pdfItem->setOmegaX(pdf_cauchy->omegaX());
        pdfItem->setOmegaY(pdf_cauchy->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_cauchy->gamma()));
        item->setDecayFunctionType(pdfItem);
    } else if (const auto* pdf_gauss = dynamic_cast<const Profile2DGauss*>(pdf)) {
        auto* pdfItem = new Profile2DGaussItem();
        pdfItem->setOmegaX(pdf_gauss->omegaX());
        pdfItem->setOmegaY(pdf_gauss->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_gauss->gamma()));
        item->setDecayFunctionType(pdfItem);
    } else if (const auto* pdf_voigt = dynamic_cast<const Profile2DVoigt*>(pdf)) {
        auto* pdfItem = new Profile2DVoigtItem();
        pdfItem->setOmegaX(pdf_voigt->omegaX());
        pdfItem->setOmegaY(pdf_voigt->omegaY());
        pdfItem->setGamma(Units::rad2deg(pdf_voigt->gamma()));
        pdfItem->setEta(pdf_voigt->eta());
        item->setDecayFunctionType(pdfItem);
    } else
        throw Error("GUI::Transform::FromCore::setDecayFunction2D: -> Error");
}
 
void set2DLatticeParameters(Interference2DAbstractLatticeItem* item, const Lattice2D& lattice)
{
    Lattice2DItem* latticeItem(nullptr);
    if (lattice.className() == "SquareLattice2D") {
        auto* squareLatticeItem = new SquareLattice2DItem();
        squareLatticeItem->setLatticeLength(lattice.length1());
        latticeItem = squareLatticeItem;
    } else if (lattice.className() == "HexagonalLattice2D") {
        auto* hexLatticeItem = new HexagonalLattice2DItem();
        hexLatticeItem->setLatticeLength(lattice.length1());
        latticeItem = hexLatticeItem;
    } else {
        auto* basicLatticeItem = new BasicLattice2DItem();
        basicLatticeItem->setLatticeLength1(lattice.length1());
        basicLatticeItem->setLatticeLength2(lattice.length2());
        basicLatticeItem->setLatticeAngle(Units::rad2deg(lattice.latticeAngle()));
        latticeItem = basicLatticeItem;
    }
    latticeItem->setLatticeRotationAngle(Units::rad2deg(lattice.rotationAngle()));
    item->setLatticeType(latticeItem);
}
 
void setPositionVariance(InterferenceItem* item, const IInterference& iff)
{
    double pos_var = iff.positionVariance();
    item->positionVariance().set(pos_var);
}
 
template <typename T>
T* addFormFactorItem(std::variant<ParticleItem*, MesoCrystalItem*> parent)
{
    if (std::holds_alternative<ParticleItem*>(parent))
        return std::get<ParticleItem*>(parent)->setFormFactorType<T>();
 
    return std::get<MesoCrystalItem*>(parent)->setOuterShapeType<T>();
}
 
void set1DLatticeItem(Interference1DLatticeItem* item, const Interference1DLattice& sample)
{
    item->length().set(sample.length());
    item->rotationAngle().set(Units::rad2deg(sample.xi()));
 
    const auto* pdf = OnlyChildOfType<IProfile1D>(sample);
    setDecayFunction1D(item, pdf);
    setPositionVariance(item, sample);
}
 
void set2DLatticeItem(Interference2DLatticeItem* item, const Interference2DLattice& sample)
{
    set2DLatticeParameters(item, sample.lattice());
 
    item->setXiIntegration(sample.integrationOverXi());
 
    const auto* p_pdf = OnlyChildOfType<IProfile2D>(sample);
    setDecayFunction2D(item, p_pdf);
    setPositionVariance(item, sample);
}
 
void set2DParaCrystalItem(Interference2DParaCrystalItem* item,
                          const Interference2DParaCrystal& sample)
{
    set2DLatticeParameters(item, sample.lattice());
 
    item->setDampingLength(sample.dampingLength());
    item->setDomainSize1(sample.domainSizes()[0]);
    item->setDomainSize2(sample.domainSizes()[1]);
    item->setXiIntegration(sample.integrationOverXi());
 
    auto pdfs = ChildNodesOfType<IProfile2D>(sample);
 
    if (!pdfs.empty()) {
        setPDF2D<SetterPDF1Type>(item, pdfs[0]);
        if (pdfs.size() >= 2)
            setPDF2D<SetterPDF2Type>(item, pdfs[1]);
    }
    setPositionVariance(item, sample);
}
 
void setFinite2DLatticeItem(InterferenceFinite2DLatticeItem* item,
                            const InterferenceFinite2DLattice& sample)
{
    set2DLatticeParameters(item, sample.lattice());
 
    item->setDomainSize1(sample.numberUnitCells1());
    item->setDomainSize2(sample.numberUnitCells2());
    item->setXiIntegration(sample.integrationOverXi());
    setPositionVariance(item, sample);
}
 
void setHardDiskItem(InterferenceHardDiskItem* item, const InterferenceHardDisk& sample)
{
    item->radius().set(sample.radius());
    item->density().set(sample.density());
    setPositionVariance(item, sample);
}
 
void setRadialParaCrystalItem(InterferenceRadialParaCrystalItem* item,
                              const InterferenceRadialParaCrystal& sample)
{
    item->peakDistance().set(sample.peakDistance());
    item->dampingLength().set(sample.dampingLength());
    item->domainSize().set(sample.domainSize());
    item->kappa().set(sample.kappa());
 
    const auto* ipdf = OnlyChildOfType<IProfile1D>(sample);
    setPDF1D(item, ipdf);
    setPositionVariance(item, sample);
}
 
//! Returns true if given roughness is non-zero roughness
bool isValidRoughness(const LayerRoughness* roughness)
{
    if (!roughness)
        return false;
    if (roughness->sigma() == 0 && roughness->hurst() == 0.0
        && roughness->lateralCorrLength() == 0.0)
        return false;
    return true;
}
 
void setRoughnessItem(LayerBasicRoughnessItem* item, const LayerRoughness& sample)
{
    item->sigma().set(sample.sigma());
    item->hurst().set(sample.hurst());
    item->lateralCorrelationLength().set(sample.lateralCorrLength());
}
 
void setLayerItem(LayerItem* layerItem, const Layer* layer, const LayerInterface* top_interface)
{
    layerItem->thickness().set(layer->thickness());
    layerItem->clearRoughness();
    layerItem->numSlices().set(layer->numberOfSlices());
 
    if (top_interface) {
        const LayerRoughness* roughness = top_interface->roughness();
        if (isValidRoughness(roughness)) {
            layerItem->setBasicRoughness();
            setRoughnessItem(layerItem->roughness().currentItem(), *roughness);
        }
    }
}
 
void setRotation(ItemWithParticles* item, const IRotation* rotation)
{
    if (!rotation)
        item->setRotation(nullptr);
    else if (const auto* r = dynamic_cast<const RotationX*>(rotation)) {
        auto* rotationItem = new XRotationItem();
        rotationItem->angle().set(Units::rad2deg(r->angle()));
        item->setRotation(rotationItem);
    } else if (const auto* r = dynamic_cast<const RotationY*>(rotation)) {
        auto* rotationItem = new YRotationItem();
        rotationItem->angle().set(Units::rad2deg(r->angle()));
        item->setRotation(rotationItem);
    } else if (const auto* r = dynamic_cast<const RotationZ*>(rotation)) {
        auto* rotationItem = new ZRotationItem();
        rotationItem->angle().set(Units::rad2deg(r->angle()));
        item->setRotation(rotationItem);
    } else if (const auto* r = dynamic_cast<const RotationEuler*>(rotation)) {
        auto* rotationItem = new EulerRotationItem();
        rotationItem->alpha().set(Units::rad2deg(r->alpha()));
        rotationItem->beta().set(Units::rad2deg(r->beta()));
        rotationItem->gamma().set(Units::rad2deg(r->gamma()));
        item->setRotation(rotationItem);
    }
}
 
void setInterference(ParticleLayoutItem* layoutItem, const IInterference* interference)
{
    if (!interference)
        layoutItem->removeInterference();
    else if (const auto* itf = dynamic_cast<const Interference1DLattice*>(interference)) {
        auto* itfItem = new Interference1DLatticeItem();
        set1DLatticeItem(itfItem, *itf);
        layoutItem->setInterference(itfItem);
    } else if (const auto* itf = dynamic_cast<const Interference2DLattice*>(interference)) {
        auto* itfItem = new Interference2DLatticeItem();
        set2DLatticeItem(itfItem, *itf);
        layoutItem->setInterference(itfItem);
    } else if (const auto* itf = dynamic_cast<const Interference2DParaCrystal*>(interference)) {
        auto* itfItem = new Interference2DParaCrystalItem();
        set2DParaCrystalItem(itfItem, *itf);
        layoutItem->setInterference(itfItem);
    } else if (const auto* itf = dynamic_cast<const InterferenceFinite2DLattice*>(interference)) {
        auto* itfItem = new InterferenceFinite2DLatticeItem();
        setFinite2DLatticeItem(itfItem, *itf);
        layoutItem->setInterference(itfItem);
    } else if (const auto* itf = dynamic_cast<const InterferenceHardDisk*>(interference)) {
        auto* itfItem = new InterferenceHardDiskItem();
        setHardDiskItem(itfItem, *itf);
        layoutItem->setInterference(itfItem);
    } else if (const auto* itf = dynamic_cast<const InterferenceRadialParaCrystal*>(interference)) {
        auto* itfItem = new InterferenceRadialParaCrystalItem();
        setRadialParaCrystalItem(itfItem, *itf);
        layoutItem->setInterference(itfItem);
    } else
        ASSERT(false); // missing implementation for interference type
}
 
void setFormFactor(std::variant<ParticleItem*, MesoCrystalItem*> parent,
                   const IFormFactor* iFormFactor)
{
    if (const auto* formfactor = dynamic_cast<const Pyramid2*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Pyramid2Item>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
    } else if (const auto* formfactor = dynamic_cast<const BarGauss*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<BarGaussItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const BarLorentz*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<BarLorentzItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Box*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<BoxItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Cone*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<ConeItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
    } else if (const auto* formfactor = dynamic_cast<const Pyramid6*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Pyramid6Item>(parent);
        formfactorItem->setBaseEdge(formfactor->baseEdge());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
    } else if (const auto* formfactor = dynamic_cast<const Bipyramid4*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Bipyramid4Item>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setHeightRatio(formfactor->heightRatio());
        formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
    } else if (const auto* formfactor = dynamic_cast<const Cylinder*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<CylinderItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Dodecahedron*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<DodecahedronItem>(parent);
        formfactorItem->setEdge(formfactor->edge());
    } else if (const auto* formfactor = dynamic_cast<const EllipsoidalCylinder*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<EllipsoidalCylinderItem>(parent);
        formfactorItem->setRadiusX(formfactor->radiusX());
        formfactorItem->setRadiusY(formfactor->radiusY());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Sphere*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<SphereItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
    } else if (const auto* formfactor = dynamic_cast<const Spheroid*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<SpheroidItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Icosahedron*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<IcosahedronItem>(parent);
        formfactorItem->setEdge(formfactor->edge());
    } else if (const auto* formfactor = dynamic_cast<const HemiEllipsoid*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<HemiEllipsoidItem>(parent);
        formfactorItem->setRadiusX(formfactor->radiusX());
        formfactorItem->setRadiusY(formfactor->radiusY());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Prism3*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Prism3Item>(parent);
        formfactorItem->setBaseEdge(formfactor->baseEdge());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Prism6*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Prism6Item>(parent);
        formfactorItem->setBaseEdge(formfactor->baseEdge());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const Pyramid4*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Pyramid4Item>(parent);
        formfactorItem->setBaseEdge(formfactor->baseEdge());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
    } else if (const auto* formfactor = dynamic_cast<const CosineRippleBox*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<CosineRippleBoxItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const CosineRippleGauss*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<CosineRippleGaussItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const CosineRippleLorentz*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<CosineRippleLorentzItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
    } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleBox*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<SawtoothRippleBoxItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAsymmetry(formfactor->asymmetry());
    } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleGauss*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<SawtoothRippleGaussItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAsymmetry(formfactor->asymmetry());
    } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleLorentz*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<SawtoothRippleLorentzItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setWidth(formfactor->width());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAsymmetry(formfactor->asymmetry());
    } else if (const auto* formfactor = dynamic_cast<const Pyramid3*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<Pyramid3Item>(parent);
        formfactorItem->setBaseEdge(formfactor->baseEdge());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
    } else if (const auto* formfactor = dynamic_cast<const TruncatedCube*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<TruncatedCubeItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setRemovedLength(formfactor->removedLength());
    } else if (const auto* formfactor = dynamic_cast<const TruncatedSphere*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<TruncatedSphereItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setRemovedTop(formfactor->removedTop());
    } else if (const auto* formfactor = dynamic_cast<const TruncatedSpheroid*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<TruncatedSpheroidItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
        formfactorItem->setHeight(formfactor->height());
        formfactorItem->setHeightFlattening(formfactor->heightFlattening());
        formfactorItem->setRemovedTop(formfactor->removedTop());
    } else if (const auto* formfactor = dynamic_cast<const CantellatedCube*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<CantellatedCubeItem>(parent);
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setRemovedLength(formfactor->removedLength());
    } else if (const auto* formfactor = dynamic_cast<const HorizontalCylinder*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<HorizontalCylinderItem>(parent);
        formfactorItem->setRadius(formfactor->radius());
        formfactorItem->setLength(formfactor->length());
        formfactorItem->setSliceBottom(formfactor->slice_bottom());
        formfactorItem->setSliceTop(formfactor->slice_top());
    } else if (const auto* formfactor = dynamic_cast<const PlatonicOctahedron*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<PlatonicOctahedronItem>(parent);
        formfactorItem->setEdge(formfactor->edge());
    } else if (const auto* formfactor = dynamic_cast<const PlatonicTetrahedron*>(iFormFactor)) {
        auto* formfactorItem = addFormFactorItem<PlatonicTetrahedronItem>(parent);
        formfactorItem->setEdge(formfactor->edge());
    } else
        ASSERT(false);
}
 
MaterialItem* findMaterialItem(MaterialItems& matItems, const ISampleNode* node)
{
    const Material* material = node->material();
 
    QString materialName = QString::fromStdString(material->materialName());
 
    MaterialItem* materialItem = matItems.materialFromName(materialName);
    if (materialItem)
        return materialItem;
 
    complex_t material_data = material->materialData();
    if (material->typeID() == MATERIAL_TYPES::RefractiveMaterial) {
        materialItem = matItems.addRefractiveMaterial(materialName, material_data.real(),
                                                      material_data.imag());
    } else if (material->typeID() == MATERIAL_TYPES::MaterialBySLD) {
        materialItem =
            matItems.addSLDMaterial(materialName, material_data.real(), material_data.imag());
    } else
        ASSERT(0);
 
    materialItem->setMagnetization(material->magnetization());
 
    return materialItem;
}
 
void copyParticleItem(ParticleItem* particleItem, MaterialItems& matItems, const Particle* particle)
{
    particleItem->setAbundance(particle->abundance());
    particleItem->setPosition(particle->particlePosition());
    particleItem->setMaterial(findMaterialItem(matItems, particle));
    setRotation(particleItem, particle->rotation());
    setFormFactor(particleItem, particle->formfactor_at_bottom());
}
 
void copyParticle(const IParticle* iparticle, MaterialItems& matItems,
                  std::function<void(ItemWithParticles*)> addToParent)
{
    if (const auto* particle = dynamic_cast<const Particle*>(iparticle)) {
        auto* particle_item = new ParticleItem(&matItems);
        copyParticleItem(particle_item, matItems, particle);
        addToParent(particle_item);
    } else if (const auto* coreshell = dynamic_cast<const ParticleCoreShell*>(iparticle)) {
        if (!coreshell->coreParticle())
            throw std::runtime_error("core/shell particle has no core particle.");
        if (!coreshell->shellParticle())
            throw std::runtime_error("core/shell particle has no shell particle.");
 
        auto* coreShellItem = new ParticleCoreShellItem(&matItems);
        coreShellItem->setAbundance(coreshell->abundance());
        coreShellItem->setPosition(coreshell->particlePosition());
        setRotation(coreShellItem, coreshell->rotation());
 
        if (const Particle* p = coreshell->coreParticle()) {
            coreShellItem->createCore(&matItems);
            copyParticleItem(coreShellItem->core(), matItems, p);
        }
        if (const Particle* p = coreshell->shellParticle()) {
            coreShellItem->createShell(&matItems);
            copyParticleItem(coreShellItem->shell(), matItems, p);
        }
 
        addToParent(coreShellItem);
    } else if (const auto* meso = dynamic_cast<const MesoCrystal*>(iparticle)) {
        if (!meso->particleStructure().basis())
            throw std::runtime_error("Meso crystal has no basis.");
 
        auto* mesoItem = new MesoCrystalItem(&matItems);
        mesoItem->setAbundance(meso->abundance());
        mesoItem->setPosition(meso->particlePosition());
        setFormFactor(mesoItem, meso->outerShape());
        setRotation(mesoItem, meso->rotation());
 
        const Lattice3D* lattice = meso->particleStructure().lattice();
        mesoItem->setRawDataVectorA(lattice->basisVectorA());
        mesoItem->setRawDataVectorB(lattice->basisVectorB());
        mesoItem->setRawDataVectorC(lattice->basisVectorC());
        addToParent(mesoItem);
 
        copyParticle(meso->particleStructure().basis(), matItems,
                     [=](ItemWithParticles* p) { mesoItem->setBasis(p); });
 
    } else if (const auto* particleComposition =
                   dynamic_cast<const ParticleComposition*>(iparticle)) {
        auto* particleCompositionItem = new ParticleCompositionItem(&matItems);
 
        particleCompositionItem->setAbundance(particleComposition->abundance());
        particleCompositionItem->setPosition(particleComposition->particlePosition());
        setRotation(particleCompositionItem, particleComposition->rotation());
        addToParent(particleCompositionItem);
 
        for (const auto* p : particleComposition->particles())
            copyParticle(p, matItems,
                         [=](ItemWithParticles* p) { particleCompositionItem->addParticle(p); });
    }
}
 
} // namespace
 
 
namespace GUI::Transform::FromCore {
 
MultiLayerItem* itemizeSample(const MultiLayer& sample, const QString& nodeName)
{
    auto* result = new MultiLayerItem();
    result->setSampleName(nodeName.isEmpty() ? QString::fromStdString(sample.sampleName())
                                             : nodeName);
    result->crossCorrLength().set(sample.crossCorrLength());
    result->setExternalField(sample.externalField());
 
    MaterialItems& matItems = result->materialItems();
 
    //  iterate over layers
    for (size_t layerIndex = 0; layerIndex < sample.numberOfLayers(); layerIndex++) {
        const auto* layer = sample.layer(layerIndex);
 
        const LayerInterface* top_interface =
            layerIndex == 0 ? nullptr : sample.layerInterface(layerIndex - 1);
 
        auto* layerItem = result->addLayer();
        layerItem->setMaterial(findMaterialItem(matItems, layer));
        layerItem->setIsTopLayer(layerIndex == 0);
        layerItem->setIsBottomLayer(layerIndex == sample.numberOfLayers() - 1);
 
        setLayerItem(layerItem, layer, top_interface);
 
        // iterate over particle layouts
        for (const auto* layout : layer->layouts()) {
            auto* layoutItem = layerItem->addLayout();
            layoutItem->ownDensity().set(layout->totalParticleSurfaceDensity());
            layoutItem->weight().set(layout->weight());
            setInterference(layoutItem, layout->interferenceFunction());
 
            // create particles/particle compositions
            for (const IParticle* particle : layout->particles())
                copyParticle(particle, matItems,
                             [=](ItemWithParticles* p) { layoutItem->addParticle(p); });
        }
    }
 
    return result;
}
 
} // namespace GUI::Transform::FromCore