DigitizationModule.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// DigitizationModule.h, ATLAS Detector software
 
#ifndef TRKDIGEVENT_PLANARDIGITIZATIONMODULE_H
#define TRKDIGEVENT_PLANARDIGITIZATIONMODULE_H
 
// GeoPrimitives
#include "GeoPrimitives/GeoPrimitives.h"
// Trk
#include "TrkDigEvent/DigitizationCell.h"
#include "TrkDigEvent/Segmentation.h"
// STL
#include <memory>
#include <vector>
 
namespace Trk {
 
    class Surface;
 
    class DigitizationModule { 
        public :
            DigitizationModule(std::shared_ptr<const Segmentation> moduleSegmentation,
                               double halfThickness,
                               int readoutDirection,
                               double lorentzAngle);
 
            virtual ~DigitizationModule(){}
            
            const std::vector< std::shared_ptr<const Surface> > segmentationSurfaces(const DigitizationCell& entryCids, const DigitizationCell& exitCids) const;
            
            const DigitizationCell cell(const Amg::Vector2D& position) const;
            
            double halfThickness() const;
            
            int readoutDirection() const;
            
            double lorentzAngle() const;
            
            const Segmentation& segmentation() const;
            
            const std::vector< std::shared_ptr<const Surface> > stepSurfaces(const Amg::Vector3D& start, const Amg::Vector3D& end) const;
            
            const DigitizationStep digitizationStep(const Amg::Vector3D& start, const Amg::Vector3D& end) const;
            
            const std::vector< std::shared_ptr<const Surface> >& boundarySurfaces() const;
            
            const std::vector< std::shared_ptr<const Surface> >& segmentationSurfacesX() const;
            
            const std::vector< std::shared_ptr<const Surface> >& segmentationSurfacesY() const;
                        
        private:
 
            double                                         m_halfThickness;
            int                                            m_readoutDirection;      
            double                                         m_lorentzAngle;          
            double                                         m_tanLorentzAngle;       
            
            std::shared_ptr<const Segmentation>            m_segmentation;          
            std::vector< std::shared_ptr<const Surface> >  m_boundarySurfaces;      
            std::vector< std::shared_ptr<const Surface> >  m_segmentationSurfacesX; 
            std::vector< std::shared_ptr<const Surface> >  m_segmentationSurfacesY; 
    
    };
    
 
    inline double DigitizationModule::halfThickness() const
        { return m_halfThickness; }
    
    inline int DigitizationModule::readoutDirection() const
        { return m_readoutDirection; }
    
    inline double DigitizationModule::lorentzAngle() const
        { return m_lorentzAngle; }
    
    inline const Segmentation& DigitizationModule::segmentation() const
        { return (*(m_segmentation.get())); }
    
    inline const std::vector< std::shared_ptr<const Surface> >& DigitizationModule::boundarySurfaces() const
        { return m_boundarySurfaces; }
    
    inline const std::vector< std::shared_ptr<const Surface> >& DigitizationModule::segmentationSurfacesX() const
        { return m_segmentationSurfacesX; }
    
    inline const std::vector< std::shared_ptr<const Surface> >& DigitizationModule::segmentationSurfacesY() const
        { return m_segmentationSurfacesY; }
    
    inline const DigitizationStep DigitizationModule::digitizationStep(const Amg::Vector3D& start, const Amg::Vector3D& end) const
        { return m_segmentation->digitizationStep(start,end,m_halfThickness,m_readoutDirection,m_lorentzAngle); }
 
}
 
#endif