InstrumentItems.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/InstrumentItems.h
//! @brief     Defines 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)
//
//  ************************************************************************************************
 
#ifndef BORNAGAIN_GUI_MODEL_DEVICE_INSTRUMENTITEMS_H
#define BORNAGAIN_GUI_MODEL_DEVICE_INSTRUMENTITEMS_H
 
#include "GUI/Model/Descriptor/AxisProperty.h"
#include "GUI/Model/Descriptor/SelectionDescriptor.h"
#include "GUI/Model/Descriptor/SelectionProperty.h"
#include "GUI/Model/Descriptor/VectorProperty.h"
#include "GUI/Model/Device/BackgroundItems.h"
#include "GUI/Model/Device/BeamItems.h" // inheritance prevents forward declaration
#include "GUI/Model/Device/DetectorItems.h"
#include <functional>
#include <memory>
 
class BackgroundItem;
class DataItem;
class DepthProbeSimulation;
class ICoordSystem;
class Instrument;
class MaskContainerItem;
class MultiLayer;
class RealDataItem;
class OffspecSimulation;
class ScatteringSimulation;
 
//! Abstract base class for instrument-specific item classes.
 
class InstrumentItem {
public:
    InstrumentItem();
    virtual ~InstrumentItem() = default;
 
    //! Creates an exact copy; also ID is the same!
    InstrumentItem* createCopy() const;
 
    virtual void serialize(Streamer& s);
 
    QString id() const;
    void setId(const QString& id);
 
    void setInstrumentName(const QString& instrumentName);
    QString instrumentName() const;
 
    //! The type as how to show it on the UI. Do not use for type checking or similar!
    virtual QString instrumentType() const = 0;
 
    template <typename T>
    bool is() const
    {
        return dynamic_cast<const T*>(this) != nullptr;
    }
 
    QString description() const;
    void setDescription(const QString& description);
 
    virtual BeamItem* beamItem() const;
    BackgroundItem* backgroundItem() const;
 
    template <typename T>
    T* setBackgroundType();
    SelectionDescriptor<BackgroundItem*> backgroundSelection() const;
 
    virtual std::vector<int> shape() const = 0;
 
    virtual void importMasks(const MaskContainerItem*) {}
 
    virtual void updateToRealData(const RealDataItem* item) = 0;
    virtual bool alignedWith(const RealDataItem* item) const;
 
    //! The default user visible name when creating an instrument
    virtual QString defaultName() const = 0;
 
    virtual ICoordSystem* createCoordSystem() const = 0;
 
    bool withPolarizerAnalyzer() const;
    void setWithPolarizerAnalyzer(bool with);
 
    VECTOR_PROPERTY(polarization, Polarization);
    VECTOR_PROPERTY(analyzerDirection, AnalyzerDirection);
    DOUBLE_PROPERTY(analyzerEfficiency, AnalyzerEfficiency)
    DOUBLE_PROPERTY(analyzerTotalTransmission, AnalyzerTotalTransmission);
 
protected:
    explicit InstrumentItem(const QString& modelType);
 
    template <typename T>
    T* beam() const;
 
    QString m_id;
    QString m_name;
    QString m_description;
    bool m_withPolarizerAnalyzer;
    SelectionProperty<BackgroundItem*> m_backgroundItem;
    std::unique_ptr<BeamItem> m_beamItem;
};
 
 
class SpecularInstrumentItem : public InstrumentItem {
public:
    SpecularInstrumentItem();
 
    SpecularBeamItem* beamItem() const override;
 
    std::vector<int> shape() const override;
    void updateToRealData(const RealDataItem* item) override;
    bool alignedWith(const RealDataItem* item) const override;
    QString defaultName() const override;
    QString instrumentType() const override;
 
    ICoordSystem* createCoordSystem() const override;
};
 
 
class DepthProbeInstrumentItem : public InstrumentItem {
public:
    DepthProbeInstrumentItem();
    void serialize(Streamer& s) override;
 
    SpecularBeamItem* beamItem() const override;
 
    std::vector<int> shape() const override;
    void updateToRealData(const RealDataItem* item) override;
    QString defaultName() const override;
    QString instrumentType() const override;
 
    // FIXME switch to base ISimulation class after InstrumentItem refactoring and
    // after ISimulation gets createCoordSystem method
    DepthProbeSimulation* createSimulation(const MultiLayer& sample) const;
 
    ICoordSystem* createCoordSystem() const override;
 
    AXIS_PROPERTY(zAxis);
};
 
 
class Instrument2DItem : public InstrumentItem {
public:
    void serialize(Streamer& s) override;
 
    DetectorItem* detectorItem() const;
    GroupItem* detectorGroup();
    template <typename T>
    T* setDetectorType();
    SelectionDescriptor<DetectorItem*> detectorSelection() const;
 
    void importMasks(const MaskContainerItem* maskContainer) override;
 
    std::unique_ptr<Instrument> createInstrument() const;
    ScatteringSimulation* createScatteringSimulation(const MultiLayer& sample) const;
    OffspecSimulation* createOffspecSimulation(const MultiLayer& sample) const;
 
    static bool isDetectorPropertyName(const QString& name);
 
protected:
    Instrument2DItem();
 
    SelectionProperty<DetectorItem*> m_detectorItem;
};
 
 
class GISASInstrumentItem : public Instrument2DItem {
public:
    std::vector<int> shape() const override;
    void updateToRealData(const RealDataItem* item) override;
    QString defaultName() const override;
    QString instrumentType() const override;
 
    ICoordSystem* createCoordSystem() const override;
};
 
 
class OffspecInstrumentItem : public Instrument2DItem {
public:
    OffspecInstrumentItem();
    void serialize(Streamer& s) override;
 
    std::vector<int> shape() const override;
    void updateToRealData(const RealDataItem* item) override;
    QString defaultName() const override;
    QString instrumentType() const override;
 
    ICoordSystem* createCoordSystem() const override;
 
    AXIS_PROPERTY(alphaAxis);
};
 
//  ************************************************************************************************
//  templated functions implementation
//  ************************************************************************************************
 
template <typename T>
T* InstrumentItem::setBackgroundType()
{
    m_backgroundItem.set<T>();
    return dynamic_cast<T*>(m_backgroundItem.get());
}
 
template <typename T>
T* Instrument2DItem::setDetectorType()
{
    m_detectorItem.set<T>();
    return dynamic_cast<T*>(m_detectorItem.get());
}
 
#endif // BORNAGAIN_GUI_MODEL_DEVICE_INSTRUMENTITEMS_H