Trk::DigitizationModule Class Reference

Class that holds the surfaces for a planar digitization detector module. More...

#include <DigitizationModule.h>

Collaboration diagram for Trk::DigitizationModule:

Public Member Functions
	DigitizationModule (std::shared_ptr< const Segmentation > moduleSegmentation, double halfThickness, int readoutDirection, double lorentzAngle)
	Constructor from a Segmentation descriptor.
virtual	~DigitizationModule ()
	Virtual Destructor.
const std::vector< std::shared_ptr< const Surface > >	segmentationSurfaces (const DigitizationCell &entryCids, const DigitizationCell &exitCids) const
	Return the internal test segmentation surfaces to test between entry and exit given by their cell id's - the boundaries are not given.
const DigitizationCell	cell (const Amg::Vector2D &position) const
	Get the digitization cell fropm a position.
double	halfThickness () const
	module thickness
int	readoutDirection () const
	return the readout direction
double	lorentzAngle () const
	return the lorentz Angle
const Segmentation &	segmentation () const
	return the segmenation
const std::vector< std::shared_ptr< const Surface > >	stepSurfaces (const Amg::Vector3D &start, const Amg::Vector3D &end) const
	return the test surfaces between these points
const DigitizationStep	digitizationStep (const Amg::Vector3D &start, const Amg::Vector3D &end) const
	Fill the associated digitsation cell from this start and end position, correct for lorentz effect if needed.
const std::vector< std::shared_ptr< const Surface > > &	boundarySurfaces () const
	return the bounding surfaces at top and bottom
const std::vector< std::shared_ptr< const Surface > > &	segmentationSurfacesX () const
	return all surfaces in X - excluding the boundaries
const std::vector< std::shared_ptr< const Surface > > &	segmentationSurfacesY () const
	return all surfaces in Y - excluding the boundaries

Private Attributes
double	m_halfThickness
int	m_readoutDirection
	defines if the readout is along (+1) / (-1) wrt the z axis
double	m_lorentzAngle
	the lorentz angle
double	m_tanLorentzAngle
	and the tangent of it
std::shared_ptr< const Segmentation >	m_segmentation
	segmentation descriptor
std::vector< std::shared_ptr< const Surface > >	m_boundarySurfaces
	boundary surfaces, they are ordered: readout, opposite, x boundaries, y boundaries
std::vector< std::shared_ptr< const Surface > >	m_segmentationSurfacesX
	segmentation surfaces in X - without boundaries
std::vector< std::shared_ptr< const Surface > >	m_segmentationSurfacesY
	segmentation surfaces in Y - without boundaries

Detailed Description

Class that holds the surfaces for a planar digitization detector module.

It needs a descriptor to design different pixel/strixels/strip setups (with a segmentation class)

The digitizaiton is done in the local frame of the surface and binning can be done in local x and local y direction.

The lorentz angle is assumed to be only in x-direction and constant for the module, it is measured from the local z-direction.

The readout direction defines the charge drift either: a) towards the surface at -halfThickness if readout is defined at -1 b) towards the surface at +halfThickness if readout is defined at +1

Conventions:

• 3D positions are within the 3D frame of the module
• 2D positions are corrected to parameter surface at the center of the module (and not the readout surface)

The lorenzShift is the correction from the readout surface to the parameter surface

Author

Andreas.Salzburger -at- cern.ch

Definition at line 50 of file DigitizationModule.h.

Constructor & Destructor Documentation

DigitizationModule()

Trk::DigitizationModule::DigitizationModule	(	std::shared_ptr< const Segmentation >	moduleSegmentation,
		double	halfThickness,
		int	readoutDirection,
		double	lorentzAngle )

Constructor from a Segmentation descriptor.

Definition at line 11 of file DigitizationModule.cxx.

                                                                 :
   
   m_halfThickness(halfThickness),
   m_readoutDirection(readoutDirection),
   m_lorentzAngle(lorentzAngle),
   m_tanLorentzAngle(tan(lorentzAngle)),
   m_segmentation(std::move(moduleSegmentation)),
   m_boundarySurfaces(),           
   m_segmentationSurfacesX(),
   m_segmentationSurfacesY()
{
    m_segmentation->createSegmenationSurfaces(m_boundarySurfaces,
                                              m_segmentationSurfacesX,
                                              m_segmentationSurfacesY,
                                              halfThickness,
                                              readoutDirection, 
                                              lorentzAngle);
}

~DigitizationModule()

virtual Trk::DigitizationModule::~DigitizationModule ( )

inlinevirtual

Virtual Destructor.

Definition at line 59 of file DigitizationModule.h.

{}

Member Function Documentation

boundarySurfaces()

const std::vector< std::shared_ptr< const Surface > > & Trk::DigitizationModule::boundarySurfaces ( ) const

inline

return the bounding surfaces at top and bottom

Definition at line 121 of file DigitizationModule.h.

        { return m_boundarySurfaces; }

cell()

const DigitizationCell Trk::DigitizationModule::cell

(

const Amg::Vector2D &

position

)

const

Get the digitization cell fropm a position.

digitizationStep()

const DigitizationStep Trk::DigitizationModule::digitizationStep ( const Amg::Vector3D & start, const Amg::Vector3D & end ) const

inline

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

Definition at line 130 of file DigitizationModule.h.

        { return m_segmentation->digitizationStep(start,end,m_halfThickness,m_readoutDirection,m_lorentzAngle); }

halfThickness()

double Trk::DigitizationModule::halfThickness ( ) const

inline

module thickness

Definition at line 109 of file DigitizationModule.h.

        { return m_halfThickness; }

lorentzAngle()

double Trk::DigitizationModule::lorentzAngle ( ) const

inline

return the lorentz Angle

Definition at line 115 of file DigitizationModule.h.

        { return m_lorentzAngle; }

readoutDirection()

int Trk::DigitizationModule::readoutDirection ( ) const

inline

return the readout direction

Definition at line 112 of file DigitizationModule.h.

        { return m_readoutDirection; }

segmentation()

const Segmentation & Trk::DigitizationModule::segmentation ( ) const

inline

return the segmenation

Definition at line 118 of file DigitizationModule.h.

        { return (*(m_segmentation.get())); }

segmentationSurfaces()

const std::vector< std::shared_ptr< const Trk::Surface > > Trk::DigitizationModule::segmentationSurfaces	(	const DigitizationCell &	entryCids,
		const DigitizationCell &	exitCids ) const

Return the internal test segmentation surfaces to test between entry and exit given by their cell id's - the boundaries are not given.

Definition at line 33 of file DigitizationModule.cxx.

{
    std::vector< std::shared_ptr<const Trk::Surface> > sSurfaces;
    
    int startbinX = entryCids.first;
    int endbinX   = exitCids.first;
    // swap if needed
    if (startbinX > endbinX) std::swap(startbinX,endbinX);
    // now cash in the rest
    for ( ; startbinX <= endbinX; ++startbinX)
        sSurfaces.push_back(m_segmentationSurfacesX[startbinX]);
    
    // start bin, end bin
    int startbinY = entryCids.second;
    int endbinY   = exitCids.second;
    // swap if needed
    if (startbinY > endbinY) std::swap(startbinY,endbinY);
    // now cash in the rest
    for ( ; startbinY <= endbinY; ++startbinY)
        sSurfaces.push_back(m_segmentationSurfacesY[startbinY]);
 
    // return what you have 
    return sSurfaces;  
}  

segmentationSurfacesX()

const std::vector< std::shared_ptr< const Surface > > & Trk::DigitizationModule::segmentationSurfacesX ( ) const

inline

return all surfaces in X - excluding the boundaries

Definition at line 124 of file DigitizationModule.h.

        { return m_segmentationSurfacesX; }

segmentationSurfacesY()

const std::vector< std::shared_ptr< const Surface > > & Trk::DigitizationModule::segmentationSurfacesY ( ) const

inline

return all surfaces in Y - excluding the boundaries

Definition at line 127 of file DigitizationModule.h.

        { return m_segmentationSurfacesY; }

stepSurfaces()

const std::vector< std::shared_ptr< const Trk::Surface > > Trk::DigitizationModule::stepSurfaces	(	const Amg::Vector3D &	start,
		const Amg::Vector3D &	end ) const

return the test surfaces between these points

Definition at line 58 of file DigitizationModule.cxx.

{
    // prepare the return vector
    std::vector< std::shared_ptr<const Trk::Surface> > stepSurfaces;
    
    const Trk::DigitizationCell startCell = m_segmentation->cell(start);
    const Trk::DigitizationCell endCell   = m_segmentation->cell(end);
    
    // go along x - first with the naive binning (i.e. w.o lorentz angle)
    size_t sCellX = startCell.first;
    size_t eCellX = endCell.first;
    if (sCellX > eCellX) std::swap(sCellX,eCellX);
    // now take the boundaries as well
    if (sCellX > 0) --sCellX;
    ++eCellX;
    // the surfaces along Y are easy, just the bin surfaces
    size_t sCellY = startCell.second; 
    size_t eCellY = endCell.second;  
    if (sCellY > eCellY) std::swap(sCellY,eCellY);
    // reserve - be safe
    stepSurfaces.reserve((eCellY-sCellY)+(eCellX-sCellX)+2);
    // now fill the x surfaces
    for ( ; sCellX <= eCellX && sCellX < m_segmentationSurfacesX.size(); ++sCellX)
        stepSurfaces.push_back(m_segmentationSurfacesX[sCellX]);
    // end fill the y surfaces
    for ( ; sCellY <= eCellY && sCellY < m_segmentationSurfacesY.size(); ++sCellY)
        stepSurfaces.push_back(m_segmentationSurfacesY[sCellY]);
    // return the lot
    return  stepSurfaces;   
}

Member Data Documentation

m_boundarySurfaces

std::vector< std::shared_ptr<const Surface> > Trk::DigitizationModule::m_boundarySurfaces

private

boundary surfaces, they are ordered: readout, opposite, x boundaries, y boundaries

Definition at line 102 of file DigitizationModule.h.

m_halfThickness

double Trk::DigitizationModule::m_halfThickness

private

Definition at line 96 of file DigitizationModule.h.

m_lorentzAngle

double Trk::DigitizationModule::m_lorentzAngle

private

the lorentz angle

Definition at line 98 of file DigitizationModule.h.

m_readoutDirection

int Trk::DigitizationModule::m_readoutDirection

private

defines if the readout is along (+1) / (-1) wrt the z axis

Definition at line 97 of file DigitizationModule.h.

m_segmentation

std::shared_ptr<const Segmentation> Trk::DigitizationModule::m_segmentation

private

segmentation descriptor

Definition at line 101 of file DigitizationModule.h.

m_segmentationSurfacesX

std::vector< std::shared_ptr<const Surface> > Trk::DigitizationModule::m_segmentationSurfacesX

private

segmentation surfaces in X - without boundaries

Definition at line 103 of file DigitizationModule.h.

m_segmentationSurfacesY

std::vector< std::shared_ptr<const Surface> > Trk::DigitizationModule::m_segmentationSurfacesY

private

segmentation surfaces in Y - without boundaries

Definition at line 104 of file DigitizationModule.h.

m_tanLorentzAngle

double Trk::DigitizationModule::m_tanLorentzAngle

private

and the tangent of it

Definition at line 99 of file DigitizationModule.h.

---

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

• DigitizationModule.h
• DigitizationModule.cxx