SimulationToCore.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/ToCore/SimulationToCore.cpp
//! @brief     Implements class DomainSimulationBuilder
//!
//! @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/SimulationToCore.h"
#include "Base/Const/Units.h"
#include "Base/Util/Assert.h"
#include "Device/Beam/Beam.h"
#include "Device/Beam/IFootprintFactor.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/FootprintItems.h"
#include "GUI/Model/Device/Instrument.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Sample/MultiLayerItem.h"
#include "GUI/Model/ToCore/SampleToCore.h"
#include "GUI/Support/Data/SimulationOptionsItem.h"
#include "GUI/Util/Error.h"
#include "Param/Distrib/RangedDistributions.h"
#include "Resample/Options/SimulationOptions.h"
#include "Sample/Multilayer/MultiLayer.h"
#include "Sim/Background/IBackground.h"
#include "Sim/Scan/AlphaScan.h"
#include "Sim/Scan/ScanResolution.h"
#include "Sim/Simulation/includeSimulations.h"
 
namespace {
 
//! If the given item has distributions, then add these distributions to the simulation's
//! distributions handler.
template <class T>
void setParameterDistributionToSimulation(ParameterDistribution::WhichParameter which,
                                          const BeamDistributionItem* item, ISimulation& simulation)
{
    const auto* const parameter_item = dynamic_cast<const T*>(item);
    ASSERT(parameter_item);
 
    auto par_distr = parameter_item->getParameterDistributionForName(which);
    if (par_distr)
        simulation.addParameterDistribution(*par_distr);
}
 
//! adds DistributionParameters to the ISimulation
void addDistributionParametersToSimulation(const BeamItem& item, ScatteringSimulation& simulation)
{
    ASSERT(dynamic_cast<const GISASBeamItem*>(&item));
 
    setParameterDistributionToSimulation<BeamWavelengthItem>(ParameterDistribution::BeamWavelength,
                                                             item.wavelengthItem(), simulation);
    setParameterDistributionToSimulation<BeamInclinationAngleItem>(
        ParameterDistribution::BeamInclinationAngle, item.inclinationAngleItem(), simulation);
    setParameterDistributionToSimulation<BeamAzimuthalAngleItem>(
        ParameterDistribution::BeamAzimuthalAngle, item.azimuthalAngleItem(), simulation);
}
 
void addBackgroundToSimulation(const InstrumentItem& item, ISimulation& simulation)
{
    if (const auto background = item.backgroundItem()->createBackground())
        simulation.setBackground(*background);
}
 
std::unique_ptr<ScanResolution> createScanResolution(const BeamDistributionItem* item)
{
    if (!item)
        return nullptr;
 
    const auto* distr_item = dynamic_cast<const SymmetricResolutionItem*>(item->distribution());
    if (!distr_item)
        return nullptr;
 
    const double scale = item->scaleFactor();
    auto ranged_distr = distr_item->createIRangedDistribution(scale);
    if (!ranged_distr)
        return nullptr;
 
    const double deviation = distr_item->deviation(scale);
    return std::unique_ptr<ScanResolution>(
        ScanResolution::scanAbsoluteResolution(*ranged_distr, deviation));
}
 
void setSimulationOptions(ISimulation* simulation, const SimulationOptionsItem& item)
{
    simulation->options().setNumberOfThreads(item.numberOfThreads());
    if (item.useMonteCarloIntegration())
        simulation->options().setMonteCarloIntegration(true, item.numberOfMonteCarloPoints());
    simulation->options().setUseAvgMaterials(item.useAverageMaterials());
    simulation->options().setIncludeSpecular(item.includeSpecularPeak());
}
 
ScatteringSimulation* createScatteringSimulation(std::unique_ptr<MultiLayer> sample,
                                                 const GISASInstrumentItem* item)
{
    ScatteringSimulation* result = item->createScatteringSimulation(*sample);
 
    addDistributionParametersToSimulation(*item->beamItem(), *result);
 
    addBackgroundToSimulation(*item, *result);
 
    return result;
}
 
OffspecSimulation* createOffspecSimulation(std::unique_ptr<MultiLayer> sample,
                                           const OffspecInstrumentItem* item)
{
    OffspecSimulation* result = item->createOffspecSimulation(*sample);
 
    auto* beamItem = item->beamItem();
    const auto axis = item->alphaAxis().createAxis(Units::deg);
    result->setBeamParameters(beamItem->wavelength(), *axis, beamItem->getAzimuthalAngle());
 
    addBackgroundToSimulation(*item, *result);
 
    return result;
}
 
SpecularSimulation* createSpecularSimulation(std::unique_ptr<MultiLayer> sample,
                                             const SpecularInstrumentItem* item)
{
    auto* beam_item = item->beamItem();
    auto* const axis_item = beam_item->inclinationAxis();
    auto* const footprint_item = beam_item->footprint();
 
    AlphaScan scan(beam_item->wavelength(), *axis_item->createAxis(Units::deg));
    scan.setFootprintFactor(footprint_item->createFootprint().get());
 
    if (const auto resolution = createScanResolution(beam_item->wavelengthItem()))
        scan.setWavelengthResolution(*resolution);
    if (const auto resolution = createScanResolution(beam_item->inclinationAngleItem()))
        scan.setAngleResolution(*resolution);
 
    auto* result = new SpecularSimulation(scan, *sample);
    // result->beam().setIntensity(beam_item->intensity());
 
    addBackgroundToSimulation(*item, *result);
 
    return result;
}
 
DepthProbeSimulation* createDepthProbeSimulation(std::unique_ptr<MultiLayer> sample,
                                                 const DepthProbeInstrumentItem* item)
{
    return item->createSimulation(*sample);
}
 
} // namespace
 
 
std::unique_ptr<ISimulation>
GUI::Transform::ToCore::itemsToSimulation(const MultiLayerItem* sampleItem,
                                          const InstrumentItem* instrumentItem,
                                          const SimulationOptionsItem& optionsItem)
{
    ASSERT(sampleItem);
    ASSERT(instrumentItem);
 
    std::unique_ptr<MultiLayer> sample = GUI::Transform::ToCore::itemToSample(*sampleItem);
    std::unique_ptr<ISimulation> result;
 
    if (const auto* gisasInstrument = dynamic_cast<const GISASInstrumentItem*>(instrumentItem))
        result.reset(createScatteringSimulation(std::move(sample), gisasInstrument));
    else if (const auto* offspecInstrument =
                 dynamic_cast<const OffspecInstrumentItem*>(instrumentItem))
        result.reset(createOffspecSimulation(std::move(sample), offspecInstrument));
    else if (const auto* specular_instrument =
                 dynamic_cast<const SpecularInstrumentItem*>(instrumentItem))
        result.reset(createSpecularSimulation(std::move(sample), specular_instrument));
    else if (const auto* penetrator = dynamic_cast<const DepthProbeInstrumentItem*>(instrumentItem))
        result.reset(createDepthProbeSimulation(std::move(sample), penetrator));
    else
        ASSERT(0);
 
    setSimulationOptions(result.get(), optionsItem);
 
    return result;
}