JiveXML::TrackRetrieverHelpers Namespace Reference

Namespace for all helper functions. More...

Functions
const Trk::Perigee *	getPerigeeParameters (const Trk::Track *track, DataVect &pt, DataVect &d0, DataVect &z0, DataVect &phi0, DataVect &cotTheta, DataVect &covMatrix)
	Obtain the perigee parameters for a given track, if available, and fill them in the corresponding data vectors.
std::vector< const Trk::TrackStateOnSurface * >	getTrackStateOnSurfaces (const Trk::Track *track, const Trk::Perigee *perigee, bool doHitsSorting)
	Get a list of track-State on Surfaces for measurement and outlier hits, sorted using the perigee comparison functions.
void	getPolylineFromHits (const std::vector< const Trk::TrackStateOnSurface * > &TSoSVec, DataVect &polylineX, DataVect &polylineY, DataVect &polylineZ, DataVect &numPolyline)
	Get polyline hits if available.
const Trk::RIO_OnTrack *	getBaseInfoFromHit (const Trk::TrackStateOnSurface *tsos, const AtlasDetectorID *idHelper, DataVect &isOutlier, DataVect &hits, DataVect &driftSign, DataVect &tsosDetType)
	Retrieve all the basic hit information from the Trk::TrackStateOnSurface.
void	getResidualPullFromHit (const Trk::TrackStateOnSurface *tsos, const Trk::RIO_OnTrack *rot, const ToolHandle< Trk::IResidualPullCalculator > &residualPullCalculator, DataVect &tsosResLoc1, DataVect &tsosResLoc2, DataVect &tsosPullLoc1, DataVect &tsosPullLoc2)
	Get the residual pull information from the Trk::TrackStateOnSurface hit.
void	getTruthFromTrack (const Trk::Track *track, const TrackCollection *trackCollection, SG::ReadHandle< TrackTruthCollection > &truthCollection, DataVect &barcode)
	Get the barcode of the associated truth track.

Detailed Description

Namespace for all helper functions.

Function Documentation

getBaseInfoFromHit()

const Trk::RIO_OnTrack * JiveXML::TrackRetrieverHelpers::getBaseInfoFromHit	(	const Trk::TrackStateOnSurface *	tsos,
		const AtlasDetectorID *	idHelper,
		DataVect &	isOutlier,
		DataVect &	hits,
		DataVect &	driftSign,
		DataVect &	tsosDetType )

Retrieve all the basic hit information from the Trk::TrackStateOnSurface.

Returns

the reconstruction input object (RIO) for further use

Definition at line 181 of file TrackRetriever.cxx.

                                                                                                        {
 
      //Get corresponding measurement
      const Trk::MeasurementBase *measurement = tsos->measurementOnTrack();
 
      //If measurement is invalid, return imediately
      if (!measurement) return nullptr;
 
      // get RIO_OnTrack
      const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(measurement);
 
      // check for competing RIO_OnTracks
      if (!rot) {
    // try to get identifier by CompetingROT:
    const Trk::CompetingRIOsOnTrack* comprot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(measurement);
    //Get the input object with highest probability
    if (comprot) rot = &(comprot->rioOnTrack(comprot->indexOfMaxAssignProb()));
      }
 
      //If there is still no RIO_onTrack, return Null
      if (!rot) return nullptr;
 
      // Now start writing out values:
      // Check if this is an outlier hit
      isOutlier.emplace_back(tsos->type(Trk::TrackStateOnSurface::Outlier));
 
      //Now try to get the identifier, create an empty invalid one if no rot
      Identifier hitId (rot->identify());
      //Check if it is valid, othwerise store 0
      hits.push_back( hitId.is_valid()?DataType( hitId.get_compact() ):DataType(0) );
 
      // get sign of drift radius for TRT measurements
      int theDriftSign = 0;
      if (idHelper->is_trt(hitId)) {
    // get local parameters
    theDriftSign = measurement->localParameters()[Trk::driftRadius] > 0. ? 1 : -1;
      }
      driftSign.emplace_back(theDriftSign);
 
      //Now get the detector type of the hit
      if ( !hitId.is_valid() ){
    tsosDetType.emplace_back("unident");
      } else if (idHelper->is_pixel(hitId) ) {
    tsosDetType.emplace_back("PIX"); // is PIX in Atlantis
      } else if (idHelper->is_sct(hitId)) {
    tsosDetType.emplace_back("SIL"); // is SIL in Atlantis
      } else if (idHelper->is_trt(hitId)) {
    tsosDetType.emplace_back("TRT");
      } else if (idHelper->is_mdt(hitId)) {
    tsosDetType.emplace_back("MDT");
      } else if (idHelper->is_csc(hitId)) {
    tsosDetType.emplace_back("CSC");
      } else if (idHelper->is_rpc(hitId)) {
    tsosDetType.emplace_back("RPC");
      } else if (idHelper->is_tgc(hitId)) {
    tsosDetType.emplace_back("TGC");
      } else {
    tsosDetType.emplace_back("unident");
      }
 
      //Return the reco input object
      return rot;
    }

getPerigeeParameters()

const Trk::Perigee * JiveXML::TrackRetrieverHelpers::getPerigeeParameters	(	const Trk::Track *	track,
		DataVect &	pt,
		DataVect &	d0,
		DataVect &	z0,
		DataVect &	phi0,
		DataVect &	cotTheta,
		DataVect &	covMatrix )

Obtain the perigee parameters for a given track, if available, and fill them in the corresponding data vectors.

Perigee parameters are written out in the old format using \( \cot\theta \) and \( q/p_T \)

Returns

the perigee parameter object for further use

Get perigee parameters in old format ( \( d_0 \), \( z_0 \), \( \phi \), \( \cot\theta \), \( q/p_T \)), whereas tracking uses ( \( d_0 \), \( z_0 \), \( \phi \), \( \theta \), q/p), therefore a transformation of the covariance matrix is needed

get transformed covariance matrix

Definition at line 48 of file TrackRetriever.cxx.

                                                                  {

      const Trk::Perigee *perigee = track->perigeeParameters();
 
      //return immediately if there is no perigee information
      if (!perigee) return nullptr;
 
      //write out p_T
      if ((perigee->parameters())[Trk::qOverP]==0) pt.emplace_back(9999.);
      else pt.push_back( (perigee->charge() > 0) ? DataType(perigee->pT()/Gaudi::Units::GeV) : DataType((-perigee->pT())/Gaudi::Units::GeV));
 
      d0.emplace_back((perigee->parameters())[Trk::d0]/Gaudi::Units::cm);
      z0.emplace_back(perigee->parameters()[Trk::z0]/Gaudi::Units::cm);
      phi0.emplace_back(perigee->parameters()[Trk::phi0]);
 
      if (perigee->parameters()[Trk::theta] == 0.) cotTheta.emplace_back(9999.);
      else cotTheta.emplace_back(1./tan(perigee->parameters()[Trk::theta]));
 
      // CLHEP->Eigen migration. jpt Dec'13
      // https://twiki.cern.ch/twiki/bin/viewauth/Atlas/MigrationCLHEPtoEigen
      // https://twiki.cern.ch/twiki/bin/viewauth/Atlas/MigrationToUpdatedEDM#Changes_to_TrkParameters

      AmgSymMatrix(5) covVert;
 
      const AmgSymMatrix(5)* covariance = perigee->covariance(); //perigee cannot be null here
      if (perigee && covariance) {
    // do trafo to old format
    double measuredTheta = perigee->parameters()[Trk::theta];
    double measuredQoverp = perigee->parameters()[Trk::qOverP];
    const Trk::JacobianThetaPToCotThetaPt theJac( measuredTheta, measuredQoverp );
    covVert = covariance->similarity(theJac);
      }else{
    for ( int ii=0; ii<20; ii++){ // placeholder. Do this nicer.
      covVert(ii) = 0.;
    }
      }
      //Scale covariance matrix values to get good resolution with fixed
      //precision in JiveXML data
 
      const long scale = 10000;
      const double thisScale(scale/100.);
      // Migration: Now only has diagonal elements from covariance matrix ?
      covMatrix.emplace_back(covVert(0)*thisScale); // 5 elements
      covMatrix.emplace_back(covVert(1)*thisScale);
      covMatrix.emplace_back(covVert(2)*thisScale);
      covMatrix.emplace_back(covVert(3)*thisScale);
      covMatrix.emplace_back(covVert(4)*thisScale);
 
      // Used to be 15 elements before migration, so need to put 10 placeholders
      for ( int i=0; i<10; i++){
    covMatrix.emplace_back( 0. );
      }
 
      //All for perigee, return object for use by other functions
      return perigee;
    }

getPolylineFromHits()

void JiveXML::TrackRetrieverHelpers::getPolylineFromHits	(	const std::vector< const Trk::TrackStateOnSurface * > &	TSoSVec,
		DataVect &	polylineX,
		DataVect &	polylineY,
		DataVect &	polylineZ,
		DataVect &	numPolyline )

Get polyline hits if available.

Polyline tracks that have less than 2 points are not useful - skip

Definition at line 155 of file TrackRetriever.cxx.

                                                                                                       {
      int numPoly = 0 ;
      if (TSoSVec.size() > 1) {
    //Loop over track state on surfaces
    std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIter;
    const double onetenth(0.1);
    for (tsosIter=TSoSVec.begin(); tsosIter!=TSoSVec.end(); ++tsosIter) {
      // get global track position
      if (!(*tsosIter)->trackParameters()) continue ;
      const Amg::Vector3D& pos = (*tsosIter)->trackParameters()->position();
      polylineX.emplace_back(pos.x()*onetenth);
      polylineY.emplace_back(pos.y()*onetenth);
      polylineZ.emplace_back(pos.z()*onetenth);
      ++numPoly;
    }
      }
      //Store counter as well
      numPolyline.emplace_back(numPoly);
    }

getResidualPullFromHit()

void JiveXML::TrackRetrieverHelpers::getResidualPullFromHit	(	const Trk::TrackStateOnSurface *	tsos,
		const Trk::RIO_OnTrack *	rot,
		const ToolHandle< Trk::IResidualPullCalculator > &	residualPullCalculator,
		DataVect &	tsosResLoc1,
		DataVect &	tsosResLoc2,
		DataVect &	tsosPullLoc1,
		DataVect &	tsosPullLoc2 )

Get the residual pull information from the Trk::TrackStateOnSurface hit.

Using track residual tool: ResidualPullCalculator -excerpt from Tracking/TrkValidation/TrkValTools/src/BasicValidationNtupleTool.cxx

Definition at line 250 of file TrackRetriever.cxx.

                                                                                                               {
 
      //Define default return values for invalid states
      double ResLoc1 = -99.;
      double ResLoc2 = -99.;
      double PullLoc1 = -99.;
      double PullLoc2 = -99.;
 
      // get TrackParameters on the surface to calculate residual
      const Trk::TrackParameters* tsosParameters = tsos->trackParameters();
 
      //Check we got the parameters
      if (tsosParameters){

 
    //Get the residualPull object
        std::optional<Trk::ResidualPull> residualPull = residualPullCalculator->residualPull(rot, tsosParameters,Trk::ResidualPull::Biased);
 
    if (residualPull) {
      //Get the first residual
      ResLoc1 = residualPull->residual()[Trk::loc1];
      //Get the second residual for more than 1 dimension
      if (residualPull->dimension() >= 2) ResLoc2 = residualPull->residual()[Trk::loc2];
 
      if ((residualPull->isPullValid()) ) {
        //Get the first residual
        PullLoc1 = residualPull->pull()[Trk::loc1];
        //Get the second residual for more than 1 dimension
        if (residualPull->dimension() >= 2) PullLoc2 = residualPull->pull()[Trk::loc2];
      }
    } // end if residualPull
      } // end if tsosParameters
 
      //Finally store the values
      tsosResLoc1.emplace_back(ResLoc1 );
      tsosResLoc2.emplace_back(ResLoc2 );
      tsosPullLoc1.emplace_back(PullLoc1 );
      tsosPullLoc2.emplace_back(PullLoc2 );
    }

getTrackStateOnSurfaces()

std::vector< const Trk::TrackStateOnSurface * > JiveXML::TrackRetrieverHelpers::getTrackStateOnSurfaces	(	const Trk::Track *	track,
		const Trk::Perigee *	perigee,
		bool	doHitsSorting )

Get a list of track-State on Surfaces for measurement and outlier hits, sorted using the perigee comparison functions.

Returns

a std::vector of Trk::TrackStateOnSurface*

Definition at line 118 of file TrackRetriever.cxx.

                                                                                                                                           {
      // vector for the return object
      std::vector<const Trk::TrackStateOnSurface*> TSoSVec;
 
      // loop over TrackStateOnSurfaces to extract interesting ones
      Trk::TrackStates::const_iterator tsos = track->trackStateOnSurfaces()->begin();
      for (; tsos!=track->trackStateOnSurfaces()->end(); ++tsos) {
    // include measurements AND outliers:
    if ((*tsos)->type(Trk::TrackStateOnSurface::Measurement) ||  (*tsos)->type(Trk::TrackStateOnSurface::Outlier) ) {
      // add to temp vector
      TSoSVec.push_back(*tsos);
    } // end if TSoS is measurement or outlier
      } // end loop over TSoS
 
      // sort the selected TSoS, if not already sorted using a comparison functor
 
      if (perigee) {
    //Get hold of the comparison functor
    Trk::TrackStateOnSurfaceComparisonFunction *compFunc
      = new Trk::TrackStateOnSurfaceComparisonFunction(perigee->position(), perigee->momentum());
    if (compFunc){
      if (doHitsSorting) {
        //Sort track state on surface if needed
        if (TSoSVec.size() > 2 && !is_sorted(TSoSVec.begin(), TSoSVec.end(), *compFunc))
          std::sort(TSoSVec.begin(), TSoSVec.end(), *compFunc);
      }
    }
    delete compFunc;
      } // end if compFunc
 
      //Now return that vector
      return TSoSVec;
    }

getTruthFromTrack()

void JiveXML::TrackRetrieverHelpers::getTruthFromTrack	(	const Trk::Track *	track,
		const TrackCollection *	trackCollection,
		SG::ReadHandle< TrackTruthCollection > &	truthCollection,
		DataVect &	barcode )

Get the barcode of the associated truth track.

Definition at line 299 of file TrackRetriever.cxx.

                                                                                       {
 
      if (!truthCollection.isValid()) {
    //Fill with zero if none found
    barcode.emplace_back(0);
    return;
      }
 
      //Get the element link to this track collection
      ElementLink<TrackCollection> tracklink;
      tracklink.setElement(track);
      tracklink.setStorableObject(*trackCollection);
 
      //try to find it in the truth collection
      std::map<Trk::TrackTruthKey,TrackTruth>::const_iterator tempTrackTruthItr = truthCollection->find(tracklink);
 
      //Fill with zero if none found
      if (tempTrackTruthItr == truthCollection->end()){
    //Fill with zero if none found
    barcode.emplace_back(0);
    return;
      }
 
      //if found, Store the barcode
      barcode.emplace_back((*tempTrackTruthItr).second.particleLink().barcode());
    }