#include <RectangularSegmentation.h>

Inheritance diagram for Trk::RectangularSegmentation:

Collaboration diagram for Trk::RectangularSegmentation:

Public Member Functions
	RectangularSegmentation (std::shared_ptr< const Trk::RectangleBounds >, size_t numCellsX, size_t numCellsY=1)
	Constructor for all same-size pixels or strips (in cas numCellsY is set to 1) More...

	RectangularSegmentation (std::shared_ptr< const Trk::RectangleBounds >, size_t numCellsX, double longY, size_t numCellsY, double numOfChips)
	Constructor for ATLAS module type pixels or strips. More...

	RectangularSegmentation (const RectangularSegmentation &)=delete
	TODO contructor from BinUtilities for more complex readouts. More...

RectangularSegmentation &	operator= (const RectangularSegmentation &)=delete

virtual	~RectangularSegmentation ()
	Virtual Destructor. More...

void	createSegmenationSurfaces (std::vector< std::shared_ptr< const Surface > > &boundarySurfaces, std::vector< std::shared_ptr< const Surface > > &segmentationSurfacesX, std::vector< std::shared_ptr< const Surface > > &segmentationSurfacesY, double halfThickness, int readoutDirection=1., double lorentzAngle=0.) const override
	Create the segmentation surfaces in X. More...

const DigitizationCell	cell (const Amg::Vector3D &position) const override
	Get the digitization cell fropm a 3D position - ignores the shift. More...

const DigitizationCell	cell (const Amg::Vector2D &position) const override
	Get the digitization cell fropm a position. More...

const Amg::Vector2D	cellPosition (const DigitizationCell &cId) const override
	calculate the cell Position from the Id More...

const DigitizationStep	digitizationStep (const Amg::Vector3D &start, const Amg::Vector3D &end, double halfThickness, int readoutDirection=1, double lorentzAngle=0.) const override
	Fill the associated digitsation cell from this start and end position, correct for lorentz effect if needed. More...

const SurfaceBounds &	moduleBounds () const override
	return the surface bounds by reference More...

size_t	numCellsX () const
	Return the simple binning parameters. More...

size_t	numCellsY () const
	Return the simple binning parameters. More...

Private Member Functions
template<class T >
const DigitizationCell	cellT (const T &position) const

Private Attributes
std::shared_ptr< const RectangleBounds >	m_activeBounds

BinUtility *	m_binUtility

size_t	m_binsX

size_t	m_binsY

Detailed Description

Definition at line 36 of file RectangularSegmentation.h.

Constructor & Destructor Documentation

◆ RectangularSegmentation() [1/3]

Trk::RectangularSegmentation::RectangularSegmentation	(	std::shared_ptr< const Trk::RectangleBounds >	mBounds,
		size_t	numCellsX,
		size_t	numCellsY = `1`
	)

Constructor for all same-size pixels or strips (in cas numCellsY is set to 1)

Definition at line 20 of file RectangularSegmentation.cxx.

                                                                                           :
    m_activeBounds(std::move(mBounds)),
    m_binUtility(nullptr),
    m_binsX(numCellsX),
    m_binsY(numCellsY)
 {
     // first the x dimension if needed
     if (numCellsX > 1)
          m_binUtility = new Trk::BinUtility(numCellsX, -m_activeBounds->halflengthX(), m_activeBounds->halflengthX(), Trk::open, Trk::binX);
     // use y dimension if needed
     if (numCellsY > 1){
         Trk::BinUtility yBinUtility(numCellsY, -m_activeBounds->halflengthY(), m_activeBounds->halflengthY(), Trk::open, Trk::binY);
         if (m_binUtility)
             (*m_binUtility) += yBinUtility;
         else
             m_binUtility = new Trk::BinUtility(yBinUtility);
     }
 }

◆ RectangularSegmentation() [2/3]

Trk::RectangularSegmentation::RectangularSegmentation	(	std::shared_ptr< const Trk::RectangleBounds >	mBounds,
		size_t	numCellsX,
		double	longY,
		size_t	numCellsY,
		double	numOfChips
	)

Constructor for ATLAS module type pixels or strips.

Constructor for ATLAS module type pixels.

Definition at line 41 of file RectangularSegmentation.cxx.

                                                                                                                                                                          :
    m_activeBounds(std::move(mBounds)),
    m_binUtility(nullptr),
    m_binsX(numCellsX),
    m_binsY(numCellsY)
 {
     // first the x dimension if needed
     if (numCellsX > 1)
          m_binUtility = new Trk::BinUtility(numCellsX, -m_activeBounds->halflengthX(), m_activeBounds->halflengthX(), Trk::open, Trk::binX);
     // use y dimension if needed
     if (numCellsY > 1){
  
       int numCellsYinChip = numCellsY/numberOfChip;
       double begin = -m_activeBounds->halflengthY();
       double end = (2. * m_activeBounds->halflengthY() / numberOfChip) - m_activeBounds->halflengthY();
       std::vector<float> boundaries;
  
       boundaries.push_back(begin);
  
       for (int i = 0; i< numberOfChip; i++){
     Trk::BinUtility SmallBinUtility((size_t) numCellsYinChip-2, begin+longY, end-longY, Trk::open, Trk::binY);
  
  
     boundaries.insert(boundaries.end(), SmallBinUtility.binningData().at(0).boundaries.begin(), SmallBinUtility.binningData().at(0).boundaries.end());
     boundaries.push_back(end);
  
     begin=end;
     end+=(2 * m_activeBounds->halflengthY() / numberOfChip);
  
       }
  
  
       if (boundaries.size() != numCellsY+1) {
         throw std::runtime_error("RectangularSegmentation: invalid numCellsY");
       }
  
       Trk::BinUtility yBinUtility(boundaries, Trk::open, Trk::binY);
       if (m_binUtility)
     (*m_binUtility) += yBinUtility;
       else
     m_binUtility = new Trk::BinUtility(yBinUtility);
  
        boundaries.clear();
     }
 }

◆ RectangularSegmentation() [3/3]

Trk::RectangularSegmentation::RectangularSegmentation ( const RectangularSegmentation & )

delete

TODO contructor from BinUtilities for more complex readouts.

◆ ~RectangularSegmentation()

Trk::RectangularSegmentation::~RectangularSegmentation ( )

virtual

Virtual Destructor.

Definition at line 88 of file RectangularSegmentation.cxx.

 {
     delete m_binUtility;
 }

Member Function Documentation

◆ cell() [1/2]

const DigitizationCell Trk::RectangularSegmentation::cell ( const Amg::Vector2D & position ) const

inlineoverridevirtual

Get the digitization cell fropm a position.

Implements Trk::Segmentation.

Definition at line 117 of file RectangularSegmentation.h.

117 { return cellT<Amg::Vector2D>(position); }

◆ cell() [2/2]

const DigitizationCell Trk::RectangularSegmentation::cell ( const Amg::Vector3D & position ) const

inlineoverridevirtual

Get the digitization cell fropm a 3D position - ignores the shift.

Implements Trk::Segmentation.

Definition at line 115 of file RectangularSegmentation.h.

115 { return cellT<Amg::Vector3D>(position); }

◆ cellPosition()

const Amg::Vector2D Trk::RectangularSegmentation::cellPosition ( const DigitizationCell & cId ) const

overridevirtual

calculate the cell Position from the Id

Implements Trk::Segmentation.

Definition at line 209 of file RectangularSegmentation.cxx.

 {
  
     // use the bin utility for this job
     double bX = m_binsX ? m_binUtility->binPosition(dCell.first,0.,0) : 0.;
     double bY = m_binsY ? m_binUtility->binPosition(dCell.second,0.,1) : 0.;
     return Amg::Vector2D(bX,bY);
 }

◆ cellT()

template<class T >

const DigitizationCell Trk::RectangularSegmentation::cellT ( const T & position ) const

private

Definition at line 106 of file RectangularSegmentation.h.

     {
         if (m_binsX == 1) 
             return DigitizationCell(0, m_binUtility->bin(position,0));
         else if (m_binsY == 1 )
             return DigitizationCell(m_binUtility->bin(position,0), 0);
         return DigitizationCell(m_binUtility->bin(position,0), m_binUtility->bin(position,1));
     }

◆ createSegmenationSurfaces()

void Trk::RectangularSegmentation::createSegmenationSurfaces	(	std::vector< std::shared_ptr< const Surface > > &	boundarySurfaces,
		std::vector< std::shared_ptr< const Surface > > &	segmentationSurfacesX,
		std::vector< std::shared_ptr< const Surface > > &	segmentationSurfacesY,
		double	halfThickness,
		int	readoutDirection = `1.`,
		double	lorentzAngle = `0.`
	)		const

overridevirtual

Create the segmentation surfaces in X.

Implements Trk::Segmentation.

Definition at line 93 of file RectangularSegmentation.cxx.

 {
     // may be needed throughout
     double lorentzAngleTan    =  std::tan(lorentzAngle);
     double lorentzPlaneShiftX = halfThickness*lorentzAngleTan;
  
     // (A) --- top/bottom surfaces -----------------------------------------------------------
     // let's create the top/botten surfaces first - we call them readout / counter readout
     // there are some things to consider
     // - they share the RectangleBounds only if the lorentzAngle is 0, otherwise only the readout surface has full length bounds like the module
     std::shared_ptr<const Trk::SurfaceBounds> moduleBounds = std::make_shared<Trk::RectangleBounds>(m_activeBounds->halflengthX(),m_activeBounds->halflengthY());
     // - they are separated by half a thickness in z
     Amg::Transform3D readoutPlaneTransform(Amg::Transform3D::Identity());
     Amg::Transform3D counterPlaneTransform(Amg::Transform3D::Identity());
     // readout and counter readout bounds, the bounds of the readout plane are like the active ones
     std::shared_ptr<const Trk::SurfaceBounds> readoutPlaneBounds = moduleBounds;
     std::shared_ptr<const Trk::SurfaceBounds> counterPlaneBounds(nullptr);
     // the transform of the readout plane is always centric
     readoutPlaneTransform.translation()     = Amg::Vector3D(0.,0.,readoutDirection*halfThickness);
     // no lorentz angle and everything is straight-forward
     if (lorentzAngle == 0.){
         counterPlaneBounds = moduleBounds;
         counterPlaneTransform.translation()     = Amg::Vector3D(0.,0.,-readoutDirection*halfThickness);
     } else {
         // lorentz reduced Bounds
         double lorentzReducedHalfX = m_activeBounds->halflengthX() - std::abs(lorentzPlaneShiftX);
         std::shared_ptr<const Trk::SurfaceBounds> lorentzReducedBounds(std::make_shared<Trk::RectangleBounds>(lorentzReducedHalfX,m_activeBounds->halflengthY()));
         counterPlaneBounds  = lorentzReducedBounds;
         // now we shift the counter plane in position - this depends on lorentz angle
         double counterPlaneShift = -readoutDirection*lorentzPlaneShiftX;
         counterPlaneTransform.translation() = Amg::Vector3D(counterPlaneShift,0.,-readoutDirection*halfThickness);
     }
     // - build the readout & counter readout surfaces
     boundarySurfaces.push_back(std::make_shared<Trk::PlaneSurface>(readoutPlaneTransform,readoutPlaneBounds));
     boundarySurfaces.push_back(std::make_shared<Trk::PlaneSurface>(counterPlaneTransform,counterPlaneBounds));
  
     // (B) - bin X and lorentz surfaces -----------------------------------------------------------
     // easy stuff first, constant pitch size and
     double pitchX             =  2.*m_activeBounds->halflengthX()/m_binsX;
  
     // now, let's create the SharedBounds of all surfaces marking x bins - choice fixes orientation of the matrix
     std::shared_ptr<const Trk::SurfaceBounds> xBinBounds(std::make_shared<Trk::RectangleBounds>(m_activeBounds->halflengthY(),halfThickness));
     // now, let's create the SharedBounds of all surfaces marking lorentz planes
     double lorentzPlaneHalfX  = std::abs(halfThickness/std::cos(lorentzAngle));
     // the bounds of the lorentz plane
     std::shared_ptr<const Trk::SurfaceBounds> lorentzPlaneBounds = (lorentzAngle==0.) ? xBinBounds :
         std::shared_ptr<const Trk::SurfaceBounds>(std::make_shared<Trk::RectangleBounds>(m_activeBounds->halflengthY(),lorentzPlaneHalfX));
  
     // now the rotation matrix for the xBins
     Amg::RotationMatrix3D xBinRotationMatrix;
     xBinRotationMatrix.col(0) = Amg::Vector3D::UnitY();
     xBinRotationMatrix.col(1) = Amg::Vector3D::UnitZ();
     xBinRotationMatrix.col(2) = Amg::Vector3D::UnitX();
     // now the lorentz plane rotation should be the xBin rotation, rotated by the lorentz angle around y
     Amg::RotationMatrix3D lorentzPlaneRotationMatrix =  (lorentzAngle !=0.) ?
         xBinRotationMatrix * Amg::AngleAxis3D(lorentzAngle, Amg::Vector3D::UnitX()) : xBinRotationMatrix;
  
     // reserve, it's always (number of bins-1) as the boundaries are within the boundarySurfaces
     segmentationSurfacesX.reserve(m_binsX);
     for (size_t ibinx = 0; ibinx <= m_binsX; ++ibinx){
            // the current step x position
            double cPosX = -m_activeBounds->halflengthX()+ibinx*pitchX;
            // (i) this is the low/high boundary --- ( ibin == 0/m_binsX )
            if (!ibinx || ibinx == m_binsX){
                // check if it a straight boundary or not: always straight for no lorentz angle, and either the first boundary or the last dependening on lorentz & readout
                bool boundaryStraight = (lorentzAngle == 0. || (!ibinx && readoutDirection*lorentzAngle > 0.) || (ibinx==m_binsX && readoutDirection*lorentzAngle < 0));
                // set the low boundary parameters : position & rotation
                Amg::Vector3D boundaryXPosition = boundaryStraight  ? Amg::Vector3D(cPosX, 0.,0.) : Amg::Vector3D(cPosX-readoutDirection*lorentzPlaneShiftX, 0., 0.);
                const Amg::RotationMatrix3D& boundaryXRotation = boundaryStraight ? xBinRotationMatrix : lorentzPlaneRotationMatrix;
                // build the rotation from it
                Amg::Transform3D boundaryXTransform(Amg::getTransformFromRotTransl(boundaryXRotation, boundaryXPosition));
                // the correct bounds for this
                std::shared_ptr<const Trk::SurfaceBounds> boundaryXBounds = boundaryStraight ? xBinBounds : lorentzPlaneBounds;
                // boundary surfaces
                boundarySurfaces.push_back(std::make_shared<const Trk::PlaneSurface>(boundaryXTransform,boundaryXBounds));
            // (ii) this is the in between bins  --- ( 1 <= ibin < m_mbnsX )
            } else {
                // shift by the lorentz angle
                Amg::Vector3D lorentzPlanePosition(cPosX-readoutDirection*lorentzPlaneShiftX, 0., 0.);
                Amg::Transform3D lorentzPlaneTransform(Amg::getTransformFromRotTransl(lorentzPlaneRotationMatrix,lorentzPlanePosition));
                // lorentz plane surfaces
                segmentationSurfacesX.push_back(std::make_shared<Trk::PlaneSurface>(lorentzPlaneTransform,lorentzPlaneBounds));
            }
     }
  
     // (C) - bin Y surfaces - everything is defined -----------------------------------------------------------
     // now the rotation matrix for the yBins - anticyclic
     Amg::RotationMatrix3D yBinRotationMatrix;
     yBinRotationMatrix.col(0) = Amg::Vector3D::UnitX();
     yBinRotationMatrix.col(1) = Amg::Vector3D::UnitZ();
     yBinRotationMatrix.col(2) = Amg::Vector3D(0.,-1.,0.);
     // easy stuff first, constant pitch in Y
     // let's create the SharedBounds of all surfaces marking y bins
     std::shared_ptr<const Trk::SurfaceBounds> yBinBounds(std::make_shared<Trk::RectangleBounds>(m_activeBounds->halflengthX(),halfThickness));
     // reserve, it's always (number of bins-1) as the boundaries are within the boundarySurfaces
     segmentationSurfacesY.reserve(m_binsY);
     for (size_t ibiny = 0; ibiny <= m_binsY; ++ibiny){
         // the position of the bin surface
         //Use the bin utility to find center of different surfaces
         double binPosY = m_binUtility->binningData().at(1).boundaries[ibiny];
         Amg::Vector3D binSurfaceCenter(0.,binPosY,0.);
         Amg::Transform3D binTransform(Amg::getTransformFromRotTransl(yBinRotationMatrix,binSurfaceCenter));
         // these are the boundaries
         if (ibiny == 0 || ibiny == m_binsY)
             boundarySurfaces.push_back(std::make_shared<Trk::PlaneSurface>(binTransform,yBinBounds));
         else // these are the bin boundaries
             segmentationSurfacesY.push_back(std::make_shared<Trk::PlaneSurface>(binTransform,yBinBounds));
     }
 }

◆ digitizationStep()

const Trk::DigitizationStep Trk::RectangularSegmentation::digitizationStep	(	const Amg::Vector3D &	start,
		const Amg::Vector3D &	end,
		double	halfThickness,
		int	readoutDirection = `1`,
		double	lorentzAngle = `0.`
	)		const

overridevirtual

Fill the associated digitsation cell from this start and end position, correct for lorentz effect if needed.

Get the digitization cell from 3D position, it used the projection to the readout surface to estimate the 2D positon.

Implements Trk::Segmentation.

Definition at line 220 of file RectangularSegmentation.cxx.

 {
     Amg::Vector3D stepCenter = 0.5*(startStep+endStep);
     // take the full drift length
     // this is the absolute drift in z
     double driftInZ     = halfThickness-readoutDirection*stepCenter.z();
     // this is the absolute drift length
     double driftLength  = driftInZ/cos(lorentzAngle);
     // project to parameter the readout surface
     double lorentzDeltaX = readoutDirection*driftInZ*tan(lorentzAngle);
     // the projected center, it has the lorentz shift applied
     Amg::Vector2D stepCenterProjected(stepCenter.x()+lorentzDeltaX,stepCenter.y());
     // the cell & its center
     Trk::DigitizationCell dCell = cell(stepCenterProjected);
     Amg::Vector2D cellCenter    = cellPosition(dCell);
     // we are ready to return what we have
     return Trk::DigitizationStep((endStep-startStep).mag(),driftLength,dCell,startStep,endStep,stepCenterProjected,cellCenter);
 }

◆ moduleBounds()

const SurfaceBounds & Trk::RectangularSegmentation::moduleBounds ( ) const

inlineoverridevirtual

return the surface bounds by reference

Implements Trk::Segmentation.

Definition at line 100 of file RectangularSegmentation.h.

100 { return (*(m_activeBounds.get())); }

◆ numCellsX()

size_t Trk::RectangularSegmentation::numCellsX ( ) const

inline

Return the simple binning parameters.

Definition at line 102 of file RectangularSegmentation.h.

102 { return m_binsX; }

◆ numCellsY()

size_t Trk::RectangularSegmentation::numCellsY ( ) const

inline

Return the simple binning parameters.

Definition at line 104 of file RectangularSegmentation.h.

104 { return m_binsY; }

◆ operator=()

RectangularSegmentation& Trk::RectangularSegmentation::operator= ( const RectangularSegmentation & )

delete

Member Data Documentation

◆ m_activeBounds

std::shared_ptr<const RectangleBounds> Trk::RectangularSegmentation::m_activeBounds

private

Definition at line 93 of file RectangularSegmentation.h.

◆ m_binsX

size_t Trk::RectangularSegmentation::m_binsX

private

Definition at line 95 of file RectangularSegmentation.h.

◆ m_binsY

size_t Trk::RectangularSegmentation::m_binsY

private

Definition at line 96 of file RectangularSegmentation.h.

◆ m_binUtility

BinUtility* Trk::RectangularSegmentation::m_binUtility

private

Definition at line 94 of file RectangularSegmentation.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RectangularSegmentation() [1/3]

◆ RectangularSegmentation() [2/3]

◆ RectangularSegmentation() [3/3]

◆ ~RectangularSegmentation()

Member Function Documentation

◆ cell() [1/2]

◆ cell() [2/2]

◆ cellPosition()

◆ cellT()

◆ createSegmenationSurfaces()

◆ digitizationStep()

◆ moduleBounds()

◆ numCellsX()

◆ numCellsY()

◆ operator=()

Member Data Documentation

◆ m_activeBounds

◆ m_binsX

◆ m_binsY

◆ m_binUtility