doesn't actually need to be an algtool as it class variables, so requires no python configuration More...

#include <TrackRoiSelector.h>

Collaboration diagram for IDTPM2::TrackRoiSelector:

Classes
struct	exit_point

Public Member Functions
	TrackRoiSelector ()
	Constructor - self evidently.
virtual	~TrackRoiSelector ()=default
	Destructor.
template<class T>
bool	accept (const T &t, const TrigRoiDescriptor *r) const
	geometric RoI filters - for non-trigger tracks (e.g. offline, truth, etc.)
template<class T>
std::vector< const T * >	getTracks (const std::vector< const T * > &tracks, const TrigRoiDescriptor *roi) const
	track getter function (for offline tracks \|\| truth particles)

Private Member Functions
exit_point	getExitPoint (float tz0, float teta) const
	why are there these "exit point functions ?
std::optional< double >	getOuterPhi (float pt, float phi, float r=1000.) const

Detailed Description

doesn't actually need to be an algtool as it class variables, so requires no python configuration

Definition at line 30 of file TrackRoiSelector.h.

Constructor & Destructor Documentation

◆ TrackRoiSelector()

IDTPM2::TrackRoiSelector::TrackRoiSelector ( )

inline

Constructor - self evidently.

Definition at line 35 of file TrackRoiSelector.h.

35{ }

◆ ~TrackRoiSelector()

virtual IDTPM2::TrackRoiSelector::~TrackRoiSelector ( )

virtualdefault

Destructor.

Member Function Documentation

◆ accept()

template<class T>

template bool IDTPM2::TrackRoiSelector::accept	(	const T &	t,
		const TrigRoiDescriptor *	r ) const

geometric RoI filters - for non-trigger tracks (e.g. offline, truth, etc.)

accept method for truth particles

Athena include(s).

Local include(s) STD includes

----— accept -----—

should really throw an exception

NB: This isn't actually correct - the tracks can bend out of the RoI even if the perigee phi is within the Roi so we check the outer phi limit later ...

must be contained along the beamline ...

this is actually wrong, but hey ho. It is even needed ?

calculation of approximate z position of the track at radius r && test if track within that z position at radius r

full check to determine whether a track is fully contained in the Roi (when used in conjunction with contained_zed above) sadly this will recalculate the Roi limits for every track, which is why the earlier version took this stuff from the Roi itself - will need to go back to that at some point,

now check phi taking account of the track transverse curvature NB: need to check the pt is properly signed

Definition at line 27 of file TrackRoiSelector.cxx.

                                                                                  {
 
  if ( r==0 ) return true; 
 
  if ( t.pt()==0 ) return false; // throw runtime_error(shouldn't ever have a track with pt = 0" );
    
  if( r->composite() ) {       
 
    for ( unsigned i=r->size() ; i-- ; ) if ( accept( t, (const TrigRoiDescriptor*)r->at(i) ) ) return true;
 
  }
  else { 
 
    if( r->isFullscan() ) return true;
 
    //    std::cout << "r->
    
    bool contained_phi = ( r->phiMinus()<r->phiPlus() ) ?
                         ( t.phi()>r->phiMinus() && t.phi()<r->phiPlus() ) :
                         ( t.phi()>r->phiMinus() || t.phi()<r->phiPlus() ); 
    bool contained_zed = ( t.z0()>r->zedMinus() && t.z0()<r->zedPlus() ); 
    
    bool contained_eta = ( t.eta()<r->etaPlus() && t.eta()>r->etaMinus() );
                                                         
 
#if 0
    //  RoiDescriptor so that computes and stores it's exit points as standard
 
    exit_point ex;
    exit_point explus;
    exit_point exminus;
 
    TIDARoiDescriptor::exitpoint( t.z0(), t.eta(), ex.z, ex.r );
 
    TIDARoiDescriptor::exitpoint( r->zedPlus(),   r->etaPlus(),   explus.z,  explus.r );
    TIDARoiDescriptor::exitpoint( r->zedMinus(),  r->etaMinus(), exminus.z, exminus.r );
 
#else
    
    exit_point ex      = getExitPoint( t.z0(),  t.eta() );
    exit_point explus  = getExitPoint( r->zedPlus(),  r->etaPlus() );
    exit_point exminus = getExitPoint( r->zedMinus(), r->etaMinus() );
#endif
 
    float cross0 = ex.z*exminus.r - ex.r*exminus.z;
    float cross1 = ex.z*explus.r  - ex.r*explus.z; 
 
    contained_eta = ( cross0>0 && cross1<0 ) ? true : false;
    std::optional<double> newphi = getOuterPhi( t.pt(), t.phi(), ex.r );
 
    if( !newphi ) return false;
  
    if( r->phiMinus() < r->phiPlus() ) contained_phi &= ( newphi > r->phiMinus() && newphi < r->phiPlus() );
    else                               contained_phi &= ( newphi > r->phiMinus() || newphi < r->phiPlus() );
 
    if( contained_eta && contained_phi && contained_zed ) return true;
  }
 
  return false;
}

◆ getExitPoint()

IDTPM2::TrackRoiSelector::exit_point IDTPM2::TrackRoiSelector::getExitPoint	(	float	tz0,
		float	teta ) const

private

why are there these "exit point functions ?

Actually, this class should really be implemented as inheriting from an ITrackSelector.

should we not use the versions in the RoiDescriptor ? this is actually a largely copy of a TrigRoiDescriptor function Geometric utility methods for track-RoI association

----— getExitPoint ----—

not quite right, because it might be passing out through the rear endcap

leaves through the barrel side || front face?

through the barrel edge actually need to calculate the z exit coordinate
for proper containment rather than spurious "eta containment"

Definition at line 151 of file TrackRoiSelector.cxx.

                                                                                                   {
 
  exit_point exitPoint;
 
  double  rexit = 0;
  double  zexit = 0;
  const double maxRadius = 1000.;
  const double maxZed    = 2700.;
 
  if      ( teta < 0 ) zexit = -maxZed;
  else if ( teta > 0 ) zexit =  maxZed;
  else { 
    exitPoint.z = tz0;
    exitPoint.r = maxRadius; 
    return exitPoint;
  }
  
  double tantheta = std::tan( 2 * std::atan( std::exp( -teta ) ) );
  
  rexit = ( zexit - tz0 ) * tantheta; 
  if ( std::fabs(rexit) > maxRadius ) {
 
    zexit = maxRadius / tantheta + tz0;
    rexit = maxRadius;
  }
 
  exitPoint.z = zexit;
  exitPoint.r = rexit;
  
  return exitPoint;
}

◆ getOuterPhi()

std::optional< double > IDTPM2::TrackRoiSelector::getOuterPhi	(	float	pt,
		float	phi,
		float	r = 1000. ) const

private

----— getOuterPhi ----—

calculate the (very approximate) phi position for a track at a radius r

track (signed) radius of curvature (if pt is signed)

make sure it escapes the radius in question

calculate new position

wrap to -pi to pi - is this correct when using floats ? NB: float(M_PI)>M_PI ? so use doubles for all the calculations

Definition at line 118 of file TrackRoiSelector.cxx.

                                                                                            {
 
  
  double mqR    = 10 * pt / ( 2.99792458 * 2 ); // 2.998=speed of light, 2=Atlas B field   
  double ratio  = 0.5 * r / mqR;    
  double newphi = phi;
  
  if ( std::fabs(ratio)>1 ) return std::nullopt;
  
  newphi -= std::asin( ratio );  
                          
  while( newphi < -M_PI ) newphi += 2 * M_PI;
  while( newphi > M_PI  ) newphi -= 2 * M_PI;
 
  return newphi;
}

◆ getTracks()

template<class T>

std::vector< const T * > IDTPM2::TrackRoiSelector::getTracks	(	const std::vector< const T * > &	tracks,
		const TrigRoiDescriptor *	roi ) const

track getter function (for offline tracks || truth particles)

no point looking at tracks that never make it into the detector ...

Definition at line 77 of file TrackRoiSelector.h.

                                                                                                {
 
  //  std::cout << "\n\n\tSUTT roi filter" << tvec.size() << "\t" << *roi << "\n" << std::endl;
 
  std::vector<const T*> selectedTracks;
 
  for( size_t it=0 ; it<tracks.size() ; it++ ) {
 
    const T* track = tracks.at(it);
    if ( track->pt()==0 ) continue;
    
    bool keep = accept<T>( *track, roi );
 
    //    if ( keep ) std::cout <<  it << "\t" << *tvec[it] << "\taccept: " << keep << std::endl; 
    
    if( keep ) selectedTracks.push_back( track );
  }
 
  //  std::cout << "\tSUTT: " << selectedTracks.size() << std::endl; 
  
  return selectedTracks;
}

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

Classes

Public Member Functions

Private Member Functions