TTStubAlgorithm_official< T > Class Template Reference

Class for "official" algorithm to be used in TTStubBuilder. More...

#include <TTStubAlgorithm_official.h>

Inheritance diagram for TTStubAlgorithm_official< T >:

Public Member Functions
float	degradeBend (bool psModule, int window, int bend) const
template<>
float	degradeBend (bool psModule, int window, int bend) const
template<>
float	degradeBend (bool psModule, int window, int bend) const
template<>
void	PatternHitCorrelation (bool &aConfirmation, int &aDisplacement, int &anOffset, float &anHardBend, const TTStub< Ref_Phase2TrackerDigi_ > &aTTStub) const
	Implementation of methods of TTStubAlgorithm_official. More...
template<>
void	PatternHitCorrelation (bool &aConfirmation, int &aDisplacement, int &anOffset, float &anHardBend, const TTStub< Ref_Phase2TrackerDigi_ > &aTTStub) const
	Close class. More...
void	PatternHitCorrelation (bool &aConfirmation, int &aDisplacement, int &anOffset, float &anHardBend, const TTStub< T > &aTTStub) const override
	Matching operations. More...
	TTStubAlgorithm_official (const TrackerGeometry *const theTrackerGeom, const TrackerTopology *const theTrackerTopo, std::vector< double > setBarrelCut, std::vector< std::vector< double >> setRingCut, std::vector< std::vector< double >> setTiltedCut, std::vector< double > setBarrelNTilt, bool aPerformZMatchingPS, bool aPerformZMatching2S)
	Constructor. More...
	~TTStubAlgorithm_official () override
	Destructor. More...
Public Member Functions inherited from TTStubAlgorithm< T >
virtual std::string	AlgorithmName () const
	Algorithm name. More...
	TTStubAlgorithm (const TrackerGeometry *const theTrackerGeom, const TrackerTopology *const theTrackerTopo, std::string fName)
	Constructors. More...
virtual	~TTStubAlgorithm ()
	Destructor. More...

Private Attributes
std::vector< double >	barrelCut
std::vector< double >	barrelNTilt
std::string	className_
bool	m_tilted
bool	mPerformZMatching2S
bool	mPerformZMatchingPS
	Data members. More...
std::vector< std::vector< double > >	ringCut
std::vector< std::vector< double > >	tiltedCut

Additional Inherited Members
Protected Attributes inherited from TTStubAlgorithm< T >
std::string	className_
const TrackerGeometry *const	theTrackerGeom_
	Data members. More...
const TrackerTopology *const	theTrackerTopo_

Detailed Description

template<typename T>
class TTStubAlgorithm_official< T >

Class for "official" algorithm to be used in TTStubBuilder.

HW-friendly algorithm: layer-wise LUT. After moving from SimDataFormats to DataFormats, the template structure of the class was maintained in order to accomodate any types other than PixelDigis in case there is such a need in the future.

Author

Nicola Pozzobon

Sebastien Viret

Date

2013, Jul 18

Definition at line 37 of file TTStubAlgorithm_official.h.

Constructor & Destructor Documentation

TTStubAlgorithm_official()

template<typename T >

TTStubAlgorithm_official< T >::TTStubAlgorithm_official ( const TrackerGeometry *const  theTrackerGeom, const TrackerTopology *const  theTrackerTopo, std::vector< double >  setBarrelCut, std::vector< std::vector< double >>  setRingCut, std::vector< std::vector< double >>  setTiltedCut, std::vector< double >  setBarrelNTilt, bool  aPerformZMatchingPS, bool  aPerformZMatching2S  )

inline

Constructor.

Definition at line 52 of file TTStubAlgorithm_official.h.

      : TTStubAlgorithm<T>(theTrackerGeom, theTrackerTopo, __func__) {
    barrelCut = setBarrelCut;
    ringCut = setRingCut;
    tiltedCut = setTiltedCut;
    barrelNTilt = setBarrelNTilt;
    mPerformZMatchingPS = aPerformZMatchingPS;
    mPerformZMatching2S = aPerformZMatching2S;
  }

References TTStubAlgorithm_official< T >::barrelCut, TTStubAlgorithm_official< T >::barrelNTilt, TTStubAlgorithm_official< T >::mPerformZMatching2S, TTStubAlgorithm_official< T >::mPerformZMatchingPS, TTStubAlgorithm_official< T >::ringCut, and TTStubAlgorithm_official< T >::tiltedCut.

~TTStubAlgorithm_official()

template<typename T >

TTStubAlgorithm_official< T >::~TTStubAlgorithm_official ( )

inlineoverride

Destructor.

Definition at line 70 of file TTStubAlgorithm_official.h.

{}

Member Function Documentation

degradeBend() [1/3]

template<typename T >

float TTStubAlgorithm_official< T >::degradeBend	(	bool	psModule,
		int	window,
		int	bend
	)		const

Referenced by trackerDTC::Setup::encodeBend().

degradeBend() [2/3]

template<>

float TTStubAlgorithm_official< Ref_Phase2TrackerDigi_ >::degradeBend	(	bool	psModule,
		int	window,
		int	bend
	)		const

degradeBend() [3/3]

template<>

float TTStubAlgorithm_official< Ref_Phase2TrackerDigi_ >::degradeBend	(	bool	psModule,
		int	window,
		int	bend
	)		const

Definition at line 131 of file TTStubAlgorithm_official.cc.

                                                                                                             {
  // Number of bits used to encoded bend output by FE electronics.
  const unsigned int bitsPS_ = 3;
  const unsigned int bits2S_ = 4;
 
  // Number of degraded bend values should correspond to 3 bits (PS modules) or 4 bits (2S modules),
  // so measuring everything in half-strip units, max integer "window" size that can be encoded without
  // compression given by 2*window+1 <= pow(2,B), where B is number of bits.
  // Hence no compression required if window cut is abs(b) <= 3 (PS) or 7 (2S). Must introduce one merge for
  // each 1 unit increase in "window" beyond this.
 
  // Bend is measured with granularity of 0.5 strips.
  // Convert it to integer measured in half-strip units for this calculation!
 
  float degradedB;
  unsigned int numBends = 2 * window + 1;
  unsigned int numAllowed = (psModule) ? pow(2, bitsPS_) : pow(2, bits2S_);
 
  // Existance of bend = 0 means can only use an odd number of groups.
  numAllowed -= 1;  // NumAllowed can be only based on 3 or 4 bits encoded bends, so 7 or 15 possible values
  if (numBends <= numAllowed) {
    // Can output uncompressed bend info. (So if window is lower or equal than 1.5 in PS, and 3.5 in 2S
    degradedB = static_cast<double>(bend);
  } else  // all other cases, need to compress
  {
    unsigned int inSmallGroup = numBends / numAllowed;
    unsigned int numLargeGroups = numBends % numAllowed;
    unsigned int inLargeGroup = inSmallGroup + 1;
    unsigned int numSmallGroups = numAllowed - numLargeGroups;
 
    std::vector<unsigned int> groups;
 
    // At the end we have
    //
    // numBends=inSmallGroup*numSmallGroups+inLargeGroup*numLargeGroups
    // and
    // numAllowed= numSmallGroups+numLargeGroups;
    //
    // Then you alternate large-small-large-small....large. In the middle, you
    // put either large or small, depending if group size is odd or not
 
    for (unsigned int i = 0; i < numLargeGroups / 2; i++)
      groups.push_back(inLargeGroup);
    for (unsigned int i = 0; i < numSmallGroups / 2; i++)
      groups.push_back(inSmallGroup);
 
    // Only one of numLargeGroups & numSmallGroups can be odd, since numAllowed is odd.
    // And whichever one is odd is associated to a group with an odd number of elements since numBends is odd,
    if (numLargeGroups % 2 == 1 && inLargeGroup % 2 == 1) {
      groups.push_back(inLargeGroup);
    } else if (numSmallGroups % 2 == 1 && inSmallGroup % 2 == 1) {
      groups.push_back(inSmallGroup);
    } else {
      throw cms::Exception("DegradeBend: logic error with odd numbers");
    }
 
    for (unsigned int i = 0; i < numSmallGroups / 2; i++)
      groups.push_back(inSmallGroup);
    for (unsigned int i = 0; i < numLargeGroups / 2; i++)
      groups.push_back(inLargeGroup);
 
    degradedB = 999;
    int iUp = -static_cast<int>(window) - 1;  // Start with the minimal possible bend -1
    int iDown;
 
    for (unsigned int& inGroup : groups) {
      iUp += inGroup;
      iDown = iUp - inGroup + 1;
      if (bend <= iUp && bend >= iDown) {
        degradedB = 0.5 * (iUp + iDown);
      }
    }
    if (degradedB == 999)
      throw cms::Exception(
          "DegradeStubResolution: error in the group creation, method has been called with wrong inputs");
  }
 
  // This is degraded bend in full strip units (neglecting bend sign).
  return static_cast<float>(degradedB) / 2.;
}

References trklet::bend(), Exception, mps_fire::i, funct::pow(), and svgfig::window().

PatternHitCorrelation() [1/3]

template<>

void TTStubAlgorithm_official< Ref_Phase2TrackerDigi_ >::PatternHitCorrelation	(	bool &	aConfirmation,
		int &	aDisplacement,
		int &	anOffset,
		float &	anHardBend,
		const TTStub< Ref_Phase2TrackerDigi_ > &	aTTStub
	)		const

Implementation of methods of TTStubAlgorithm_official.

Here, in the source file, the methods which do depend on the specific type <T> that can fit the template.

Author

Nicola Pozzobon

Sebastien Viret

Date

2013, Jul 18 Matching operations

Calculate average coordinates col/row for inner/outer Cluster

Get the module position in global coordinates

Find pixel pitch and topology related information

Stop if the clusters are not in the same z-segment

This assumes the ratio is integer!

PS Modules

Get the Stack radius and z and displacements

Scale factor is already present in double mPtScalingFactor = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0*0.0015/mPtThreshold; hence the formula iis something like displacement < Delta * 1 / sqrt( ( 1/(mPtScalingFactor*R) )** 2 - 1 )

POSITION IN TERMS OF PITCH MULTIPLES: 0 1 2 3 4 5 5 6 8 9 ... COORD: 0 1 2 3 4 5 6 7 8 9 ... OUT | | | | | |x| | | | | | | | | |

IN | | | |x|x| | | | | | | | | | | THIS is 3.5 (COORD) and 4.0 (POS) 1) disp is the difference between average row coordinates in inner and outer stack member, in terms of outer member pitch (in case they are the same, this is just a plain coordinate difference)

In HALF-STRIP units!

In HALF-STRIP units!

2) offset is the projection with a straight line of the innermost hit towards the ourermost stack member, still in terms of outer member pitch NOTE: in terms of coordinates, the center of the module is at NROWS/2-0.5 to be consistent with the definition given above

In HALF-STRIP units!

In HALF-STRIP units!

Accept the stub if the post-offset correction displacement is smaller than the half-window

In HALF-STRIP units!

In HALF-STRIP units!

In HALF-STRIP units!

End of stub is accepted

Definition at line 15 of file TTStubAlgorithm_official.cc.

                                                         {
  // These are already corrected for being at the center of each pixel
  MeasurementPoint mp0 = aTTStub.clusterRef(0)->findAverageLocalCoordinates();
  MeasurementPoint mp1 = aTTStub.clusterRef(1)->findAverageLocalCoordinates();
 
  bool isPS = aTTStub.moduleTypePS();  // get it from the stub now
 
  // TODO temporary: should use a method from the topology
  DetId stDetId(aTTStub.getDetId());
  const GeomDetUnit* det0 = theTrackerGeom_->idToDetUnit(stDetId + 1);
  const GeomDetUnit* det1 = theTrackerGeom_->idToDetUnit(stDetId + 2);
 
  const PixelGeomDetUnit* pix0 = dynamic_cast<const PixelGeomDetUnit*>(det0);
  const PixelGeomDetUnit* pix1 = dynamic_cast<const PixelGeomDetUnit*>(det1);
  const PixelTopology* top0 = dynamic_cast<const PixelTopology*>(&(pix0->specificTopology()));
  const PixelTopology* top1 = dynamic_cast<const PixelTopology*>(&(pix1->specificTopology()));
  std::pair<float, float> pitch0 = top0->pitch();
  std::pair<float, float> pitch1 = top1->pitch();
 
  int cols0 = top0->ncolumns();
  int cols1 = top1->ncolumns();
  int ratio = cols0 / cols1;  
  int segment0 = floor(mp0.y() / ratio);
 
  //  if ( ratio == 1 ) /// 2S Modules
  if (!isPS) {
    if (mPerformZMatching2S && (segment0 != floor(mp1.y())))
      return;
  } else  
  {
    if (mPerformZMatchingPS && (segment0 != floor(mp1.y())))
      return;
  }
 
  double R0 = det0->position().perp();
  double R1 = det1->position().perp();
  double Z0 = det0->position().z();
  double Z1 = det1->position().z();
 
  double DR = R1 - R0;
  double DZ = Z1 - Z0;
 
  double alpha = atan2(DR, DZ);
  double delta = sqrt(DR * DR + DZ * DZ) / (R0 * sin(alpha) + Z0 * cos(alpha));
 
  int window = 0;
 
 
  double dispD = 2 * (mp1.x() - mp0.x()) * (pitch0.first / pitch1.first);  
  int dispI = ((dispD > 0) - (dispD < 0)) * floor(std::abs(dispD));        
 
  double offsetD = 2 * delta * (mp0.x() - (top0->nrows() / 2 - 0.5)) * (pitch0.first / pitch1.first);
  int offsetI = ((offsetD > 0) - (offsetD < 0)) * floor(std::abs(offsetD));  
 
  if (stDetId.subdetId() == StripSubdetector::TOB) {
    int layer = theTrackerTopo_->layer(stDetId);
    int ladder = theTrackerTopo_->tobRod(stDetId);
    int type = 2 * theTrackerTopo_->tobSide(stDetId) - 3;  // -1 for tilted-, 1 for tilted+, 3 for flat
    double corr = 0;
 
    if (type < 3)  // Only for tilted modules
    {
      corr = (barrelNTilt.at(layer) + 1) / 2.;
      // Corrected ring number, bet 0 and barrelNTilt.at(layer), in ascending |z|
      ladder = corr - (corr - ladder) * type;
      window = 2 * (tiltedCut.at(layer)).at(ladder);
    } else  // Classis barrel window otherwise
    {
      window = 2 * barrelCut.at(layer);
    }
 
  } else if (stDetId.subdetId() == StripSubdetector::TID) {
    window = 2 * (ringCut.at(theTrackerTopo_->tidWheel(stDetId))).at(theTrackerTopo_->tidRing(stDetId));
  }
 
  if (std::abs(dispI - offsetI) <= window)  
  {
    aConfirmation = true;
    aDisplacement = dispI;                                                     
    anOffset = offsetI;                                                        
    anHardBend = this->degradeBend(isPS, window, (aDisplacement - anOffset));  // In strips units
  }                                                                            
}

References funct::abs(), zMuMuMuonUserData::alpha, HLT_2018_cff::barrelCut, TTStub< T >::clusterRef(), alignCSCRings::corr, funct::cos(), dumpMFGeometry_cfg::delta, TTStub< T >::getDetId(), PVValHelper::ladder, TTStub< T >::moduleTypePS(), PixelTopology::ncolumns(), PixelTopology::nrows(), PV3DBase< T, PVType, FrameType >::perp(), PixelTopology::pitch(), GeomDet::position(), HLT_2018_cff::R0, particleFlowDisplacedVertex_cfi::ratio, funct::sin(), PixelGeomDetUnit::specificTopology(), mathSSE::sqrt(), StripSubdetector::TID, StripSubdetector::TOB, svgfig::window(), PV2DBase< T, PVType, FrameType >::x(), PV2DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and Z0.

PatternHitCorrelation() [2/3]

template<>

void TTStubAlgorithm_official< Ref_Phase2TrackerDigi_ >::PatternHitCorrelation	(	bool &	aConfirmation,
		int &	aDisplacement,
		int &	anOffset,
		float &	anHardBend,
		const TTStub< Ref_Phase2TrackerDigi_ > &	aTTStub
	)		const

Close class.

Implementation of methods

Here, in the header file, the methods which do not depend on the specific type <T> that can fit the template. Other methods, with type-specific features, are implemented in the source file. Matching operations

PatternHitCorrelation() [3/3]

template<typename T >

void TTStubAlgorithm_official< T >::PatternHitCorrelation ( bool &  aConfirmation, int &  aDisplacement, int &  anOffset, float &  anHardBend, const TTStub< T > &  aTTStub  ) const

overridevirtual

Matching operations.

Reimplemented from TTStubAlgorithm< T >.

Member Data Documentation

barrelCut

template<typename T >

std::vector<double> TTStubAlgorithm_official< T >::barrelCut

private

Definition at line 45 of file TTStubAlgorithm_official.h.

Referenced by TTStubAlgorithm_official< T >::TTStubAlgorithm_official().

barrelNTilt

template<typename T >

std::vector<double> TTStubAlgorithm_official< T >::barrelNTilt

private

Definition at line 48 of file TTStubAlgorithm_official.h.

Referenced by TTStubAlgorithm_official< T >::TTStubAlgorithm_official().

className_

template<typename T >

std::string TTStubAlgorithm_official< T >::className_

private

Definition at line 43 of file TTStubAlgorithm_official.h.

m_tilted

template<typename T >

bool TTStubAlgorithm_official< T >::m_tilted

private

Definition at line 42 of file TTStubAlgorithm_official.h.

mPerformZMatching2S

template<typename T >

bool TTStubAlgorithm_official< T >::mPerformZMatching2S

private

Definition at line 41 of file TTStubAlgorithm_official.h.

Referenced by TTStubAlgorithm_official< T >::TTStubAlgorithm_official().

mPerformZMatchingPS

template<typename T >

bool TTStubAlgorithm_official< T >::mPerformZMatchingPS

private

Data members.

Definition at line 40 of file TTStubAlgorithm_official.h.

Referenced by TTStubAlgorithm_official< T >::TTStubAlgorithm_official().

ringCut

template<typename T >

std::vector<std::vector<double> > TTStubAlgorithm_official< T >::ringCut

private

Definition at line 46 of file TTStubAlgorithm_official.h.

Referenced by TTStubAlgorithm_official< T >::TTStubAlgorithm_official().

tiltedCut

template<typename T >

std::vector<std::vector<double> > TTStubAlgorithm_official< T >::tiltedCut

private

Definition at line 47 of file TTStubAlgorithm_official.h.

Referenced by TTStubAlgorithm_official< T >::TTStubAlgorithm_official().