ParameterTreeUtils.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Model/ParameterTreeUtils.cpp
//! @brief     Implements ParameterTreeUtils 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/Model/Model/ParameterTreeUtils.h"
#include "GUI/Model/CatDevice/DistributionItemCatalog.h"
#include "GUI/Model/CatSample/FormFactorItemCatalog.h"
#include "GUI/Model/CatSample/InterferenceItemCatalog.h"
#include "GUI/Model/CatSample/ItemWithParticlesCatalog.h"
#include "GUI/Model/CatSample/Lattice2DItemCatalog.h"
#include "GUI/Model/CatSample/ProfileItemCatalogs.h"
#include "GUI/Model/CatSample/RotationItemCatalog.h"
#include "GUI/Model/Device/AxesItems.h"
#include "GUI/Model/Device/BackgroundItems.h"
#include "GUI/Model/Device/BeamAngleItems.h"
#include "GUI/Model/Device/BeamWavelengthItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Device/RectangularDetectorItem.h"
#include "GUI/Model/Device/ResolutionFunctionItems.h"
#include "GUI/Model/Device/SphericalDetectorItem.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Job/ParameterTreeItems.h"
#include "GUI/Model/Sample/InterferenceItems.h"
#include "GUI/Model/Sample/LayerItem.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"
 
namespace {
 
QString labelWithUnit(const QString& label, variant<QString, Unit> unit)
{
    const QString s = std::holds_alternative<QString>(unit) ? std::get<QString>(unit)
                                                            : unitAsString(std::get<Unit>(unit));
 
    if (!s.isEmpty())
        return label + " [" + s + "]";
 
    return label;
}
 
template <typename Catalog>
ParameterLabelItem* addLabel(ParameterLabelItem* parent, const QString& category,
                             const typename Catalog::CatalogedType* p)
{
    const auto title = category + " (" + Catalog::uiInfo(Catalog::type(p)).menuEntry + ")";
    return new ParameterLabelItem(title, parent);
}
 
template <typename Catalog>
ParameterLabelItem* addLabel(ParameterLabelItem* parent, const typename Catalog::CatalogedType* p)
{
    const auto title = Catalog::uiInfo(Catalog::type(p)).menuEntry;
    return new ParameterLabelItem(title, parent);
}
 
} // namespace
 
//  ************************************************************************************************
 
ParameterTreeBuilder::ParameterTreeBuilder(JobItem* jobItem, bool recreateBackupValues)
    : m_jobItem(jobItem)
    , m_recreateBackupValues(recreateBackupValues)
{
}
 
void ParameterTreeBuilder::build()
{
    addMaterials();
    addSample();
    addInstrument();
}
 
void ParameterTreeBuilder::addMaterials()
{
    auto* materialTopLabel =
        new ParameterLabelItem("Materials", parameterContainer()->parameterTreeRoot());
    for (auto* item : m_jobItem->sampleItem()->materialItems().materialItems()) {
        auto* label = new ParameterLabelItem(item->matItemName(), materialTopLabel);
        if (item->hasRefractiveIndex()) {
            addParameterItem(label, item->delta());
            addParameterItem(label, item->beta());
        } else {
            addParameterItem(label, item->sldRe());
            addParameterItem(label, item->sldIm());
        }
 
        if (allowMagneticFields())
            addParameterItem(label, item->magnetizationVector());
    }
}
 
void ParameterTreeBuilder::addSample()
{
    auto* label = new ParameterLabelItem("Sample", parameterContainer()->parameterTreeRoot());
    addParameterItem(label, m_jobItem->sampleItem()->crossCorrLength());
    if (allowMagneticFields())
        addParameterItem(label, m_jobItem->sampleItem()->externalFieldVector());
 
    int iLayer = 0;
    for (auto* layer : m_jobItem->sampleItem()->layers()) {
        auto* layerLabel = new ParameterLabelItem("Layer" + QString::number(iLayer++), label);
        if (!layer->isTopLayer() && !layer->isBottomLayer())
            addParameterItem(layerLabel, layer->thickness());
        if (!layer->isTopLayer())
            if (auto* roughnessItem = layer->roughness().currentItem()) {
                auto* roughnessLabel = new ParameterLabelItem("Top roughness", layerLabel);
                addParameterItem(roughnessLabel, roughnessItem->sigma());
                addParameterItem(roughnessLabel, roughnessItem->hurst());
                addParameterItem(roughnessLabel, roughnessItem->lateralCorrelationLength());
            }
 
        int iLayout = 0;
        for (auto* layout : layer->layouts()) {
            auto* label = new ParameterLabelItem("Layout" + QString::number(iLayout++), layerLabel);
            if (!layout->totalDensityIsDefinedByInterference())
                addParameterItem(label, layout->ownDensity());
            addParameterItem(label, layout->weight());
 
            addInterference(label, layout);
 
            for (auto* p : layout->particles())
                addParticle(label, p, true);
        }
    }
}
 
void ParameterTreeBuilder::addParameterItem(ParameterLabelItem* parent, const DoubleDescriptor& d,
                                            const QString& label)
{
    auto* parameterItem = new ParameterItem(parent);
    parameterItem->setTitle(labelWithUnit(label.isEmpty() ? d.label : label, d.unit));
    parameterItem->linkToDescriptor(d);
    if (m_recreateBackupValues)
        m_jobItem->parameterContainerItem()->setBackupValue(parameterItem->link(), d.get());
}
 
void ParameterTreeBuilder::addParameterItem(ParameterLabelItem* parent, const VectorDescriptor& d)
{
    auto* label = new ParameterLabelItem(d.label, parent);
    addParameterItem(label, d.x);
    addParameterItem(label, d.y);
    addParameterItem(label, d.z);
}
 
 
void ParameterTreeBuilder::addParameterItem(
    ParameterLabelItem* parent, const std::variant<VectorDescriptor, DoubleDescriptor>& v)
{
    std::visit([=](auto const& e) { addParameterItem(parent, e); }, v);
}
 
ParameterContainerItem* ParameterTreeBuilder::parameterContainer()
{
    return m_jobItem->parameterContainerItem();
}
 
bool ParameterTreeBuilder::allowMagneticFields() const
{
    // TODO: return true when specular instrument is ready for magnetization
    return !m_jobItem->isSpecularJob();
}
 
void ParameterTreeBuilder::addInterference(ParameterLabelItem* layoutLabel,
                                           const ParticleLayoutItem* layout)
{
    const auto* interference = layout->interference().currentItem();
    if (!interference)
        return;
 
    const auto itfType = InterferenceItemCatalog::type(interference);
    const QString title = InterferenceItemCatalog::uiInfo(itfType).menuEntry;
 
    auto* label = new ParameterLabelItem("Interference (" + title + ")", layoutLabel);
 
    if (const auto* itf = dynamic_cast<const InterferenceRadialParaCrystalItem*>(interference)) {
        addParameterItem(label, itf->positionVariance());
        addParameterItem(label, itf->peakDistance());
        addParameterItem(label, itf->dampingLength());
        addParameterItem(label, itf->domainSize());
        addParameterItem(label, itf->kappa());
 
        const auto* pdf = itf->probabilityDistribution().currentItem();
        auto* pdfLabel = addLabel<Profile1DItemCatalog>(label, "PDF", pdf);
        for (const auto& d : pdf->valueDescriptors())
            addParameterItem(pdfLabel, d);
    } else if (const auto* itf = dynamic_cast<const Interference2DParaCrystalItem*>(interference)) {
        addParameterItem(label, itf->positionVariance());
        addParameterItem(label, itf->dampingLength());
        addParameterItem(label, itf->domainSize1());
        addParameterItem(label, itf->domainSize2());
        addLattice(label, itf);
 
        const auto* pdf1 = itf->probabilityDistribution1().currentItem();
        const auto* pdf2 = itf->probabilityDistribution2().currentItem();
        const bool samePdfTypes =
            Profile2DItemCatalog::type(pdf1) == Profile2DItemCatalog::type(pdf2);
        auto* pdf1Label =
            addLabel<Profile2DItemCatalog>(label, samePdfTypes ? "PDF1" : "PDF", pdf1);
        for (const auto& d : pdf1->valueDescriptors())
            addParameterItem(pdf1Label, d);
        auto* pdf2Label =
            addLabel<Profile2DItemCatalog>(label, samePdfTypes ? "PDF2" : "PDF", pdf2);
        for (const auto& d : pdf2->valueDescriptors())
            addParameterItem(pdf2Label, d);
    } else if (const auto* itf = dynamic_cast<const Interference1DLatticeItem*>(interference)) {
        addParameterItem(label, itf->positionVariance());
        addParameterItem(label, itf->length());
        addParameterItem(label, itf->rotationAngle());
 
        const auto* df = itf->decayFunction().currentItem();
        auto* dfLabel = addLabel<Profile1DItemCatalog>(label, "Decay function", df);
        for (const auto& d : df->valueDescriptors())
            addParameterItem(dfLabel, d);
    } else if (const auto* itf = dynamic_cast<const Interference2DLatticeItem*>(interference)) {
        addParameterItem(label, itf->positionVariance());
        addLattice(label, itf);
 
        const auto* df = itf->decayFunction().currentItem();
        auto* dfLabel = addLabel<Profile2DItemCatalog>(label, "Decay function", df);
        for (const auto& d : df->valueDescriptors())
            addParameterItem(dfLabel, d);
    } else if (const auto* itf =
                   dynamic_cast<const InterferenceFinite2DLatticeItem*>(interference)) {
        // domainSize1 and domainSize2 are of type UInt (not matching the double approach for tuning
        // and fitting). In BornAgain 1.18 these values have not been added to the tuning tree, and
        // also not to the fitting parameters. Maybe this should be necessary, but for now this
        // stays the same and the two sizes are not added
        addParameterItem(label, itf->positionVariance());
        addLattice(label, itf);
    } else if (const auto* itf = dynamic_cast<const InterferenceHardDiskItem*>(interference)) {
        addParameterItem(label, itf->positionVariance());
        addParameterItem(label, itf->radius());
        addParameterItem(label, itf->density());
    }
}
 
ParameterLabelItem* ParameterTreeBuilder::addParticle(ParameterLabelItem* parentLabel,
                                                      ItemWithParticles* p, bool enableAbundance,
                                                      bool enablePosition)
{
    auto* label = addLabel<ItemWithParticlesCatalog>(parentLabel, p);
 
    if (enableAbundance)
        addParameterItem(label, p->abundance());
    if (enablePosition)
        addParameterItem(label, p->positionVector());
    addRotation(label, p);
 
    if (const auto* particle = dynamic_cast<const ParticleItem*>(p)) {
        const auto* formFactor = particle->formfactor_at_bottom();
        auto* ffLabel = addLabel<FormFactorItemCatalog>(label, "Formfactor", formFactor);
        for (const auto& d : formFactor->geometryValues())
            addParameterItem(ffLabel, d);
    } else if (const auto* particleComposition = dynamic_cast<const ParticleCompositionItem*>(p)) {
        for (auto* p : particleComposition->particles())
            addParticle(label, p, false);
    } else if (const auto* coreShell = dynamic_cast<const ParticleCoreShellItem*>(p)) {
        auto* l = addParticle(label, coreShell->core(), false);
        l->setTitle(l->title() + " (Core)");
        l = addParticle(label, coreShell->shell(), false, false);
        l->setTitle(l->title() + " (Shell)");
    } else if (const auto* meso = dynamic_cast<const MesoCrystalItem*>(p)) {
        addParameterItem(label, meso->vectorA());
        addParameterItem(label, meso->vectorB());
        addParameterItem(label, meso->vectorC());
 
        const auto* outerShape = meso->outerShape().currentItem();
        auto* ffLabel = addLabel<FormFactorItemCatalog>(label, "Outer shape", outerShape);
        for (const auto& d : outerShape->geometryValues())
            addParameterItem(ffLabel, d);
 
        auto* l = addParticle(label, meso->basisParticle(), false);
        l->setTitle(l->title() + " (Basis particle)");
    }
 
    return label;
}
 
void ParameterTreeBuilder::addLattice(ParameterLabelItem* parentLabel,
                                      const Interference2DAbstractLatticeItem* itf)
{
    const auto* lattice = itf->latticeType().currentItem();
    auto* label = addLabel<Lattice2DItemCatalog>(parentLabel, "Lattice", lattice);
    for (const auto& d : lattice->geometryValues(!itf->xiIntegration()))
        addParameterItem(label, d);
}
 
void ParameterTreeBuilder::addRotation(ParameterLabelItem* parentLabel, ItemWithParticles* p)
{
    const auto* r = p->rotation().currentItem();
    if (!r)
        return;
 
    auto* label = addLabel<RotationItemCatalog>(parentLabel, "Rotation", r);
    for (const auto& d : r->rotationValues())
        addParameterItem(label, d);
}
 
void ParameterTreeBuilder::addInstrument()
{
    const auto* instrument = m_jobItem->instrumentItem();
    auto* label = new ParameterLabelItem(instrument->instrumentType() + " instrument",
                                         parameterContainer()->parameterTreeRoot());
 
    auto* beamItem = instrument->beamItem();
    if (auto* gisas = dynamic_cast<const GISASInstrumentItem*>(instrument)) {
        auto* beamLabel = new ParameterLabelItem("Beam", label);
        addParameterItem(beamLabel, beamItem->intensity());
        addBeamDistribution(beamLabel, beamItem->wavelengthItem(), "Wavelength");
        addBeamDistribution(beamLabel, beamItem->inclinationAngleItem(), "Inclination angle");
        addBeamDistribution(beamLabel, beamItem->azimuthalAngleItem(), "Azimuthal angle");
        addDetector(label, gisas->detectorItem());
        addPolarization(label, instrument);
        addBackground(label, instrument->backgroundItem());
    } else if (instrument->is<SpecularInstrumentItem>()) {
        auto* beamLabel = new ParameterLabelItem("Beam", label);
        addParameterItem(beamLabel, beamItem->intensity());
        addBeamDistribution(beamLabel, beamItem->wavelengthItem(), "Wavelength", false);
        addBeamDistribution(beamLabel, beamItem->inclinationAngleItem(), "Inclination angle",
                            false);
        addPolarization(label, instrument);
        addBackground(label, instrument->backgroundItem());
    } else if (auto* os = dynamic_cast<const OffspecInstrumentItem*>(instrument)) {
        auto* beamLabel = new ParameterLabelItem("Beam", label);
        addParameterItem(beamLabel, beamItem->intensity());
        addBeamDistribution(beamLabel, beamItem->wavelengthItem(), "Wavelength");
        addBeamDistribution(beamLabel, beamItem->azimuthalAngleItem(), "Azimuthal angle");
        addDetector(label, os->detectorItem());
        addPolarization(label, instrument);
    } else if (instrument->is<DepthProbeInstrumentItem>()) {
        auto* beamLabel = new ParameterLabelItem("Parameters", label);
        addBeamDistribution(beamLabel, beamItem->wavelengthItem(), "Wavelength");
        addBeamDistribution(beamLabel, beamItem->inclinationAngleItem(), "Inclination angle",
                            false);
        addPolarization(label, instrument);
    } else
        ASSERT(false);
}
 
void ParameterTreeBuilder::addBeamDistribution(ParameterLabelItem* parentLabel,
                                               BeamDistributionItem* distributionItem,
                                               const QString& label, bool withMean)
{
    auto* distribution = distributionItem->distribution();
    if (auto* dn = dynamic_cast<DistributionNoneItem*>(distribution)) {
        if (withMean)
            addParameterItem(parentLabel, dn->mean(), label);
    } else {
        const auto type = DistributionItemCatalog::type(distribution);
        const auto name = DistributionItemCatalog::uiInfo(type).menuEntry;
        auto* item = new ParameterLabelItem(QString("%1 (%2 distribution)").arg(label).arg(name),
                                            parentLabel);
        for (const auto& d : distribution->distributionValues(withMean))
            addParameterItem(item, d);
    }
}
 
void ParameterTreeBuilder::addDetector(ParameterLabelItem* parentLabel, DetectorItem* detector)
{
    const auto addResolutionFunction = [=](ParameterLabelItem* detLabel) {
        if (auto* r = dynamic_cast<ResolutionFunction2DGaussianItem*>(
                detector->resolutionFunctionSelection().currentItem())) {
            auto* label = new ParameterLabelItem("Resolution (Gaussian)", detLabel);
            addParameterItem(label, r->sigmaX());
            addParameterItem(label, r->sigmaY());
        }
    };
 
    if (auto* rectDetector = dynamic_cast<RectangularDetectorItem*>(detector)) {
        auto* label = new ParameterLabelItem("Detector (rectangular)", parentLabel);
        addParameterItem(label, rectDetector->width());
        addParameterItem(label, rectDetector->height());
        addResolutionFunction(label);
        for (const auto& a : rectDetector->alignmentPropertiesForUI())
            addParameterItem(label, a);
    } else if (auto* spherDetector = dynamic_cast<SphericalDetectorItem*>(detector)) {
        auto* label = new ParameterLabelItem("Detector (spherical)", parentLabel);
        auto* phiLabel = new ParameterLabelItem("Phi axis", label);
        const QString unit = unitAsString(Unit::degree);
        addParameterItem(phiLabel, spherDetector->phiAxis().min());
        addParameterItem(phiLabel, spherDetector->phiAxis().max());
        auto* alphaLabel = new ParameterLabelItem("Alpha axis", label);
        addParameterItem(alphaLabel, spherDetector->alphaAxis().min());
        addParameterItem(alphaLabel, spherDetector->alphaAxis().max());
        addResolutionFunction(label);
    } else
        ASSERT(false);
}
 
void ParameterTreeBuilder::addBackground(ParameterLabelItem* instrumentLabel,
                                         BackgroundItem* backgroundItem)
{
    if (auto* b = dynamic_cast<ConstantBackgroundItem*>(backgroundItem))
        addParameterItem(instrumentLabel, b->backgroundValue(),
                         labelWithUnit("Constant background", b->backgroundValue().unit));
}
 
void ParameterTreeBuilder::addPolarization(ParameterLabelItem* instrumentLabel,
                                           const InstrumentItem* instrument)
{
    if (!instrument->withPolarizerAnalyzer())
        return;
 
    auto* label = new ParameterLabelItem("Polarization analysis", instrumentLabel);
    addParameterItem(label, instrument->polarization());
    addParameterItem(label, instrument->analyzerDirection());
    addParameterItem(label, instrument->analyzerEfficiency());
    addParameterItem(label, instrument->analyzerTotalTransmission());
}