FTDParametersImpl.h

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

#include "gear/FTDParameters.h"
#include "gearimpl/GearParametersImpl.h"
#include "gearimpl/FTDLayerLayoutImpl.h"


namespace gear 
{
class FTDLayerLayout;
class FTDParametersImpl : public GearParametersImpl, public FTDParameters 
{
        public: 

        FTDParametersImpl() : _ftdType(0) {}
                // Destructor.
                virtual ~FTDParametersImpl() { /* nop */; }
                
                // static constants enums( for the type of layout )
                static const int PIXEL   = 1 ;
                static const int STRIP   = 2 ;
                // for the sensitive strips, facing the IP or backing it
                static const int FACE    = 1;
                static const int BACK    = 2;

                virtual void addLayer(int nPetals, int nSensors, bool isDoubleSided, int sensorType, double petalOpAngle, double phi0, double alpha, 
                                double zposition, double zoffset, double zsign0,
                                //double supportZposition,
                                double supportRinner, double supportThickness,
                                double supportLengthMin, double supportLengthMax,
                                double supportWidth, double supportRadLength,
                                //double sensitiveZposition, 
                                double sensitiveRinner, double sensitiveThickness,
                                double sensitiveLengthMin, double sensitiveLengthMax,
                                double sensitiveWidth, double sensitiveRadLength )
                {
                        _layer.addLayer( nPetals, nSensors, isDoubleSided, sensorType, petalOpAngle,phi0, alpha, 
                                        zposition,zoffset,zsign0,
                                        //supportZposition,
                                        supportRinner,supportThickness, 
                                        supportLengthMin, supportLengthMax,
                                        supportWidth, supportRadLength,
                                        //sensitiveZposition,
                                        sensitiveRinner,sensitiveThickness,
                                        sensitiveLengthMin, sensitiveLengthMax,
                                        sensitiveWidth, sensitiveRadLength ) ;
                        return ;
                }
    

                virtual const FTDLayerLayout & getFTDLayerLayout() const { return _layer ; }
                
                
                virtual int getLayerIndex( const Vector3D & p ) const;
                
                // /** returns the petal Index which correspond to the layer where the point
                //   * is. If the point is not inside any layer returns -1
                //   */
                // virtual int getPetalIndex( const Vector3D & p ) const { return getPetalIndex(p); }
                
                virtual int getSensitiveIndex( const Vector3D & p ) const;

        protected:
                
                FTDLayerLayoutImpl _layer{} ;
                
                int _ftdType{} ;
                
                // double _shellInnerRadiusMin;
                // double _shellInnerRadiusMax;
                // double _shellOuterRadius ;
                // double _shellHalfLength ;
                // double _shellGap ;
                // double _shellRadLength ;
                
  //private:
public:
                
                bool isPointInFTD(const Vector3D & p ,const bool & sensitive = false) const ;

                int getPetalIndex(const Vector3D & p, const bool & sensitive = false) const;
                
//              Vector3D distanceToNearestFTD(Vector3D p, bool sensitive = false) const ;
                
                Vector3D distanceToPlane(Vector3D p, Vector3D r, Vector3D n, Vector3D u, 
                                Vector3D v, float minU, float maxU, float minV, float maxV) const ;
                
//              Vector3D intersectionFTD( Vector3D p, Vector3D v, bool sensitive = false) const ;
                
                Vector3D planeLineIntersection( Vector3D r, Vector3D n, Vector3D linePoint, Vector3D lineDir) const ;
                
                double confiningRatio( Vector3D p , Vector3D r, Vector3D n, Vector3D u, Vector3D v, 
                                float minU, float maxU, float minV, float maxV ) const ;
                
                Vector3D correctToBorderPoint( Vector3D vPlane , Vector3D u, Vector3D v,
                                float minU, float maxU, float minV, float maxV ) const ;
                
                bool isEqual( double valueOne , double valueTwo ) const ;
                
                bool isEqual( Vector3D p1 , Vector3D p2 ) const ;
                
                bool differsLess( double valueOne , double valueTwo ) const ;
                
                
                double correctPhiRange( double Phi ) const ;
                
                double getPhiPoint( Vector3D p ) const ;
                
}; // class

} // namespace gear

#endif /* ifndef GEAR_FTDPARAMETERS_H */