InstrumentItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/InstrumentItems.cpp
//! @brief     Implement class InstrumentItem and all its children
//!
//! @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/Device/InstrumentItems.h"
#include "Base/Const/Units.h"
#include "Base/Pixel/RectangularPixel.h"
#include "Device/Beam/Beam.h"
#include "Device/Coord/CoordSystem1D.h"
#include "Device/Coord/CoordSystem2D.h"
#include "Device/Detector/RectangularDetector.h"
#include "Device/Detector/SphericalDetector.h"
#include "GUI/Model/CatDevice/BackgroundItemCatalog.h"
#include "GUI/Model/CatDevice/DetectorItemCatalog.h"
#include "GUI/Model/CatDevice/InstrumentItemCatalog.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Device/BackgroundItems.h"
#include "GUI/Model/Device/BeamWavelengthItem.h"
#include "GUI/Model/Device/DetectorItems.h"
#include "GUI/Model/Device/Instrument.h"
#include "GUI/Model/Device/PointwiseAxisItem.h"
#include "GUI/Model/Device/RectangularDetectorItem.h"
#include "GUI/Model/Device/SphericalDetectorItem.h"
#include "GUI/Support/XML/Backup.h"
#include "GUI/Support/XML/Serialize.h"
#include "GUI/Util/CoordName.h"
#include "GUI/Util/Error.h"
#include "GUI/Util/String.h"
#include "Sim/Simulation/DepthProbeSimulation.h"
#include "Sim/Simulation/OffspecSimulation.h"
#include "Sim/Simulation/ScatteringSimulation.h"
 
namespace {
 
void setBeamDistribution(ParameterDistribution::WhichParameter which,
                         const BeamDistributionItem& item, ISimulation& simulation)
{
    auto P_par_distr = item.getParameterDistributionForName(which);
    if (P_par_distr)
        simulation.addParameterDistribution(*P_par_distr);
}
 
} // namespace
 
//  ************************************************************************************************
//  class InstrumentItem
//  ************************************************************************************************
 
InstrumentItem::InstrumentItem()
    : m_withPolarizerAnalyzer(false)
{
    m_id = QUuid::createUuid().toString();
    m_analyzerEfficiency.init("Analyzer efficiency", "Efficiency of the polarization analysis", 0.0,
                              Unit::unitless, 4, RealLimits::limitless(), "efficiency");
    m_analyzerTotalTransmission.init("Analyzer transmission",
                                     "Total transmission of the polarization analysis", 1.0,
                                     Unit::unitless, 4, RealLimits::nonnegative(), "transmission");
    m_polarization.init("Polarization (Bloch vector)",
                        "Polarization of the beam, given as the Bloch vector", Unit::unitless,
                        "polarization");
    m_analyzerDirection.init("Analyzer direction", "Direction of the polarization analysis",
                             Unit::unitless, "analyzerDirection");
    m_backgroundItem.init<BackgroundItemCatalog>("Background", "", "background");
}
 
InstrumentItem* InstrumentItem::createCopy() const
{
    const auto type = InstrumentItemCatalog::type(this);
    auto* copy = InstrumentItemCatalog::create(type);
    GUI::Util::copyContents(this, copy);
    return copy;
}
 
QString InstrumentItem::id() const
{
    return m_id;
}
 
void InstrumentItem::setId(const QString& id)
{
    m_id = id;
}
 
void InstrumentItem::setInstrumentName(const QString& instrumentName)
{
    m_name = instrumentName;
}
 
QString InstrumentItem::instrumentName() const
{
    return m_name;
}
 
QString InstrumentItem::description() const
{
    return m_description;
}
 
void InstrumentItem::setDescription(const QString& description)
{
    m_description = description;
}
 
BeamItem* InstrumentItem::beamItem() const
{
    return m_beamItem.get();
}
 
BackgroundItem* InstrumentItem::backgroundItem() const
{
    return m_backgroundItem.get();
}
 
SelectionDescriptor<BackgroundItem*> InstrumentItem::backgroundSelection() const
{
    return m_backgroundItem;
}
 
bool InstrumentItem::alignedWith(const RealDataItem* item) const
{
    return shape() == item->shape();
}
 
bool InstrumentItem::withPolarizerAnalyzer() const
{
    return m_withPolarizerAnalyzer;
}
 
void InstrumentItem::setWithPolarizerAnalyzer(bool with)
{
    m_withPolarizerAnalyzer = with;
}
 
template <typename T>
T* InstrumentItem::beam() const
{
    return dynamic_cast<T*>(m_beamItem.get());
}
 
void InstrumentItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwValue(s, "id", m_id);
    Serialize::rwValue(s, "name", m_name);
    Serialize::rwValue(s, "description", m_description);
    Serialize::rwValue(s, "pa", m_withPolarizerAnalyzer);
    Serialize::rwProperty(s, m_polarization);
    Serialize::rwProperty(s, m_analyzerDirection);
    Serialize::rwProperty(s, m_analyzerEfficiency);
    Serialize::rwProperty(s, m_analyzerTotalTransmission);
    Serialize::rwSelected<BackgroundItemCatalog>(s, m_backgroundItem);
    Serialize::rwClass(s, "beam", *m_beamItem);
}
 
//  ************************************************************************************************
//  class SpecularInstrumentItem
//  ************************************************************************************************
 
SpecularInstrumentItem::SpecularInstrumentItem()
{
    m_beamItem.reset(new SpecularBeamItem(this));
}
 
SpecularBeamItem* SpecularInstrumentItem::beamItem() const
{
    return beam<SpecularBeamItem>();
}
 
std::vector<int> SpecularInstrumentItem::shape() const
{
    auto* const axis_item = beamItem()->inclinationAxis();
    return {axis_item->binCount()};
}
 
void SpecularInstrumentItem::updateToRealData(const RealDataItem* item)
{
    if (shape().size() != item->shape().size())
        throw Error("Error in SpecularInstrumentItem::updateToRealData: The type "
                    "of instrument is incompatible with passed data shape.");
 
    const auto& data = item->nativeDatafield()->axis(0);
    beamItem()->updateToData(data, item->nativeDataUnits());
}
 
bool SpecularInstrumentItem::alignedWith(const RealDataItem* item) const
{
    const QString native_units = item->nativeDataUnits();
    if (native_units == "nbins") {
        return beamItem()->inclinationAngleItem()->uniformAlphaAxisSelected()
               && shape() == item->shape();
    }
 
    if (!beamItem()->inclinationAngleItem()->pointwiseAlphaAxisSelected())
        return false;
 
    const auto* axisItem =
        dynamic_cast<const PointwiseAxisItem*>(beamItem()->inclinationAngleItem()->alphaAxis());
    ASSERT(axisItem);
 
    if (axisItem->getUnitsLabel() != native_units)
        return false;
 
    const auto* instrumentAxis = axisItem->axis();
    if (!instrumentAxis)
        return false;
 
    if (!item->hasNativeData())
        return false;
 
    const auto& native_axis = item->nativeDatafield()->axis(0);
    return *instrumentAxis == native_axis;
}
 
ICoordSystem* SpecularInstrumentItem::createCoordSystem() const
{
    std::unique_ptr<Beam> beam = beamItem()->createBeam();
    auto* axis_item = beamItem()->inclinationAxis();
    if (auto* pointwise_axis = dynamic_cast<PointwiseAxisItem*>(axis_item)) {
        if (!pointwise_axis->axis()) // workaround for loading project
            return nullptr;
        Coords native_units = GUI::Util::CoordName::coordFromName(pointwise_axis->getUnitsLabel());
        return new AngularReflectometryCoordinates(beam->wavelength(), *pointwise_axis->axis(),
                                                   native_units);
    }
 
    return new AngularReflectometryCoordinates(beam->wavelength(), *axis_item->createAxis(1.0),
                                               Coords::DEGREES);
}
 
QString SpecularInstrumentItem::instrumentType() const
{
    return "Specular";
}
 
QString SpecularInstrumentItem::defaultName() const
{
    return "Specular";
}
 
//  ************************************************************************************************
//  class DepthProbeInstrumentItem
//  ************************************************************************************************
 
DepthProbeInstrumentItem::DepthProbeInstrumentItem()
{
    m_beamItem.reset(new SpecularBeamItem(this));
 
    auto* axisItem = beamItem()->inclinationAxis();
    axisItem->setLowerBound(0.0);
    axisItem->setUpperBound(1.0);
    axisItem->setBinCount(500);
 
    m_zAxis.initNbins("Nbins", "Number of points in scan across sample bulk");
    m_zAxis.initMin("Min", "Starting value below sample horizon", -100.0, Unit::nanometer,
                    RealLimits::limitless());
    m_zAxis.initMax("Max", "Ending value above sample horizon", 100.0, Unit::nanometer,
                    RealLimits::limitless());
}
 
void DepthProbeInstrumentItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwBaseClass<InstrumentItem>(s, "InstrumentItem", this);
    m_zAxis.rwAxisProperty(s, "zAxis");
}
 
SpecularBeamItem* DepthProbeInstrumentItem::beamItem() const
{
    return beam<SpecularBeamItem>();
}
 
std::vector<int> DepthProbeInstrumentItem::shape() const
{
    return std::vector<int>(); // no certain shape to avoid linking to real data
}
 
void DepthProbeInstrumentItem::updateToRealData(const RealDataItem*)
{
    throw std::runtime_error("DepthProbeInstrumentItem::updateToRealData()");
}
 
QString DepthProbeInstrumentItem::defaultName() const
{
    return "DepthProbe";
}
 
QString DepthProbeInstrumentItem::instrumentType() const
{
    return "Depth probe";
}
 
DepthProbeSimulation* DepthProbeInstrumentItem::createSimulation(const MultiLayer& sample) const
{
    auto* simulation = new DepthProbeSimulation(sample);
 
    auto* const axis_item = beamItem()->inclinationAxis();
    auto axis = axis_item->createAxis(Units::deg);
 
    simulation->setBeamParameters(beamItem()->wavelength(), static_cast<int>(axis->size()),
                                  axis->min(), axis->max());
 
    simulation->setZSpan(m_zAxis.nbins(), m_zAxis.min(), m_zAxis.max());
 
    setBeamDistribution(ParameterDistribution::BeamWavelength, *beamItem()->wavelengthItem(),
                        *simulation);
 
    setBeamDistribution(ParameterDistribution::BeamInclinationAngle,
                        *beamItem()->inclinationAngleItem(), *simulation);
 
    return simulation;
}
 
ICoordSystem* DepthProbeInstrumentItem::createCoordSystem() const
{
    // TODO set pol filters ?
    return nullptr; // TODO NOW RESTORE createSimulation()->createCoordSystem();
}
 
//  ************************************************************************************************
//  class Instrument2DItem
//  ************************************************************************************************
 
Instrument2DItem::Instrument2DItem()
{
    m_beamItem.reset(new GISASBeamItem());
    m_detectorItem.init<DetectorItemCatalog>("Detector", "", "detector");
}
 
void Instrument2DItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwBaseClass<InstrumentItem>(s, "InstrumentItem", this);
    Serialize::rwSelected<DetectorItemCatalog>(s, m_detectorItem);
}
 
DetectorItem* Instrument2DItem::detectorItem() const
{
    return m_detectorItem.get();
}
 
SelectionDescriptor<DetectorItem*> Instrument2DItem::detectorSelection() const
{
    return m_detectorItem;
}
 
void Instrument2DItem::importMasks(const MaskContainerItem* maskContainer)
{
    detectorItem()->importMasks(maskContainer);
}
 
std::unique_ptr<Instrument> Instrument2DItem::createInstrument() const
{
    auto beam = beamItem()->createBeam();
    auto detector = detectorItem()->createDetector();
    detector->setDetectorNormal(beam->direction().zReflected());
 
    return std::make_unique<Instrument>(*beam, *detector);
}
 
ScatteringSimulation* Instrument2DItem::createScatteringSimulation(const MultiLayer& sample) const
{
    auto beam = beamItem()->createBeam();
    beam->setPolarization(m_polarization);
    auto detector = detectorItem()->createDetector();
    detector->setAnalyzer(m_analyzerDirection, m_analyzerEfficiency, m_analyzerTotalTransmission);
    detector->setDetectorNormal(beam->direction().zReflected());
 
    auto* result = new ScatteringSimulation(*beam, sample, *detector);
    return result;
}
 
OffspecSimulation* Instrument2DItem::createOffspecSimulation(const MultiLayer& sample) const
{
    auto beam = beamItem()->createBeam();
    beam->setPolarization(m_polarization);
    auto detector = detectorItem()->createDetector();
    detector->setAnalyzer(m_analyzerDirection, m_analyzerEfficiency, m_analyzerTotalTransmission);
    detector->setDetectorNormal(beam->direction().zReflected());
 
    auto* result = new OffspecSimulation(*beam, sample, *detector);
    return result;
}
 
//  ************************************************************************************************
//  class GISASInstrumentItem
//  ************************************************************************************************
 
std::vector<int> GISASInstrumentItem::shape() const
{
    auto* detector_item = detectorItem();
    return {detector_item->xSize(), detector_item->ySize()};
}
 
void GISASInstrumentItem::updateToRealData(const RealDataItem* item)
{
    if (!item)
        return;
 
    const auto data_shape = item->shape();
    if (shape().size() != data_shape.size())
        throw Error("Error in GISASInstrumentItem::updateToRealData: The type of "
                    "instrument is incompatible with passed data shape.");
    detectorItem()->setXSize(data_shape[0]);
    detectorItem()->setYSize(data_shape[1]);
}
 
QString GISASInstrumentItem::defaultName() const
{
    return "GISAS";
}
 
QString GISASInstrumentItem::instrumentType() const
{
    return "GISAS";
}
 
ICoordSystem* GISASInstrumentItem::createCoordSystem() const
{
    const auto instrument = createInstrument();
    return instrument->detector().scatteringCoords(instrument->beam());
}
 
//  ************************************************************************************************
//  class OffspecInstrumentItem
//  ************************************************************************************************
 
OffspecInstrumentItem::OffspecInstrumentItem()
{
    m_alphaAxis.initNbins("Nbins", "Number of points in scan");
    m_alphaAxis.initMin("Min", "Starting value", 0.0, Unit::degree, RealLimits::limited(-90, 90));
    m_alphaAxis.initMax("Max", "Ending value", 10.0, Unit::degree, RealLimits::limited(-90, 90));
 
    auto* beam_item = dynamic_cast<GISASBeamItem*>(beamItem());
    beam_item->setInclinationAngleGetter([=]() { return m_alphaAxis.min(); });
}
 
void OffspecInstrumentItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwBaseClass<Instrument2DItem>(s, "Instrument2DItem", this);
    m_alphaAxis.rwAxisProperty(s, "alphaAxis");
}
 
std::vector<int> OffspecInstrumentItem::shape() const
{
    return {(int)m_alphaAxis.nbins(), detectorItem()->ySize()};
}
 
void OffspecInstrumentItem::updateToRealData(const RealDataItem* dataItem)
{
    if (!dataItem)
        return;
 
    const auto data_shape = dataItem->shape();
    if (shape().size() != data_shape.size())
        throw Error("Error in OffspecInstrumentItem::updateToRealData: The type of "
                    "instrument is incompatible with passed data shape.");
 
    m_alphaAxis.setNbins(data_shape[0]);
    detectorItem()->setYSize(data_shape[1]);
}
 
QString OffspecInstrumentItem::defaultName() const
{
    return "Offspec";
}
 
QString OffspecInstrumentItem::instrumentType() const
{
    return "Off specular";
}
 
ICoordSystem* OffspecInstrumentItem::createCoordSystem() const
{
    IAxis* alphaAxis =
        new FixedBinAxis("alpha", m_alphaAxis.nbins(), m_alphaAxis.min() * Units::deg,
                         m_alphaAxis.max() * Units::deg);
    const auto instrument = createInstrument();
    return instrument->detector().offspecCoords(alphaAxis, instrument->beam().direction());
}