RectangularDetectorItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/RectangularDetectorItem.cpp
//! @brief     Implements class RectangularDetectorItem
//!
//! @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/RectangularDetectorItem.h"
#include "Device/Detector/RectangularDetector.h"
#include "GUI/Model/CatDevice/ResolutionFunctionItemCatalog.h"
#include "GUI/Model/Device/AxesItems.h"
#include "GUI/Model/Device/ResolutionFunctionItems.h"
#include "GUI/Support/XML/Serialize.h"
#include "GUI/Support/XML/UtilXML.h"
#include "GUI/Util/ComboProperty.h"
#include "GUI/Util/Error.h"
 
namespace {
 
const double default_detector_width = 20.0;
const double default_detector_height = 20.0;
const double default_detector_distance = 1000.0;
 
QString alignmentTitle(RectangularDetector::EDetectorArrangement a)
{
    switch (a) {
    case RectangularDetector::GENERIC:
        return "Generic";
    case RectangularDetector::PERPENDICULAR_TO_SAMPLE:
        return "Perpendicular to sample x-axis";
    case RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM:
        return "Perpendicular to direct beam";
    case RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM:
        return "Perpendicular to reflected beam";
    case RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS:
        return "Perpendicular to reflected beam (intersection unknown)";
    default:
        ASSERT(false);
    }
}
 
//! Returns the alignments as expected on the UI
QList<RectangularDetector::EDetectorArrangement> alignments()
{
    return {RectangularDetector::GENERIC, RectangularDetector::PERPENDICULAR_TO_SAMPLE,
            RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM,
            RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM,
            RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS};
}
 
void initResolutionFunction(ResolutionFunctionItem* newFunc, const ResolutionFunctionItem*)
{
    newFunc->setUnit("mm");
}
 
} // namespace
 
RectangularDetectorItem::RectangularDetectorItem()
{
    m_resolutionFunction.initWithInitializer<ResolutionFunctionItemCatalog>(
        "Resolution function", "Detector resolution function", "resolutionFunction",
        initResolutionFunction);
 
    m_xSize = 100;
    m_ySize = 100;
    m_width.init("Width (x-axis)", "Width of the detector", default_detector_width, "mm", 3,
                 RealLimits::positive(), "width");
    m_height.init("Height (y-axis)", "Height of the detector", default_detector_height, "mm", 3,
                  RealLimits::positive(), "height");
 
    m_normalVector.init(
        "Normal vector",
        "Normal of the detector plane with length equal to the sample detector distance",
        Unit::unitless, "normalVector");
    m_normalVector.r3().setX(default_detector_distance);
    m_directionVector.init("Direction vector",
                           "Detector axis direction vector w.r.t. the sample coordinate system",
                           Unit::unitless, "directionVector");
    m_directionVector.r3().setY(-1.0);
 
    m_u0.init("u0", "", default_detector_width / 2., "mm", 3, RealLimits::limitless(), "u0");
    m_v0.init("v0", "", 0.0, "mm", 3, RealLimits::limitless(), "v0");
    m_distance.init("Distance", "Distance from the sample origin to the detector plane",
                    default_detector_distance, "mm", "distance");
 
    m_detectorAlignment = RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM;
 
    updateTooltips();
}
 
void RectangularDetectorItem::serialize(Streamer& s)
{
    int alignment = m_detectorAlignment;
 
    s.assertVersion(0);
    // base class members
    Serialize::rwClass(s, "masks", m_maskItems);
    Serialize::rwSelected<ResolutionFunctionItemCatalog>(s, m_resolutionFunction);
 
    // own members
    Serialize::rwValue(s, "xSize", m_xSize);
    Serialize::rwValue(s, "ySize", m_ySize);
    Serialize::rwProperty(s, m_width);
    Serialize::rwProperty(s, m_height);
    Serialize::rwValue(s, "alignment", alignment);
    Serialize::rwProperty(s, m_normalVector);
    Serialize::rwProperty(s, m_directionVector);
    Serialize::rwProperty(s, m_u0);
    Serialize::rwProperty(s, m_v0);
    Serialize::rwProperty(s, m_distance);
 
    if (s.xmlReader()) {
        setDetectorAlignment(static_cast<RectangularDetector::EDetectorArrangement>(alignment));
        m_resolutionFunction->setUnit("mm");
    }
}
 
void RectangularDetectorItem::setDetectorAlignment(
    RectangularDetector::EDetectorArrangement alignment)
{
    m_detectorAlignment = alignment;
    updateTooltips();
}
 
RectangularDetector::EDetectorArrangement RectangularDetectorItem::detectorAlignment() const
{
    return m_detectorAlignment;
}
 
int RectangularDetectorItem::xSize() const
{
    return m_xSize;
}
 
int RectangularDetectorItem::ySize() const
{
    return m_ySize;
}
 
void RectangularDetectorItem::setXSize(size_t nx)
{
    m_xSize = static_cast<int>(nx);
}
 
void RectangularDetectorItem::setYSize(size_t ny)
{
    m_ySize = static_cast<int>(ny);
}
 
SelectionDescriptor<RectangularDetector::EDetectorArrangement>
RectangularDetectorItem::detectorAlignmentSelection() const
{
    SelectionDescriptor<RectangularDetector::EDetectorArrangement> d;
 
    d.label = "Alignment";
    for (auto a : alignments())
        d.options << alignmentTitle(a);
 
    d.currentIndexSetter = [&](int newIndex) {
        const_cast<RectangularDetectorItem*>(this)->setDetectorAlignment(alignments()[newIndex]);
    };
 
    d.currentIndexGetter = [&]() { return alignments().indexOf(m_detectorAlignment); };
    return d;
}
 
QVector<std::variant<VectorDescriptor, DoubleDescriptor>>
RectangularDetectorItem::alignmentPropertiesForUI() const
{
    if (m_detectorAlignment == RectangularDetector::GENERIC)
        return {normalVector(), directionVector(), u0(), v0()};
 
    return {u0(), v0(), distance()};
}
 
std::unique_ptr<IDetector> RectangularDetectorItem::createDomainDetector() const
{
    auto result = std::make_unique<RectangularDetector>(xSize(), width(), ySize(), height());
 
    // distance and alignment
    switch (m_detectorAlignment) {
    case RectangularDetector::GENERIC:
        result->setDetectorPosition(m_normalVector, m_u0, m_v0, m_directionVector);
        break;
    case RectangularDetector::PERPENDICULAR_TO_SAMPLE:
        result->setPerpendicularToSampleX(m_distance, m_u0, m_v0);
        break;
    case RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM:
        result->setPerpendicularToDirectBeam(m_distance, m_u0, m_v0);
        break;
    case RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM:
        result->setPerpendicularToReflectedBeam(m_distance, m_u0, m_v0);
        break;
    case RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS:
        result->setPerpendicularToReflectedBeam(m_distance);
        result->setDirectBeamPosition(m_u0, m_v0);
        break;
    default:
        break;
    }
 
    return std::unique_ptr<IDetector>(result.release());
}
 
void RectangularDetectorItem::updateTooltips()
{
    switch (m_detectorAlignment) {
    case RectangularDetector::GENERIC:
        m_u0.setTooltip(
            "u-coordinate of point of intersection of normal vector and detector plane");
        m_v0.setTooltip(
            "v-coordinate of point of intersection of normal vector and detector plane");
        break;
    case RectangularDetector::PERPENDICULAR_TO_SAMPLE:
        m_u0.setTooltip("u-coordinate of point where sample x-axis crosses the detector");
        m_v0.setTooltip("v-coordinate of point where sample x-axis crosses the detector");
        break;
    case RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM:
        m_u0.setTooltip("u-coordinate of point where reflected beam hits the detector");
        m_v0.setTooltip("v-coordinate of point where reflected beam hits the detector");
        break;
    case RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM: // fall-through!
    case RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS:
        m_u0.setTooltip("u-coordinate of point where direct beam hits the detector");
        m_v0.setTooltip("v-coordinate of point where direct beam hits the detector");
        break;
    default:
        break;
    }
}