#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)
	TrapezoidSegmentation (const TrapezoidSegmentation &)=delete
	TODO contructor from BinUtilities for more complex readouts.
TrapezoidSegmentation &	operator= (const TrapezoidSegmentation &)=delete
virtual	~TrapezoidSegmentation ()
	Virtual Destructor.
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.
const DigitizationCell	cell (const Amg::Vector3D &position) const override
	Get the digitization cell from a 3D position - ignores the shift.
const DigitizationCell	cell (const Amg::Vector2D &position) const override
	Get the digitization cell from a position.
const Amg::Vector2D	cellPosition (const DigitizationCell &cId) const override
	calculate the cell Position from the Id
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.
const SurfaceBounds &	moduleBounds () const override
	return the surface bounds by reference
size_t	numCellsX () const
	Return the simple binning parameters.
size_t	numCellsY () const
	Return the simple binning parameters.

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.
double	sinStereoLocal (const Amg::Vector2D &localPos) const
	Return the local sinStereo.
double	projectLocX (const Amg::Vector2D &localPos) const
	Return the projected x value on the y=0.
double	radius () const
	Return the radius correponding to the given module.

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 21 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 42 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 134 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 47 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::shared_ptr<Trk::TrapezoidBounds> readoutPlaneBounds =
        std::make_shared<Trk::TrapezoidBounds>(m_activeBounds->minHalflengthX(),
                                               m_activeBounds->maxHalflengthX(),
                                               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
    // 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
    std::shared_ptr<Trk::TrapezoidBounds> counterPlaneBounds = readoutPlaneBounds;
    counterPlaneTransform.translation()     = Amg::Vector3D(0.,0.,-readoutDirection*halfThickness);
 
    // - build the readout & counter readout surfaces
    boundarySurfaces.push_back(std::make_shared<const Trk::PlaneSurface>(readoutPlaneTransform,readoutPlaneBounds));
    boundarySurfaces.push_back(std::make_shared<const 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
      auto xBinBounds = std::make_shared<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::make_shared<const Trk::PlaneSurface>(binTransform, xBinBounds));
      else // these are the bin boundaries
      segmentationSurfacesX.push_back(std::make_shared<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));
        auto yBinBounds = std::make_shared<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<const Trk::PlaneSurface>(binTransform,yBinBounds));
        else // these are the bin boundaries
            segmentationSurfacesY.push_back(std::make_shared<const 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 144 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