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 paramets for a given track, if available, and fill them in the corresponding data vectors. More...
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. More...
void	getPolylineFromHits (const std::vector< const Trk::TrackStateOnSurface * > &TSoSVec, DataVect &polylineX, DataVect &polylineY, DataVect &polylineZ, DataVect &numPolyline)
	Get polyline hits if available. More...
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. More...
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. More...
void	getTruthFromTrack (const Trk::Track *track, const TrackCollection *trackCollection, const TrackTruthCollection *truthCollection, DataVect &barcode)
	Get the barcode of the associated truth track. More...

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 184 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 paramets 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 50 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 158 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 253 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 120 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,
		const TrackTruthCollection *	truthCollection,
		DataVect &	barcode
	)

Get the barcode of the associated truth track.

Definition at line 302 of file TrackRetriever.cxx.

                                                                           {
 
            if (!truthCollection) {
                //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());
        }