SampleToCore.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/ToCore/SampleToCore.cpp
//! @brief     Implements class TransformToCore
//!
//! @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/ToCore/SampleToCore.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Model/Descriptor/UIntDescriptor.h"
#include "GUI/Model/Sample/InterferenceItems.h"
#include "GUI/Model/Sample/LayerItem.h"
#include "GUI/Model/Sample/LayerRoughnessItems.h"
#include "GUI/Model/Sample/MaterialItem.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 "Sample/Aggregate/IInterference.h"
#include "Sample/Aggregate/ParticleLayout.h"
#include "Sample/Interface/LayerRoughness.h"
#include "Sample/Multilayer/Layer.h"
#include "Sample/Multilayer/MultiLayer.h"
#include "Sample/Particle/IParticle.h"
#include "Sample/Particle/MesoCrystal.h"
#include "Sample/Particle/Particle.h"
#include "Sample/Particle/ParticleCoreShell.h"
 
namespace {
 
std::unique_ptr<MultiLayer> createMultiLayer(const MultiLayerItem& item)
{
    auto sample = std::make_unique<MultiLayer>();
    double cross_corr_length = item.crossCorrLength();
    if (cross_corr_length > 0)
        sample->setCrossCorrLength(cross_corr_length);
    R3 external_field = item.externalField();
    sample->setExternalField(external_field);
    return sample;
}
 
std::unique_ptr<Layer> createLayer(const LayerItem& item)
{
    const bool isFirstOrLastLayer = item.isTopLayer() || item.isBottomLayer();
    auto layer = std::make_unique<Layer>(*item.materialItem()->createMaterial(),
                                         isFirstOrLastLayer ? 0.0 : item.thickness());
    layer->setNumberOfSlices(item.numSlices());
    return layer;
}
 
std::unique_ptr<ParticleLayout> createParticleLayout(const ParticleLayoutItem& item)
{
    auto layout = std::make_unique<ParticleLayout>();
    double total_density = item.totalDensity();
    double layout_weight = item.weight();
    layout->setTotalParticleSurfaceDensity(total_density);
    layout->setWeight(layout_weight);
    return layout;
}
 
std::unique_ptr<IParticle> createIParticle(const ItemWithParticles& item)
{
    std::unique_ptr<IParticle> particle;
    if (const auto* particle_item = dynamic_cast<const ParticleItem*>(&item))
        particle = particle_item->createParticle();
    else if (const auto* particle_coreshell_item =
                 dynamic_cast<const ParticleCoreShellItem*>(&item))
        particle = particle_coreshell_item->createParticleCoreShell();
    else if (const auto* particle_composition_item =
                 dynamic_cast<const ParticleCompositionItem*>(&item))
        particle = particle_composition_item->createParticleComposition();
    else if (const auto* mesocrystal_item = dynamic_cast<const MesoCrystalItem*>(&item))
        particle = mesocrystal_item->createMesoCrystal();
 
    return particle;
}
 
std::unique_ptr<ParticleLayout> buildParticleLayout(const ParticleLayoutItem& item)
{
    auto layout = createParticleLayout(item);
    for (auto particleItem : item.particles()) {
        if (auto particle = createIParticle(*particleItem)) {
            layout->addParticle(*particle);
            continue;
        }
        ASSERT(0); // case not implemented yet?
    }
 
    if (InterferenceItem* interferenceItem = item.interference().currentItem())
        if (auto interference = interferenceItem->createInterference())
            layout->setInterference(*interference);
    return layout;
}
 
std::unique_ptr<Layer> buildLayer(const LayerItem& item)
{
    auto layer = createLayer(item);
    for (ParticleLayoutItem* layoutItem : item.layouts()) {
        if (auto layout = buildParticleLayout(*layoutItem))
            layer->addLayout(*layout);
    }
    return layer;
}
 
std::unique_ptr<LayerRoughness> itemToLayerRoughness(LayerBasicRoughnessItem* roughness)
{
    if (!roughness)
        return nullptr;
    return std::make_unique<LayerRoughness>(roughness->sigma(), roughness->hurst(),
                                            roughness->lateralCorrelationLength());
}
 
} // namespace
 
std::unique_ptr<MultiLayer> GUI::Transform::ToCore::itemToSample(const MultiLayerItem& sampleItem)
{
    auto sample = createMultiLayer(sampleItem);
    for (auto* layerItem : sampleItem.layers()) {
        auto layer = buildLayer(*layerItem);
        ASSERT(layer);
        const auto roughnessItem = layerItem->roughness().currentItem();
        auto roughness = itemToLayerRoughness(roughnessItem);
        if (roughness && !layerItem->isTopLayer())
            sample->addLayerWithTopRoughness(*layer, *roughness);
        else
            sample->addLayer(*layer);
    }
    return sample;
}