#include <TrapezoidSegmentation.h>

Inheritance diagram for Trk::TrapezoidSegmentation:

Collaboration diagram for Trk::TrapezoidSegmentation:

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

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

TrapezoidSegmentation &	operator= (const TrapezoidSegmentation &)=delete

virtual	~TrapezoidSegmentation ()
	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 from a 3D position - ignores the shift. More...

const DigitizationCell	cell (const Amg::Vector2D &position) const override
	Get the digitization cell from 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 digitisation 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

double	PitchX (const Amg::Vector2D &localPos) const
	Return the local pitch X More...

double	sinStereoLocal (const Amg::Vector2D &localPos) const
	Return the local sinStereo More...

double	projectLocX (const Amg::Vector2D &localPos) const
	Return the projected x value on the y=0. More...

double	radius () const
	Return the radius correponding to the given module. More...

Private Attributes
std::shared_ptr< const TrapezoidBounds >	m_activeBounds

BinUtility *	m_binUtility

size_t	m_binsX

size_t	m_binsY

Detailed Description

Definition at line 36 of file TrapezoidSegmentation.h.

Constructor & Destructor Documentation

◆ TrapezoidSegmentation() [1/2]

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

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

Definition at line 22 of file TrapezoidSegmentation.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, -0.5*(m_activeBounds->minHalflengthX()+m_activeBounds->maxHalflengthX()), 0.5*(m_activeBounds->minHalflengthX()+m_activeBounds->maxHalflengthX()), 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);
     }           
 }       

◆ TrapezoidSegmentation() [2/2]

Trk::TrapezoidSegmentation::TrapezoidSegmentation ( const TrapezoidSegmentation & )

delete

TODO contructor from BinUtilities for more complex readouts.

◆ ~TrapezoidSegmentation()

Trk::TrapezoidSegmentation::~TrapezoidSegmentation ( )

virtual

Virtual Destructor.

Definition at line 43 of file TrapezoidSegmentation.cxx.

 {
     delete m_binUtility;
 }

Member Function Documentation

◆ cell() [1/2]

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

inlineoverridevirtual

Get the digitization cell from a position.

Implements Trk::Segmentation.

Definition at line 130 of file TrapezoidSegmentation.h.

                                                                                                { 
       using Trk::locX;
       using Trk::locY;
       Amg::Vector2D CorrPosition = position;
       CorrPosition[Trk::locX] = projectLocX(Amg::Vector2D(CorrPosition[Trk::locX], CorrPosition[Trk::locY]));
       return cellT<Amg::Vector2D>(CorrPosition);  
     }

◆ cell() [2/2]

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

inlineoverridevirtual

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

Implements Trk::Segmentation.

Definition at line 124 of file TrapezoidSegmentation.h.

                                                                                                { 
       Amg::Vector3D CorrPosition = position;
       CorrPosition.x() = projectLocX(Amg::Vector2D(CorrPosition.x(), CorrPosition.y()));
       return cellT<Amg::Vector3D>(CorrPosition); 
     }

◆ cellPosition()

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

overridevirtual

calculate the cell Position from the Id

Implements Trk::Segmentation.

Definition at line 135 of file TrapezoidSegmentation.cxx.

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

◆ cellT()

template<class T >

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

private

Definition at line 115 of file TrapezoidSegmentation.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::TrapezoidSegmentation::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 48 of file TrapezoidSegmentation.cxx.

 {
     // The Lorentz angle is not taken into account for trapezoidal segmentation
     // (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 only the readout surface, then the segmentation surfaces are tilted and cannot be shared on the same module
     std::unique_ptr<Trk::TrapezoidBounds> moduleTrapBounds(new Trk::TrapezoidBounds(m_activeBounds->minHalflengthX(),m_activeBounds->maxHalflengthX(),m_activeBounds->halflengthY()));
     Trk::SharedObject<const Trk::SurfaceBounds> moduleBounds(&*moduleTrapBounds);
     // - 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
     const Trk::SharedObject<const Trk::SurfaceBounds>& readoutPlaneBounds = moduleBounds;
     Trk::SharedObject<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
     counterPlaneBounds = moduleBounds;
     counterPlaneTransform.translation()     = Amg::Vector3D(0.,0.,-readoutDirection*halfThickness);
     
     // - build the readout & counter readout surfaces
     boundarySurfaces.push_back(std::shared_ptr<const Trk::PlaneSurface>(new Trk::PlaneSurface(readoutPlaneTransform,readoutPlaneBounds)));
     boundarySurfaces.push_back(std::shared_ptr<const Trk::PlaneSurface>(new Trk::PlaneSurface(counterPlaneTransform,counterPlaneBounds)));
     
     // (B) - bin X -----------------------------------------------------------
     // easy stuff first, constant pitch size and 
     double pitchX             =  2.*(m_activeBounds->maxHalflengthX()+m_activeBounds->minHalflengthX())*0.5/m_binsX;
  
     // 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();
     
     // 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->minHalflengthX()+m_activeBounds->maxHalflengthX())*0.5+ibinx*pitchX;
       
       // set position & rotation for all (boundaries and segmentations) --> Then you separate between them
       Amg::Vector3D xPosition = Amg::Vector3D(cPosX, 0.,0.);
       double stereoLocal = asin(sinStereoLocal(Amg::Vector2D(cPosX, 0.)));
       const Amg::RotationMatrix3D xRotation = xBinRotationMatrix*Amg::AngleAxis3D(stereoLocal, Amg::Vector3D::UnitY()); 
       // build the rotation from it
       Amg::Transform3D binTransform(Amg::getTransformFromRotTransl(xRotation, xPosition));
       // the correct bounds for this
       std::unique_ptr<Trk::RectangleBounds> xBinBounds(new Trk::RectangleBounds(m_activeBounds->halflengthY()/cos(stereoLocal),halfThickness));
       // these are the boundaries
       if (ibinx==0 || ibinx == m_binsX) // (i) this is the low/high boundary --- ( ibin == 0/m_binsX )
     boundarySurfaces.push_back(std::shared_ptr<const Trk::PlaneSurface>(new Trk::PlaneSurface(binTransform,&*xBinBounds)));
       else // these are the bin boundaries
     segmentationSurfacesX.push_back(std::shared_ptr<const Trk::PlaneSurface>(new Trk::PlaneSurface(binTransform,&*xBinBounds)));
     }
     
     // (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 
     double pitchY             =  2.*m_activeBounds->halflengthY()/m_binsY;
     // 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
         double binPosY = -m_activeBounds->halflengthY()+ibiny*pitchY;
         Amg::Vector3D binSurfaceCenter(0.,binPosY,0.);
     double localPitchX = PitchX(Amg::Vector2D(0., binPosY));
   std::unique_ptr<Trk::RectangleBounds> yBinBounds(new Trk::RectangleBounds(localPitchX*m_binsX*0.5,halfThickness));
   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::TrapezoidSegmentation::digitizationStep	(	const Amg::Vector3D &	start,
		const Amg::Vector3D &	end,
		double	halfThickness,
		int	readoutDirection = `1`,
		double	lorentzAngle = `0.`
	)		const

overridevirtual

Fill the associated digitisation 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 145 of file TrapezoidSegmentation.cxx.

 {
    
     Amg::Vector3D stepCenter = 0.5*(startStep+endStep);
     // project to parameter surface
     double lorentzDeltaX = -readoutDirection*stepCenter.z()*std::tan(lorentzAngle);
     // take the full drift length
     double driftInZ = (halfThickness-readoutDirection*stepCenter.z());
     double driftLength  = std::abs(driftInZ/std::cos(lorentzAngle)); 
     // the projected center
     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::TrapezoidSegmentation::moduleBounds ( ) const

inlineoverridevirtual

return the surface bounds by reference

Implements Trk::Segmentation.

Definition at line 109 of file TrapezoidSegmentation.h.

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

◆ numCellsX()

size_t Trk::TrapezoidSegmentation::numCellsX ( ) const

inline

Return the simple binning parameters.

Definition at line 111 of file TrapezoidSegmentation.h.

111 { return m_binsX; }

◆ numCellsY()

size_t Trk::TrapezoidSegmentation::numCellsY ( ) const

inline

Return the simple binning parameters.

Definition at line 113 of file TrapezoidSegmentation.h.

113 { return m_binsY; }

◆ operator=()

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

delete

◆ PitchX()

double Trk::TrapezoidSegmentation::PitchX ( const Amg::Vector2D & localPos ) const

private

Return the local pitch X

Definition at line 152 of file TrapezoidSegmentation.h.

                                                                           {
       using Trk::locY;
       double tanPhi = (m_activeBounds->maxHalflengthX()-m_activeBounds->minHalflengthX())/m_activeBounds->halflengthY();
       double lengthXatHit = (radius()+localPos[Trk::locY])*tanPhi;
       return lengthXatHit/float(m_binsX);
     }

◆ projectLocX()

double Trk::TrapezoidSegmentation::projectLocX ( const Amg::Vector2D & localPos ) const

private

Return the projected x value on the y=0.

Definition at line 159 of file TrapezoidSegmentation.h.

                                                                                {
       return -radius()*tan(asin(sinStereoLocal(localPos)));
     }

◆ radius()

double Trk::TrapezoidSegmentation::radius ( ) const

private

Return the radius correponding to the given module.

Definition at line 138 of file TrapezoidSegmentation.h.

     {
       return m_activeBounds->halflengthY()/(m_activeBounds->maxHalflengthX() - m_activeBounds->minHalflengthX())*(m_activeBounds->maxHalflengthX() + m_activeBounds->minHalflengthX());
     }

◆ sinStereoLocal()

double Trk::TrapezoidSegmentation::sinStereoLocal ( const Amg::Vector2D & localPos ) const

private

Return the local sinStereo

Definition at line 143 of file TrapezoidSegmentation.h.

                                                                                   {
       using Trk::locX;
       using Trk::locY;
       double oneOverRadius = 1./radius();
       double x = localPos[Trk::locX];
       double y = localPos[Trk::locY];
       return -x*oneOverRadius / sqrt( (1+y*oneOverRadius)*(1+y*oneOverRadius) + x*oneOverRadius*x*oneOverRadius ); 
     }

Member Data Documentation

◆ m_activeBounds

std::shared_ptr<const TrapezoidBounds> Trk::TrapezoidSegmentation::m_activeBounds

private

Definition at line 102 of file TrapezoidSegmentation.h.

◆ m_binsX

size_t Trk::TrapezoidSegmentation::m_binsX

private

Definition at line 104 of file TrapezoidSegmentation.h.

◆ m_binsY

size_t Trk::TrapezoidSegmentation::m_binsY

private

Definition at line 105 of file TrapezoidSegmentation.h.

◆ m_binUtility

BinUtility* Trk::TrapezoidSegmentation::m_binUtility

private

Definition at line 103 of file TrapezoidSegmentation.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

◆ TrapezoidSegmentation() [1/2]

◆ TrapezoidSegmentation() [2/2]

◆ ~TrapezoidSegmentation()

Member Function Documentation

◆ cell() [1/2]

◆ cell() [2/2]

◆ cellPosition()

◆ cellT()

◆ createSegmenationSurfaces()

◆ digitizationStep()

◆ moduleBounds()

◆ numCellsX()

◆ numCellsY()

◆ operator=()

◆ PitchX()

◆ projectLocX()

◆ radius()

◆ sinStereoLocal()

Member Data Documentation

◆ m_activeBounds

◆ m_binsX

◆ m_binsY

◆ m_binUtility