AlphaScan.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Sim/Scan/AlphaScan.h
//! @brief     Declares AlphaScan class.
//!
//! @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_SIM_SCAN_ALPHASCAN_H
#define BORNAGAIN_SIM_SCAN_ALPHASCAN_H
 
#include "Sim/Scan/ISpecularScan.h"
#include <memory>
 
class ParameterSample;
class IRangedDistribution;
class ScanResolution;
 
//! Scan type with inclination angles as coordinate values and a unique wavelength.
//! Features footprint correction.
class AlphaScan : public ISpecularScan {
public:
    AlphaScan(double wl, std::vector<double> inc_angle);
    AlphaScan(double wl, const IAxis& inc_angle);
    //! Sets angle-defined specular scan. The first parameter is always a wavelength in nm.
    //! Second parameter is either a numpy array of incident angles in radians or an IAxis object
    //! with angle values. Alternatively an axis can be defined in-place, then
    //! the second passed parameter is the number of bins, third - minimum on-axis angle value,
    //! fourth - maximum on-axis  angle value.
    AlphaScan(double wl, int nbins, double alpha_i_min, double alpha_i_max);
    ~AlphaScan() override;
    AlphaScan* clone() const override;
 
#ifndef SWIG
    //! Generates simulation elements for specular simulations
    std::vector<SpecularElement> generateElements() const override;
 
    //! Returns coordinate axis assigned to the data holder
    const IAxis* coordinateAxis() const override { return m_inc_angle.get(); }
 
    //! Returns IFootprintFactor object pointer
    const IFootprintFactor* footprintFactor() const override { return m_footprint.get(); }
 
    //! Returns footprint correction factor for a range of simulation elements of size _n_elements_
    //! and starting from element with index _i_.
    std::vector<double> footprint(size_t start, size_t n_elements) const override;
 
    //! Returns the number of simulation elements
    size_t numberOfElements() const override;
 
    CoordSystem1D* createCoordSystem() const override;
 
    //! Returns intensity vector corresponding to convolution of given simulation elements
    std::vector<double> createIntensities(const std::vector<SpecularElement>& eles) const override;
 
    // TODO: remove these getters after transition to the new resolution machinery is finished
    const ScanResolution* wavelengthResolution() const { return m_wl_resolution.get(); }
    const ScanResolution* angleResolution() const { return m_inc_resolution.get(); }
#endif // USER_API
 
    double wavelength() const override { return m_wl; }
 
    //! Sets footprint correction factor
    void setFootprintFactor(const IFootprintFactor* f_factor);
 
    //! Sets wavelength resolution values via ScanResolution object.
    void setWavelengthResolution(const ScanResolution& resolution);
 
    void setRelativeWavelengthResolution(const IRangedDistribution& distr, double rel_dev);
    //! Sets wavelength resolution values via IRangedDistribution and values of relative deviations
    //! (that is, _rel_dev_ equals standard deviation divided by the mean value).
    //! _rel_dev_ can be either single-valued or a numpy array. In the latter case the length of the
    //! array should coinside with the length of the inclination angle axis.
    void setRelativeWavelengthResolution(const IRangedDistribution& distr,
                                         const std::vector<double>& rel_dev);
 
    void setAbsoluteWavelengthResolution(const IRangedDistribution& distr, double std_dev);
    //! Sets wavelength resolution values via IRangedDistribution and values of standard deviations.
    //! _std_dev_ can be either single-valued or a numpy array. In the latter case the length of the
    //! array should coinside with the length of the inclination angle axis.
    void setAbsoluteWavelengthResolution(const IRangedDistribution& distr,
                                         const std::vector<double>& std_dev);
 
    //! Sets angle resolution values via ScanResolution object.
    void setAngleResolution(const ScanResolution& resolution);
 
    void setRelativeAngularResolution(const IRangedDistribution& distr, double rel_dev);
    //! Sets angular resolution values via IRangedDistribution and values of relative deviations
    //! (that is, _rel_dev_ equals standard deviation divided by the mean value).
    //! _rel_dev_ can be either single-valued or a numpy array. In the latter case the length of the
    //! array should coinside with the length of the inclination angle axis.
    void setRelativeAngularResolution(const IRangedDistribution& distr,
                                      const std::vector<double>& rel_dev);
 
    void setAbsoluteAngularResolution(const IRangedDistribution& distr, double std_dev);
    //! Sets angular resolution values via IRangedDistribution and values of standard deviations.
    //! _std_dev_ can be either single-valued or a numpy array. In the latter case the length of the
    //! array should coinside with the length of the inclination angle axis.
    void setAbsoluteAngularResolution(const IRangedDistribution& distr,
                                      const std::vector<double>& std_dev);
 
private:
    using DistrOutput = std::vector<std::vector<ParameterSample>>;
 
    void checkInitialization();
    DistrOutput applyWlResolution() const;
    DistrOutput applyIncResolution() const;
 
    const double m_wl;
    const std::unique_ptr<IAxis> m_inc_angle;
    std::unique_ptr<IFootprintFactor> m_footprint;
 
    std::unique_ptr<ScanResolution> m_wl_resolution;
    std::unique_ptr<ScanResolution> m_inc_resolution;
};
 
#endif // BORNAGAIN_SIM_SCAN_ALPHASCAN_H