Datafield.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Device/Data/Datafield.h
//! @brief     Defines and implements templated class Datafield.
//!
//! @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_DEVICE_DATA_DATAFIELD_H
#define BORNAGAIN_DEVICE_DATA_DATAFIELD_H
 
#include "Base/Py/PyObject.h"
#include <memory>
#include <vector>
 
using std::size_t;
 
class IAxis;
class Frame;
 
//! Stores radiation power per bin.
//! @ingroup tools
 
class Datafield {
public:
    //! Constructor that takes ownership of supplied frame.
    Datafield(Frame* frame);
    //! Constructor that takes ownership of supplied frame.
    Datafield(Frame* frame, const std::vector<double>& vector);
 
    //! Constructor that takes ownership of supplied axes.
    Datafield(const std::vector<IAxis*>& axes);
    //! Constructor that takes ownership of supplied axes.
    Datafield(const std::vector<IAxis*>& axes, const std::vector<double>& vector);
 
    Datafield(const Datafield&) = delete;
    Datafield(Datafield&&) = default;
 
    ~Datafield();
    Datafield* clone() const;
 
    void setAt(size_t i, double val);
 
    double valAt(size_t i) const;
 
    // retrieve basic info
 
    const Frame& frame() const;
    size_t rank() const;
    const IAxis& axis(size_t k) const;
    const IAxis& xAxis() const;
    const IAxis& yAxis() const;
 
    //! Returns total size of data buffer (product of bin number in every dimension).
    size_t size() const;
 
    //! Returns copy of raw data vector
    std::vector<double> flatVector() const;
 
    double maxVal() const;
    double minVal() const;
 
    // modifiers
 
    //! Sets content of output data to specific value
    void setAllTo(const double& value);
 
    //! Sets new values to raw data vector
    void setVector(const std::vector<double>& data_vector);
 
    //! indexed accessor
    double& operator[](size_t i) { return m_vec[i]; }
 
    //! ied accessor (const)
    const double& operator[](size_t i) const { return m_vec[i]; }
 
    // helpers
 
    //! Returns true if object have same dimensions and number of axes bins
    bool hasSameSizes(const Datafield& other) const;
 
    //! Returns true if objects a) have same dimensions b) bin boundaries of axes coincide
    bool hasSameShape(const Datafield& other) const;
 
    Datafield* crop(double xmin, double ymin, double xmax, double ymax) const;
    Datafield* crop(double xmin, double xmax) const;
 
#ifdef BORNAGAIN_PYTHON
    //! Returns data as Python numpy array
    PyObject* npArray() const;
#endif
 
    Datafield* normalizedToMaximum() const;
 
    //! Project a 2D histogram into 1D histogram along X. The projection is made
    //! from all bins along y-axis.
    Datafield* xProjection();
 
    //! @brief Project a 2D histogram into 1D histogram along X. The projection is made
    //! from the y-bin closest to given ordinate yvalue.
    //! @param yvalue the value on y-axis at which projection is taken
    Datafield* xProjection(double yvalue);
 
    //! @brief Project a 2D histogram into 1D histogram along X. The projection is made from
    //! all y-bins corresponding to ordinate between ylow and yup.
    //! @param ylow lower edje on y-axis
    //! @param yup upper edje on y-axis
    Datafield* xProjection(double ylow, double yup);
 
    //! Project a 2D histogram into 1D histogram along Y. The projection is made
    //! from all bins along x-axis.
    Datafield* yProjection();
 
    //! @brief Project a 2D histogram into 1D histogram along Y. The projection is made
    //! from the x-bin closest to given abscissa xvalue.
    //! @param xvalue the value on x-axis at which projection is taken
    Datafield* yProjection(double xvalue);
 
    //! @brief Project a 2D histogram into 1D histogram along Y. The projection is made from
    //! all x-bins corresponding to abscissa between xlow and xup.
    //! @param xlow lower edje on x-axis
    //! @param xup upper edje on x-axis
    Datafield* yProjection(double xlow, double xup);
 
private:
    //! Creates projection along X. The projections is made by collecting the data in the range
    //! between [ybinlow, ybinup].
    Datafield* create_xProjection(int ybinlow, int ybinup);
 
    //! Creates projection along Y. The projections is made by collecting the data in the range
    //! between [xbinlow, xbinup].
    Datafield* create_yProjection(int xbinlow, int xbinup);
 
    std::unique_ptr<Frame> m_frame;
    std::vector<double> m_vec;
};
 
#endif // BORNAGAIN_DEVICE_DATA_DATAFIELD_H