VersatileDiskRowLayout.h

#ifndef VersatileDiskRowLayout_h
#define VersatileDiskRowLayout_h 1

#include <vector>
#include "gearimpl/FixedDiskLayoutBase.h"


namespace gear {

class VersatileDiskRowLayout : public FixedDiskLayoutBase {
    
    public:
        
        class Row
        {
        protected:
            int _rowNumber{}; 
            int _nPads{}; 
            double _padPitch_mm{}; 
            double _padPitch{}; 
            double _padWidth_mm{}; 
            double _padWidth{}; 
            double _rowHeight{}; 
            double _padHeight{}; 
            double _offset_mm{}; 
            double _offset{}; 

            double _rCentre{}; 

            double _phiMax{}; 
            double _rMin{}; 
            double _rMax{}; 

            double distanceToPhiMin(double r, double phi) const;
            double distanceToPhiMax(double r, double phi) const;

        public:
            Row(int rowNumber, int nPads, double rCentre, double padPitch_mm, double rowHeight,
                double padWidth_mm, double padHeight, double offset_mm);
            int    getRowNumber()   const {return _rowNumber;}
            int    getNPads()       const {return _nPads;}
            double getPadPitch_mm() const {return _padPitch_mm;}
            double getPadPitch()    const {return _padPitch;}
            double getPadWidth_mm() const {return _padWidth_mm;}
            double getPadWidth()    const {return _padWidth;}
            double getRowHeight()   const {return _rowHeight;}
            double getPadHeight()   const {return _padHeight;}
            double getOffset_mm()   const {return _offset_mm;}
            double getOffset()      const {return _offset;}
            double getRCentre()     const {return _rCentre;}
            double getPhiMin()      const {return _offset;}
            double getPhiMax()      const {return _phiMax;}
            double getRMin()        const {return _rMin;}
            double getRMax()        const {return _rMax;}

            double getDistanceToRow(double r, double phi) const;

            int getNearestPad(double r, double phi) const;
        };
    

    protected:

        int _nPad {}; 
        std::vector<Row> _rows {}; 
        std::vector<double> _extent {}; 
        mutable std::vector< std::vector<int>* > _padIndices {}; 

        bool _isFrayed {};

        void copy_and_assign(const  VersatileDiskRowLayout & );

        void cleanup();
        
        
    public: 
        
        VersatileDiskRowLayout( double rMin ) ;
    
        VersatileDiskRowLayout( const VersatileDiskRowLayout &);
        
        VersatileDiskRowLayout & operator = ( const VersatileDiskRowLayout &);
        
        virtual ~VersatileDiskRowLayout() ; 
        
        /* The clone function. Used to access the copy-constructor if this class via the
         * acstract PadRowLayout2D interface.
         */
        PadRowLayout2D* clone() const;
        
        virtual void addRow(  int nPads , double padPitch , double rowHeight , 
                              double offset = 0., double padWidth =0., double padHeight = 0., 
                              int repeat = 1);
        
        virtual int getPadLayoutImplType() const { return PadRowLayout2D::VERSATILEDISKROWLAYOUT; } 

        virtual int getPadLayoutType() const;
        
        /* The type of the row layout: PadRowLayout2D::POLAR.
         */
        //
        // Already implemented in FixedDiskLayoutBase
        //virtual int getCoordinateType() const { return PadRowLayout2D::POLAR ; } 
        
        virtual int getPadShape() const { return PadRowLayout2D::RECTANGLE ; }
        
        virtual int getNPads() const { return _nPad ; }
        
        virtual int getNRows() const ;
        
        virtual double getRowHeight(int rowNumber) const;
        
        virtual double getPadHeight(int padIndex) const;
        
        virtual double getPadWidth(int padIndex) const ;
        
        virtual double getPadPitch(int padIndex) const ;
        
        virtual Vector2D getPadCenter(int padIndex)  const;
        
        
        virtual const std::vector<int>& getPadsInRow(int rowNumber) const ;
        
        virtual const std::vector<double>& getPlaneExtent()  const { return _extent ; }
        
        virtual int getRowNumber(int padIndex)  const;
        
        virtual int getPadNumber(int padIndex) const { return ( 0x0000ffff & padIndex ) ; }
        
        virtual int getPadIndex(int rowNum, int padNum)  const;
        
        virtual int getNearestPad(double c0, double c1)  const;
        
        virtual int getRightNeighbour(int padIndex)  const;
        
        virtual int getLeftNeighbour(int padIndex)  const;
        
        virtual bool isInsidePad(double c0, double c1, int padIndex)  const;
        
        virtual bool isInsidePad(double c0, double c1)  const;
        
        virtual bool isFrayed() const { return _isFrayed;}

        const std::vector<Row>& rows() const { return _rows ; }

    }; // class
    
} // namespace gear
#endif // ifndef VersatileDiskRowLayout_h