PndDiscSensorGrid.h

Go to the documentation of this file.

//-------------------------------------------------------------------------
// Author:      Oliver Merle (Oliver.Merle@exp2.physik.uni-giessen.de)
// Changes:     Mustafa Schmidt (Mustafa.A.Schmidt@physik.uni-giessen.de)  
// Date:        30.11.2015
// Description: Definition of sensor grid
//-------------------------------------------------------------------------

#ifndef SENSOR_GRID_HH_
#define SENSOR_GRID_HH_

#include <vector>
//#include <tr1/memory>



namespace SensorGrid {

// ======================
// =    Next steps:     =
// ======================
//
// - add similar counting like pixel number, but for dead time entity  ... 0%
// - add pixel iteration (return number and position)                  ... to test
//

// Compute number of pixels in
// a Grid and number them as:
// pixel_number_offset + ix + iy*cells_per_row


struct PixelInfo {
    int pixel_number;
    int grid_id;
    int column_on_grid;
    int row_on_grid;
};



class SensorGridBase {
public:
    SensorGridBase()
        : pixel_number_offset(0), user_row_offset(0), user_col_offset(0), number_of_pixels(0), locked(false)
    { }
    virtual ~SensorGridBase() {}
    void SetUserColumnOffset(int ofs) { user_col_offset = ofs; }
    void SetUserRowOffset(int ofs)    { user_row_offset = ofs; }
    void LockGrid(bool lock); // Function for the user to lock the root grid - will trigger enumeration.
    bool IsLocked() { return locked; }

    int GetNumberOfPixels() { return number_of_pixels; }
    virtual bool PositionToPixel(const double & x, const double & y, PixelInfo & pixel_info) const = 0;
    virtual bool PixelToPosition(PixelInfo & pixel_info, double & x, double & y) const = 0;

    virtual bool NextPixel(double & x, double & y, PixelInfo & pixel_number) const; // Pixel enumeration

protected:
    virtual void EnumerateGrids(int & id, int & pixel_offset) = 0;      // used to enumerate grids and pixel offsets.
    virtual void LockChilds(bool ) {}    // used to forward lock to children //  lock//[R.K.03/2017] unused variable(s)
    void SetPixelNumberOffset(int offset) { pixel_number_offset= offset; }

    // Proxys to method in siblings through base class:
    void EnumerateGridsProxy(SensorGridBase* b, int & grid_id, int & pixel_number) { b->EnumerateGrids(grid_id, pixel_number); }
    void LockChildsProxy(SensorGridBase* b, bool lock)                             { b->LockChilds(lock); }


protected:
    int grid_number;
    int pixel_number_offset;    
    int user_row_offset;        
    int user_col_offset;        
    int number_of_pixels;       
    bool locked;                
};


class BasicGrid : public SensorGridBase {
public:
    BasicGrid();
    BasicGrid(const double & x_min, const double & x_width, const double & x_pitch, int n_x,
              const double & y_min, const double & y_width, const double & y_pitch, int n_y); 
    virtual ~BasicGrid();

    void SetXDivision(const double & x_min, const double & x_width, const double & x_pitch, int n_x );
    void SetYDivision(const double & y_min, const double & y_width, const double & y_pitch, int n_y );

    virtual bool PositionToPixel(const double & x, const double & y, PixelInfo & pixel_info) const;
    virtual bool PixelToPosition(PixelInfo & pixel_info, double & x, double & y) const ;

    virtual void EnumerateGrids(int & id, int & pixel_offset);

protected:
    double x_min, x_width, x_pitch, x_width_over_two_pitch;
    double y_min, y_width, y_pitch, y_width_over_two_pitch;
    int    n_x, n_y;
    double x_max, y_max;
};


class MultipleGrids : public SensorGridBase {
public:
    MultipleGrids();
    virtual ~MultipleGrids();
    
    void AddGrid(SensorGridBase* grid ); // Policy: this instance will take over the ownership of grid. Do not use the grid in userspace.

    virtual void EnumerateGrids(int & id, int & pixel_offset);

    virtual bool PositionToPixel(const double & x, const double & y, PixelInfo & pixel_info) const;
    virtual bool PixelToPosition(PixelInfo & pixel_number, double & x, double & y) const ;

protected:
    virtual void LockChilds(bool lock);

    std::vector<SensorGridBase*> grids;
};

}
#endif