#include <CombinedSVSoftLeptonComputer.h>

Classes
struct	IterationRange

Public Member Functions
	CombinedSVSoftLeptonComputer (const edm::ParameterSet &params)

reco::TaggingVariableList	operator() (const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo, const reco::SoftLeptonTagInfo &muonInfo, const reco::SoftLeptonTagInfo &elecInfo) const

Private Member Functions
IterationRange	flipIterate (int size, bool vertex) const

double	flipValue (double value, bool vertex) const

const reco::TrackIPTagInfo::TrackIPData &	threshTrack (const reco::TrackIPTagInfo &trackIPTagInfo, const reco::TrackIPTagInfo::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const

Private Attributes
double	charmCut

double	minTrackWeight

unsigned int	pseudoMultiplicityMin

reco::V0Filter	pseudoVertexV0Filter

reco::TrackIPTagInfo::SortCriteria	sortCriterium

bool	trackFlip

unsigned int	trackMultiplicityMin

reco::TrackSelector	trackNoDeltaRSelector

reco::V0Filter	trackPairV0Filter

reco::TrackSelector	trackPseudoSelector

reco::TrackSelector	trackSelector

bool	useTrackWeights

bool	vertexFlip

bool	vertexMassCorrection

Detailed Description

Definition at line 15 of file CombinedSVSoftLeptonComputer.h.

Constructor & Destructor Documentation

CombinedSVSoftLeptonComputer::CombinedSVSoftLeptonComputer ( const edm::ParameterSet & params )

Definition at line 56 of file CombinedSVSoftLeptonComputer.cc.

                                                                                         :
     trackFlip(params.getParameter<bool>("trackFlip")),
     vertexFlip(params.getParameter<bool>("vertexFlip")),
     charmCut(params.getParameter<double>("charmCut")),
     sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
     trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
     trackNoDeltaRSelector(dropDeltaR(params.getParameter<edm::ParameterSet>("trackSelection"))),
     trackPseudoSelector(params.getParameter<edm::ParameterSet>("trackPseudoSelection")),
     pseudoMultiplicityMin(params.getParameter<unsigned int>("pseudoMultiplicityMin")),
     trackMultiplicityMin(params.getParameter<unsigned int>("trackMultiplicityMin")),
     minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
     useTrackWeights(params.getParameter<bool>("useTrackWeights")),
     vertexMassCorrection(params.getParameter<bool>("correctVertexMass")),
     pseudoVertexV0Filter(params.getParameter<edm::ParameterSet>("pseudoVertexV0Filter")),
     trackPairV0Filter(params.getParameter<edm::ParameterSet>("trackPairV0Filter"))
 {
 
 }

Member Function Documentation

CombinedSVSoftLeptonComputer::IterationRange CombinedSVSoftLeptonComputer::flipIterate	(	int	size,
		bool	vertex
	)		const

inlineprivate

Definition at line 80 of file CombinedSVSoftLeptonComputer.cc.

References CombinedSVSoftLeptonComputer::IterationRange::begin, CombinedSVSoftLeptonComputer::IterationRange::end, CombinedSVSoftLeptonComputer::IterationRange::increment, findQualityFiles::size, trackFlip, and vertexFlip.

Referenced by operator()(), and threshTrack().

 {
     IterationRange range;
     if (vertex ? vertexFlip : trackFlip) {
         range.begin = size - 1;
         range.end = -1;
         range.increment = -1;
     } else {
         range.begin = 0;
         range.end = size;
         range.increment = +1;
     }
 
     return range;
 }

double CombinedSVSoftLeptonComputer::flipValue	(	double	value,
		bool	vertex
	)		const

inlineprivate

Definition at line 75 of file CombinedSVSoftLeptonComputer.cc.

References trackFlip, relativeConstraints::value, and vertexFlip.

Referenced by operator()().

 {
     return (vertex ? vertexFlip : trackFlip) ? -value : value;
 }

TaggingVariableList CombinedSVSoftLeptonComputer::operator()	(	const reco::TrackIPTagInfo &	ipInfo,
		const reco::SecondaryVertexTagInfo &	svInfo,
		const reco::SoftLeptonTagInfo &	muonInfo,
		const reco::SoftLeptonTagInfo &	elecInfo
	)		const

Definition at line 145 of file CombinedSVSoftLeptonComputer.cc.

 {
     using namespace ROOT::Math;
 
     edm::RefToBase<Jet> jet = ipInfo.jet();
 
     math::XYZVector jetDir = jet->momentum().Unit();
     bool havePv = ipInfo.primaryVertex().isNonnull();
     GlobalPoint pv;
     if (havePv)
         pv = GlobalPoint(ipInfo.primaryVertex()->x(), ipInfo.primaryVertex()->y(), ipInfo.primaryVertex()->z());
 
     btag::Vertices::VertexType vtxType = btag::Vertices::NoVertex;
 
     TaggingVariableList vars; 
 
     vars.insert(btau::jetPt, jet->pt(), true);
     vars.insert(btau::jetEta, jet->eta(), true);
 
     if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
         return vars;
     
     vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);
 
     TrackKinematics allKinematics;
     TrackKinematics vertexKinematics;
     TrackKinematics trackJetKinematics;
 
     double vtx_track_ptSum= 0.; 
     double vtx_track_ESum= 0.; 
     double jet_track_ESum= 0.;
 
     int vtx = -1;
     unsigned int numberofvertextracks = 0;
 
     //IF THERE ARE SECONDARY VERTICES THE JET FALLS IN THE RECOVERTEX CATEGORY
     IterationRange range = flipIterate(svInfo.nVertices(), true);
     range_for(i, range) {
         if (vtx < 0) vtx = i; //RecoVertex category (vtx=0) if we enter at least one time in this loop!
 
         numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();
             
         const Vertex &vertex = svInfo.secondaryVertex(i);
         bool hasRefittedTracks = vertex.hasRefittedTracks();
         TrackRefVector tracks = svInfo.vertexTracks(i);
         for(TrackRefVector::const_iterator track = tracks.begin(); track != tracks.end(); track++) {
             double w = svInfo.trackWeight(i, *track);
             if (w < minTrackWeight)
                 continue;
             if (hasRefittedTracks) {
                 Track actualTrack = vertex.refittedTrack(*track);
                 vars.insert(btau::trackEtaRel, etaRel(jetDir,actualTrack.momentum()), true);
                 vertexKinematics.add(actualTrack, w);
             if(i==0)
                 {
                     math::XYZVector vtx_trackMom = actualTrack.momentum();
                     vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2)); 
                     vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));  
                 }
             } else { //THIS ONE IS TAKEN...
                 vars.insert(btau::trackEtaRel, etaRel(jetDir,(*track)->momentum()), true);
                 vertexKinematics.add(**track, w);
                 if(i==0) // calculate this only for the first vertex
                 {
                     math::XYZVector vtx_trackMom = (*track)->momentum();
                     vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2)); 
                     vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + std::pow(ParticleMasses::piPlus,2)); 
                     }
             }
         }
     }
 
     if (vtx >= 0) {
         vtxType = btag::Vertices::RecoVertex;
         vars.insert(btau::flightDistance2dVal,flipValue(svInfo.flightDistance(vtx, true).value(),true),true);
         vars.insert(btau::flightDistance2dSig,flipValue(svInfo.flightDistance(vtx, true).significance(),true),true);
         vars.insert(btau::flightDistance3dVal,flipValue(svInfo.flightDistance(vtx, false).value(),true),true);
         vars.insert(btau::flightDistance3dSig,flipValue(svInfo.flightDistance(vtx, false).significance(),true),true);
         vars.insert(btau::vertexJetDeltaR,Geom::deltaR(svInfo.flightDirection(vtx), jetDir),true);
         vars.insert(btau::jetNSecondaryVertices, svInfo.nVertices(), true);
         vars.insert(btau::vertexNTracks, numberofvertextracks, true);   
         vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
     }
 
 
     //NOW ATTEMPT TO RECONSTRUCT PSEUDOVERTEX!!!
     std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
     const std::vector<TrackIPTagInfo::TrackIPData> &ipData = ipInfo.impactParameterData();
     const edm::RefVector<TrackCollection> &tracks = ipInfo.selectedTracks();
   
     std::vector<TrackRef> pseudoVertexTracks;
 
     range = flipIterate(indices.size(), false);
     range_for(i, range) {
         std::size_t idx = indices[i];
         const TrackIPTagInfo::TrackIPData &data = ipData[idx];
         const TrackRef &trackRef = tracks[idx];
         const Track &track = *trackRef;
 
         // if no vertex was reconstructed, attempt pseudo vertex
         if (vtxType == btag::Vertices::NoVertex && trackPseudoSelector(track, data, *jet, pv)) {
             pseudoVertexTracks.push_back(trackRef);
             vertexKinematics.add(track);
         }
     }
 
     if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks)) 
     { 
         vtxType = btag::Vertices::PseudoVertex;
         for(std::vector<TrackRef>::const_iterator track = pseudoVertexTracks.begin(); track != pseudoVertexTracks.end(); ++track)
         {
             vars.insert(btau::trackEtaRel, etaRel(jetDir, (*track)->momentum()), true);
             math::XYZVector vtx_trackMom = (*track)->momentum();
             vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2)); 
             vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + std::pow(ParticleMasses::piPlus,2)); 
         }
     }
 
     vars.insert(btau::vertexCategory, vtxType, true);
 
 
 
     // do a tighter track selection to fill the variable plots...
     TrackRef trackPairV0Test[2];
     range = flipIterate(indices.size(), false);
     range_for(i, range) {
 
         std::size_t idx = indices[i];
         const TrackIPTagInfo::TrackIPData &data = ipData[idx];
         const TrackRef &trackRef = tracks[idx];
         const Track &track = *trackRef;
 
         jet_track_ESum += std::sqrt((track.momentum()).Mag2() + std::pow(ParticleMasses::piPlus,2)); 
         // add track to kinematics for all tracks in jet
         //allKinematics.add(track); //would make more sense for some variables, e.g. vertexEnergyRatio nicely between 0 and 1, but not necessarily the best option for the discriminating power...
                     
         // filter tracks -> this track selection can be more tight (used to fill the track related variables...)
         if (!trackSelector(track, data, *jet, pv))
             continue;
 
         // add track to kinematics for all tracks in jet
         allKinematics.add(track);
 
         // check against all other tracks for K0 track pairs setting the track mass to pi+
         trackPairV0Test[0] = tracks[idx];
         bool ok = true;
         range_for(j, range) {
             if (i == j)
                 continue;
 
             std::size_t pairIdx = indices[j];
             const TrackIPTagInfo::TrackIPData &pairTrackData = ipData[pairIdx];
             const TrackRef &pairTrackRef = tracks[pairIdx];
             const Track &pairTrack = *pairTrackRef;
 
             if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
                 continue;
 
             trackPairV0Test[1] = pairTrackRef;
             if (!trackPairV0Filter(trackPairV0Test, 2)) { //V0 filter is more tight (0.03) than the one used for the RecoVertex and PseudoVertex tracks (0.05)
             ok = false;
             break;
             }
         }
         
         if (!ok)
             continue;
 
         trackJetKinematics.add(track);
 
         // add track variables
         math::XYZVector trackMom = track.momentum();
         double trackMag = std::sqrt(trackMom.Mag2());
 
         vars.insert(btau::trackSip3dVal,  flipValue(data.ip3d.value(), false), true);
         vars.insert(btau::trackSip3dSig, flipValue(data.ip3d.significance(), false), true);
         vars.insert(btau::trackSip2dVal, flipValue(data.ip2d.value(), false), true);
         vars.insert(btau::trackSip2dSig, flipValue(data.ip2d.significance(), false), true);
         vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
         vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);
 
         vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
         vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
         vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
         vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
         vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
     } 
     
     vars.insert(btau::trackJetPt, trackJetKinematics.vectorSum().Pt(), true);
 
     vars.insert(btau::trackSumJetDeltaR,VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
     vars.insert(btau::trackSumJetEtRatio,allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
     vars.insert(btau::trackSip3dSigAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP3DSig, *jet, pv).ip3d.significance(),false),true);
     vars.insert(btau::trackSip3dValAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP3DSig, *jet, pv).ip3d.value(),false),true);
     vars.insert(btau::trackSip2dSigAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP2DSig, *jet, pv).ip2d.significance(),false),true);
     vars.insert(btau::trackSip2dValAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP2DSig, *jet, pv).ip2d.value(),false),true);
 
     if (vtxType != btag::Vertices::NoVertex) {
         math::XYZTLorentzVector allSum = useTrackWeights ? allKinematics.weightedVectorSum() : allKinematics.vectorSum();
         math::XYZTLorentzVector vertexSum = useTrackWeights ? vertexKinematics.weightedVectorSum() : vertexKinematics.vectorSum();
 
         if (vtxType != btag::Vertices::RecoVertex) {
             vars.insert(btau::vertexNTracks,vertexKinematics.numberOfTracks(), true);
             vars.insert(btau::vertexJetDeltaR,VectorUtil::DeltaR(vertexSum, jetDir), true);
         }
 
         double vertexMass = vertexSum.M();
         double varPi = 0;
         double varB = 0;
         if (vtxType == btag::Vertices::RecoVertex) {
             if(vertexMassCorrection)
             {
                 GlobalVector dir = svInfo.flightDirection(vtx);
                 double vertexPt2 = math::XYZVector(dir.x(), dir.y(), dir.z()).Cross(vertexSum).Mag2() / dir.mag2();
                 vertexMass = std::sqrt(vertexMass * vertexMass + vertexPt2) + std::sqrt(vertexPt2);
             }
         }
         vars.insert(btau::vertexMass, vertexMass, true);
         varPi = (vertexMass/5.2794) * (vtx_track_ESum /jet_track_ESum); //5.2794 should be average B meson mass of PDG! CHECK!!!
         vars.insert(btau::massVertexEnergyFraction, varPi, true);
         varB  = (std::sqrt(5.2794) * vtx_track_ptSum) / ( vertexMass * std::sqrt(jet->pt())); 
         vars.insert(btau::vertexBoostOverSqrtJetPt,varB*varB/(varB*varB + 10.), true);
         
         if (allKinematics.numberOfTracks())
             vars.insert(btau::vertexEnergyRatio, vertexSum.E() / allSum.E(), true);
         else
             vars.insert(btau::vertexEnergyRatio, 1, true);
     }
 
     reco::PFJet const * pfJet = dynamic_cast<reco::PFJet const *>( &* jet ) ;
     pat::Jet const * patJet = dynamic_cast<pat::Jet const *>( &* jet ) ;
     if ( pfJet != 0 ) {
         vars.insert(btau::chargedHadronEnergyFraction,pfJet->chargedHadronEnergyFraction(), true);
         vars.insert(btau::neutralHadronEnergyFraction,pfJet->neutralHadronEnergyFraction(), true);
         vars.insert(btau::photonEnergyFraction,pfJet->photonEnergyFraction(), true);
         vars.insert(btau::electronEnergyFraction,pfJet->electronEnergyFraction(), true);
         vars.insert(btau::muonEnergyFraction,pfJet->muonEnergyFraction(), true);
         vars.insert(btau::chargedHadronMultiplicity,pfJet->chargedHadronMultiplicity(), true);
         vars.insert(btau::neutralHadronMultiplicity,pfJet->neutralHadronMultiplicity(), true);
         vars.insert(btau::photonMultiplicity,pfJet->photonMultiplicity(), true);
         vars.insert(btau::electronMultiplicity,pfJet->electronMultiplicity(), true);
         vars.insert(btau::muonMultiplicity,pfJet->muonMultiplicity(), true);
         vars.insert(btau::hadronMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity(), true);
         vars.insert(btau::hadronPhotonMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity(), true);
             vars.insert(btau::totalMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity()+pfJet->electronMultiplicity()+pfJet->muonMultiplicity(), true);
 
     }
     else if( patJet != 0)
     {
         vars.insert(btau::chargedHadronEnergyFraction,patJet->chargedHadronEnergyFraction(), true);
         vars.insert(btau::neutralHadronEnergyFraction,patJet->neutralHadronEnergyFraction(), true);
         vars.insert(btau::photonEnergyFraction,patJet->photonEnergyFraction(), true);
         vars.insert(btau::electronEnergyFraction,patJet->electronEnergyFraction(), true);
         vars.insert(btau::muonEnergyFraction,patJet->muonEnergyFraction(), true);
         vars.insert(btau::chargedHadronMultiplicity,patJet->chargedHadronMultiplicity(), true);
         vars.insert(btau::neutralHadronMultiplicity,patJet->neutralHadronMultiplicity(), true);
         vars.insert(btau::photonMultiplicity,patJet->photonMultiplicity(), true);
         vars.insert(btau::electronMultiplicity,patJet->electronMultiplicity(), true);
         vars.insert(btau::muonMultiplicity,patJet->muonMultiplicity(), true);
         vars.insert(btau::hadronMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity(), true);
         vars.insert(btau::hadronPhotonMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity(), true);
             vars.insert(btau::totalMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity()+patJet->electronMultiplicity()+patJet->muonMultiplicity(), true);
     
     }
     else
     {
         throw cms::Exception("InvalidConfiguration") << "From CombinedSVSoftLeptonComputer::operator: reco::PFJet OR pat::Jet are required by this module" << std::endl;    
     }
 
     int leptonCategory = 0; //0 = no lepton, 1 = muon, 2 = electron
 
     for (unsigned int i = 0; i < muonInfo.leptons(); i++) {// loop over all muons, not optimal -> find the best or use ranking from best to worst
         leptonCategory = 1; // muon category
         const SoftLeptonProperties & propertiesMuon = muonInfo.properties(i);
         vars.insert(btau::leptonPtRel,propertiesMuon.ptRel , true); 
         vars.insert(btau::leptonSip3d,propertiesMuon.sip3d , true); 
         vars.insert(btau::leptonDeltaR,propertiesMuon.deltaR , true);   
         vars.insert(btau::leptonRatioRel,propertiesMuon.ratioRel , true);   
         vars.insert(btau::leptonEtaRel,propertiesMuon.etaRel , true);   
         vars.insert(btau::leptonRatio,propertiesMuon.ratio , true); 
     }
     
     if(leptonCategory != 1){ //no soft muon found, try soft electron
         for (unsigned int i = 0; i < elecInfo.leptons(); i++) { // loop over all electrons, not optimal -> find the best or use ranking from best to worst
             leptonCategory = 2; // electron category
             const SoftLeptonProperties & propertiesElec = elecInfo.properties(i);
             vars.insert(btau::leptonPtRel,propertiesElec.ptRel , true); 
             vars.insert(btau::leptonSip3d,propertiesElec.sip3d , true); 
             vars.insert(btau::leptonDeltaR,propertiesElec.deltaR , true);   
             vars.insert(btau::leptonRatioRel,propertiesElec.ratioRel , true);   
             vars.insert(btau::leptonEtaRel,propertiesElec.etaRel , true);   
             vars.insert(btau::leptonRatio,propertiesElec.ratio , true); 
         }
     }
     
 
     //put default value for vertexLeptonCategory on 2 = NoVertexNoSoftLepton
     int vertexLepCat = 2; 
 
     if(leptonCategory == 0){ //  no soft lepton
     if (vtxType == btag::Vertices::RecoVertex)
             vertexLepCat = 0;
     else if (vtxType == btag::Vertices::PseudoVertex)
             vertexLepCat = 1;
     else
             vertexLepCat = 2;
     } else if(leptonCategory == 1){ // soft muon
     if (vtxType == btag::Vertices::RecoVertex)
             vertexLepCat = 3;
     else if(vtxType == btag::Vertices::PseudoVertex)
             vertexLepCat = 4;
     else            vertexLepCat = 5;
     } else if(leptonCategory == 2){ // soft electron    
     if (vtxType == btag::Vertices::RecoVertex)
             vertexLepCat = 6;
     else if (vtxType == btag::Vertices::PseudoVertex)
             vertexLepCat = 7;
     else 
             vertexLepCat = 8;
     }
     
     vars.insert(btau::vertexLeptonCategory, vertexLepCat , true);   
 
     vars.finalize();
     
     return vars;
 }

const TrackIPTagInfo::TrackIPData & CombinedSVSoftLeptonComputer::threshTrack	(	const reco::TrackIPTagInfo &	trackIPTagInfo,
		const reco::TrackIPTagInfo::SortCriteria	sort,
		const reco::Jet &	jet,
		const GlobalPoint &	pv
	)		const

private

Definition at line 98 of file CombinedSVSoftLeptonComputer.cc.

References charmCut, data, flipIterate(), i, customizeTrackingMonitorSeedNumber::idx, reco::TrackIPTagInfo::impactParameterData(), range_for, reco::TrackIPTagInfo::selectedTracks(), reco::TrackIPTagInfo::sortedIndexes(), trackNoDeltaRSelector, and testEve_cfg::tracks.

Referenced by operator()().

 {
     const edm::RefVector<TrackCollection> &tracks =
                     trackIPTagInfo.selectedTracks();
     const std::vector<TrackIPTagInfo::TrackIPData> &ipData =
                     trackIPTagInfo.impactParameterData();
     std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);
 
     IterationRange range = flipIterate(indices.size(), false);
     TrackKinematics kin;
     range_for(i, range) {
         std::size_t idx = indices[i];
         const TrackIPTagInfo::TrackIPData &data = ipData[idx];
         const Track &track = *tracks[idx];
 
         if (!trackNoDeltaRSelector(track, data, jet, pv))
             continue;
 
         kin.add(track);
         if (kin.vectorSum().M() > charmCut) 
             return data;
     }
 
     static const TrackIPTagInfo::TrackIPData dummy = {
         GlobalPoint(),
         GlobalPoint(),
         Measurement1D(-1.0, 1.0),
         Measurement1D(-1.0, 1.0),
         Measurement1D(-1.0, 1.0),
         Measurement1D(-1.0, 1.0),
         0.
     };
     return dummy;
 }