FTDLayerLayoutImpl.h

// -*- C++ -*-
#ifndef GEAR_FTDLayerLayoutImpl_H
#define GEAR_FTDLayerLayoutImpl_H 1

#include "gear/FTDLayerLayout.h"
#include <vector>
#include <math.h>

namespace gear 
{
// Helper class: Components x,y,z of a vector which defines
//               a reference frame (its module is 1), why not
//               usign Vector3D (CLHEP or GEAR)?... by the moment       
class vframe  // TO BE DEPRECATED...
{
        public:
                vframe(): x(0),y(0),z(0) { ; }
                vframe(const double & xval, const double & yval, const double & zval):
                        x(xval),y(yval),z(zval) { ; }
                ~vframe() { ; }

                double x{};
                double y{};
                double z{};
};

class FTDLayerLayoutImpl : public FTDLayerLayout 
{
        friend class FTDParametersImpl ;
        
        public: 
                struct Layer 
                {
                        int    nPetals {};    // Number of petals
                        int    nSensors {};   // Number of sensors per petal
                        bool   isDoubleSided{}; // if Petals have sensors on front AND back
                        int    sensorType {}; // The sensor type of the disk: pixel or strips
                                            // For future changes: could be extended the types
                                            // to Double Side Micro Strips, for instance...                                 
                        double petalOpenningAngle {}; // Angle defining the half-width of a petal
                        double phi0 {};       // azimuthal angle  of the first petal (paralel to Y-axis,
                                            // and in the Y-positive direction)
                        double alpha{};       // Angle of the rotation of the petal in 
                                            // its own plane (turbine-blade design)
                        double zposition{};   // Z-position of the centroid of the layer  (disk).
                        double zoffset{};     // z-distance from the zposition to the centroid
                                            // of a petal (staggered design)
                        double zsign0{};      // Sign of the zoffset of the first petal --> FIXME: int
                        double rInner{};      // Distance from Z-axis to the closest point of a petal (or sensitive)
                        double thickness {};  // thickness (petal or sensor) 
                        double lengthMin {};  // smaller length of a trapezoid (petal or sensor)
                        double lengthMax {};  // biggest length of a trapezoid (petal or sensor)
                        double width {};      // y-distance (between the lengthMin line
                                            // and the lengthMax line) for petal or sensor
                        double radLength {};  // Radiation length (petal or sensor)
                } ;
                
        
                typedef std::vector<Layer> LayerVec ;
                
                // Destructor.
                virtual ~FTDLayerLayoutImpl() { /* nop */; }
                
                virtual int getNLayers() const { return _lVec.size() ; }
                
                virtual int getNPetals(int layerIndex) const { return _lVec.at( getEquivLayer(layerIndex) ).nPetals  ; }
                
                virtual int getNSensors(int layerIndex) const { return _lVec.at( getEquivLayer(layerIndex) ).nSensors; }
                
                virtual bool isDoubleSided(int layerIndex) const { return _lVec.at( getEquivLayer(layerIndex) ).isDoubleSided; }
                
                virtual int getSensorType(int layerIndex) const { return _lVec.at(getEquivLayer(layerIndex)).sensorType; }

                virtual double getPhiHalfDistance(int layerIndex) const 
                { return _lVec.at( getEquivLayer(layerIndex) ).petalOpenningAngle  ; }

                virtual double getPhi0(const int & layerIndex) const { return _lVec.at(getEquivLayer(layerIndex)).phi0 ; }
                
                virtual double getAlpha(int layerIndex) const { return _lVec.at( getEquivLayer(layerIndex) ).alpha  ; }

                //FIXME: TO BE DEPRECATED OR PRIVATE? All the positions having to 
                //       return this class is relative to the petals or
                //       sensors. to be checked
                virtual double getZposition(const int & layerIndex) const 
                { return _lVec.at(getEquivLayer(layerIndex)).zposition ; }

                //FIXME: TO BE DEPRECATED OR PRIVATE?
                virtual double getZoffset(const int & layerIndex) const 
                { return _lVec.at(getEquivLayer(layerIndex)).zoffset ; }
                
                virtual double getZoffsetSign0(const int & layerIndex) const 
                { return _lVec.at(getEquivLayer(layerIndex)).zsign0 ; }
        
                virtual double getSupportZposition(const int & layerIndex, const int & petalIndex) const;
                
                virtual double getSupportRinner(int layerIndex) const 
                { return _lVec.at( getEquivLayer(layerIndex) ).rInner  ; }
                
                virtual double getSupportRadLength(int layerIndex) const 
                { return _lVec.at( getEquivLayer(layerIndex) ).radLength  ; }
          
                virtual double getSupportThickness(int layerIndex) const 
                { return _lVec.at( getEquivLayer(layerIndex) ).thickness  ; }
                
                // FIXME: Change Length <--> Width (I think is the usual notation)
                virtual double getSupportLengthMin(int layerIndex) const { return  _lVec.at( getEquivLayer(layerIndex) ).lengthMin  ; }
                
                // FIXME: Change Length <--> Width (I think is the usual notation)
                virtual double getSupportLengthMax(int layerIndex) const { return  _lVec.at( getEquivLayer(layerIndex) ).lengthMax  ; }
        
                // FIXME: Change Length <--> Width (I think is the usual notation)
                virtual double getSupportWidth(int layerIndex) const { return _lVec.at( getEquivLayer(layerIndex) ).width  ; }
        

                virtual double getSensitiveZposition(const int & layerIndex, const int & petalIndex, 
                                const int & sensorIndex) const;

                virtual double getSensitiveRinner(int layerIndex) const 
                { return _sVec.at( getEquivLayer(layerIndex) ).rInner  ; }

                virtual double getSensitiveRadLength(int layerIndex) const { return _sVec.at( getEquivLayer(layerIndex) ).radLength  ; }
                
                virtual double getSensitiveThickness(int layerIndex) const { return _sVec.at( getEquivLayer(layerIndex) ).thickness  ; }
                
                virtual double getSensitiveLengthMin(int layerIndex) const { return _sVec.at( getEquivLayer(layerIndex) ).lengthMin  ; }
                
                // FIXME: Change Length <--> Width (I think is the usual notation)
                virtual double getSensitiveLengthMax(int layerIndex) const { return _sVec.at( getEquivLayer(layerIndex) ).lengthMax  ; }
                
                // FIXME: Change Length <--> Width (I think is the usual notation)
                virtual double getSensitiveWidth(int layerIndex) const { return _sVec.at( getEquivLayer(layerIndex) ).width  ; }
                
        
                virtual void addLayer(int nPetals, int nSensors, bool isDoubleSided ,int sensorType, double petalOpAngle, double phi0, double alpha, 
                                      // common for support and sensitive
                                      double zposition, double zoffset, double zsign0,
                                      // support
                                      //double supportZposlayer, 
                                      double supportRinner, double supportThickness, 
                                      double supportLengthMin, double supportLengthMax,
                                      double supportWidth, 
                                      double supportRadLength,
                                      // sensitive
                                      //double sensitiveZposlayer, 
                                      double sensitiveRinner,   double sensitiveThickness,
                                      double sensitiveLengthMin, double sensitiveLengthMax,
                                      double sensitiveWidth, 
                                      double sensitiveRadLength ) ;

        
                virtual double getPhiPetalCd(const int & layerIndex, const int & petalIndex) const;

                // FIXME: To be checked if necessary
                virtual double getMaxRadius(const int & layerIndex,const bool & sensitive=false ) const ; 
                
                // FIXME: To be checked if necessary
                virtual double getStartPhi(const int & layerIndex, const int & petalInd,const bool &sensitive=false ) const ;
        
                // FIXME: To be checked if necessary
                virtual double getEndPhi(const int & layerIndex,const int & petalInd, const bool & sensitive=false ) const ;
        
                // FIXME: To be checked if necessary
                virtual double getThicknessForAngle(const int & layerIndex, const double & tetha,
                                const double & phi, const bool & sensitive=false ) const ;
        
        
        protected:
                // Support
                LayerVec _lVec {};
                // Sensitive
                LayerVec _sVec {};
        

                // Reference frame of the petal (left side ).  
                // The frame is defined in the way of that all the points inside the 
                // trapezoid are defined positives. 
                std::vector<vframe> _eL{}; //FIXME: TO BE DEPRECATED
                std::vector<vframe> _eS{}; //FIXME: TO BE DEPRECATED
                
        private:
                // Internal function to convert the raw layerIndex (which goes from 0 to 2N-1,
                // being N=total number of positive disk, to the identifier which corresponds
                // with the z-positive disks symmetric to it.
                // The positives disks have defined the raw index as 0,N-1
                // The negatives disks have defined the raw index as N,2N-1
                // So, the returned index will be the same for positives disks
                // and the correspondent value between 0,N-1 for the negative ones.
                int getEquivLayer(const int & layerIndex) const;

                // Extraction of the left side reference frame
                std::vector<vframe> getframe( const Layer & layer ); //FIXME: TO BE DEPRECATED
                
}; // class
} // namespace gear
#endif /* ifndef GEAR_FTDLAYERLAYOUT_H */