Trk::RectangularSegmentation Class Reference

#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).
	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.
	RectangularSegmentation (const RectangularSegmentation &)=delete
	TODO contructor from BinUtilities for more complex readouts.
RectangularSegmentation &	operator= (const RectangularSegmentation &)=delete
virtual	~RectangularSegmentation ()
	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 fropm a 3D position - ignores the shift.
const DigitizationCell	cell (const Amg::Vector2D &position) const override
	Get the digitization cell fropm 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 digitsation 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

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 16 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(std::move(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 37 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(std::move(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 84 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.

{ 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.

{ 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 205 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 89 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<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<Trk::SurfaceBounds> readoutPlaneBounds = moduleBounds;
    std::shared_ptr<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 = std::move(moduleBounds);
        counterPlaneTransform.translation()     = Amg::Vector3D(0.,0.,-readoutDirection*halfThickness);
    } else {
        // lorentz reduced Bounds
        double lorentzReducedHalfX = m_activeBounds->halflengthX() - std::abs(lorentzPlaneShiftX);
        std::shared_ptr<Trk::SurfaceBounds> lorentzReducedBounds(std::make_shared<Trk::RectangleBounds>(lorentzReducedHalfX,m_activeBounds->halflengthY()));
        counterPlaneBounds  = std::move(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<const Trk::PlaneSurface>(readoutPlaneTransform,readoutPlaneBounds));
    boundarySurfaces.push_back(std::make_shared<const 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<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<Trk::SurfaceBounds> lorentzPlaneBounds = (lorentzAngle==0.) ? xBinBounds :
        std::shared_ptr<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<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<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<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::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 216 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.

{ 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.

{ return m_binsX; }

numCellsY()

size_t Trk::RectangularSegmentation::numCellsY ( ) const

inline

Return the simple binning parameters.

Definition at line 104 of file RectangularSegmentation.h.

{ 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:

• RectangularSegmentation.h
• RectangularSegmentation.cxx