#include <CombinedSVComputer.h>

Inheritance diagram for CombinedSVComputer:

Classes
struct	IterationRange

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

edm::ParameterSet	dropDeltaR (const edm::ParameterSet &pset) const

template<class SVTI , class IPTI >
void	fillCommonVariables (reco::TaggingVariableList &vars, reco::TrackKinematics &vertexKinematics, const IPTI &ipInfo, const SVTI &svInfo, double &vtx_track_ptSum, double &vtx_track_ESum) const

IterationRange	flipIterate (int size, bool vertex) const

double	flipValue (double value, bool vertex) const

virtual reco::TaggingVariableList	operator() (const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const

virtual reco::TaggingVariableList	operator() (const reco::CandIPTagInfo &ipInfo, const reco::CandSecondaryVertexTagInfo &svInfo) const

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

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

virtual	~CombinedSVComputer ()=default

Private Attributes
double	charmCut

double	minTrackWeight

unsigned int	pseudoMultiplicityMin

reco::V0Filter	pseudoVertexV0Filter

reco::btag::SortCriteria	sortCriterium

std::vector < reco::btau::TaggingVariableName >	taggingVariables

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 39 of file CombinedSVComputer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 11 of file CombinedSVComputer.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")) {}

virtual CombinedSVComputer::~CombinedSVComputer ( )

virtualdefault

Member Function Documentation

edm::ParameterSet CombinedSVComputer::dropDeltaR ( const edm::ParameterSet & pset ) const

inline

Definition at line 5 of file CombinedSVComputer.cc.

References edm::ParameterSet::addParameter().

                                                                                        {
   edm::ParameterSet psetCopy(pset);
   psetCopy.addParameter<double>("jetDeltaRMax", 99999.0);
   return psetCopy;
 }

template<class SVTI , class IPTI >

void CombinedSVComputer::fillCommonVariables	(	reco::TaggingVariableList &	vars,
		reco::TrackKinematics &	vertexKinematics,
		const IPTI &	ipInfo,
		const SVTI &	svInfo,
		double &	vtx_track_ptSum,
		double &	vtx_track_ESum
	)		const

Definition at line 91 of file CombinedSVComputer.h.

References reco::TrackKinematics::add(), reco::btau::chargedHadronEnergyFraction, reco::btau::chargedHadronMultiplicity, reco::btag::TrackIPData::closestToJetAxis, data, HLT_FULL_cff::DeltaR, HLT_FULL_cff::deltaR, DeadROC_duringRun::dir, reco::btag::TrackIPData::distanceToJetAxis, reco::btau::electronEnergyFraction, reco::btau::electronMultiplicity, reco::btau::etaRel(), reco::btau::flightDistance1dSig, reco::btau::flightDistance1dVal, reco::btau::flightDistance2dSig, reco::btau::flightDistance2dVal, reco::btau::flightDistance3dSig, reco::btau::flightDistance3dVal, flipIterate(), flipValue(), reco::btau::hadronMultiplicity, reco::btau::hadronPhotonMultiplicity, mps_fire::i, dqmdumpme::indices, reco::TaggingVariableList::insert(), reco::btag::TrackIPData::ip2d, reco::btag::IP2DSig, reco::btag::TrackIPData::ip3d, reco::btag::IP3DSig, dqmiolumiharvest::j, metsig::jet, reco::btau::jetAbsEta, reco::btau::jetEta, reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, reco::btau::jetPt, PV3DBase< T, PVType, FrameType >::mag2(), reco::btau::massVertexEnergyFraction, reco::btau::muonEnergyFraction, reco::btau::muonMultiplicity, reco::btau::neutralHadronEnergyFraction, reco::btau::neutralHadronMultiplicity, reco::btag::Vertices::NoVertex, reco::TrackKinematics::numberOfTracks(), convertSQLiteXML::ok, reco::btau::photonEnergyFraction, reco::btau::photonMultiplicity, reco::ParticleMasses::piPlus, pseudoMultiplicityMin, reco::btag::Vertices::PseudoVertex, pseudoVertexV0Filter, MetAnalyzer::pv(), sistrip::SpyUtilities::range(), range_for, dt_dqm_sourceclient_common_cff::reco, reco::btag::Vertices::RecoVertex, Measurement1D::significance(), sortCriterium, mathSSE::sqrt(), HGCalGeometryMode::Square, threshTrack(), reco::btau::totalMultiplicity, HLT_FULL_cff::track, reco::btau::trackDecayLenVal, reco::btau::trackDeltaR, reco::btau::trackEta, reco::btau::trackEtaRel, reco::btau::trackJetDistVal, reco::btau::trackJetPt, reco::btau::trackMomentum, trackMultiplicityMin, trackPairV0Filter, reco::btau::trackPPar, reco::btau::trackPParRatio, trackPseudoSelector, reco::btau::trackPtRatio, reco::btau::trackPtRel, tracks, trackSelector, reco::btau::trackSip2dSig, reco::btau::trackSip2dSigAboveCharm, reco::btau::trackSip2dVal, reco::btau::trackSip2dValAboveCharm, reco::btau::trackSip3dSig, reco::btau::trackSip3dSigAboveCharm, reco::btau::trackSip3dVal, reco::btau::trackSip3dValAboveCharm, reco::btau::trackSumJetDeltaR, reco::btau::trackSumJetEtRatio, useTrackWeights, Measurement1D::value(), reco::TrackKinematics::vectorSum(), reco::btau::vertexBoostOverSqrtJetPt, reco::btau::vertexCategory, reco::btau::vertexEnergyRatio, vertexFlip, reco::btau::vertexJetDeltaR, reco::btau::vertexMass, vertexMassCorrection, reco::btau::vertexNTracks, reco::TrackKinematics::weightedVectorSum(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by operator()().

                                                                            {
   using namespace ROOT::Math;
   using namespace reco;
 
   typedef typename IPTI::input_container Container;
   typedef typename Container::value_type TrackRef;
 
   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;
 
   vars.insert(btau::jetPt, jet->pt(), true);
   vars.insert(btau::jetEta, jet->eta(), true);
   vars.insert(btau::jetAbsEta, fabs(jet->eta()), true);
 
   if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
     return;
 
   vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);
 
   TrackKinematics allKinematics;
   TrackKinematics trackJetKinematics;
 
   double jet_track_ESum = 0.;
 
   int vtx = -1;
 
   IterationRange range = flipIterate(svInfo.nVertices(), true);
   range_for(i, range) {
     if (vtx < 0)
       vtx = i;
   }
 
   if (vtx >= 0) {
     vtxType = btag::Vertices::RecoVertex;
     vars.insert(btau::flightDistance1dVal, flipValue(svInfo.flightDistance(vtx, 1).value(), true), true);
     vars.insert(btau::flightDistance1dSig, flipValue(svInfo.flightDistance(vtx, 1).significance(), true), true);
     vars.insert(btau::flightDistance2dVal, flipValue(svInfo.flightDistance(vtx, 2).value(), true), true);
     vars.insert(btau::flightDistance2dSig, flipValue(svInfo.flightDistance(vtx, 2).significance(), true), true);
     vars.insert(btau::flightDistance3dVal, flipValue(svInfo.flightDistance(vtx, 3).value(), true), true);
     vars.insert(btau::flightDistance3dSig, flipValue(svInfo.flightDistance(vtx, 3).significance(), true), true);
     vars.insert(btau::vertexJetDeltaR, Geom::deltaR(svInfo.flightDirection(vtx), vertexFlip ? -jetDir : jetDir), true);
     vars.insert(btau::jetNSecondaryVertices, svInfo.nVertices(), true);
   }
 
   std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
   const std::vector<reco::btag::TrackIPData> &ipData = ipInfo.impactParameterData();
 
   const Container &tracks = ipInfo.selectedTracks();
   std::vector<TrackRef> pseudoVertexTracks;
 
   std::vector<TrackRef> trackPairV0Test(2);
   range = flipIterate(indices.size(), false);
   range_for(i, range) {
     std::size_t idx = indices[i];
     const reco::btag::TrackIPData &data = ipData[idx];
     const TrackRef &track = tracks[idx];
 
     jet_track_ESum += std::sqrt(track->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
 
     // 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 track -> this track selection can be tighter than the vertex track selection (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);
 
     // if no vertex was reconstructed, attempt pseudo vertex
     if (vtxType == btag::Vertices::NoVertex && trackPseudoSelector(track, data, *jet, pv)) {
       pseudoVertexTracks.push_back(track);
       vertexKinematics.add(track);
     }
 
     // check against all other tracks for V0 track pairs
     trackPairV0Test[0] = track;
     bool ok = true;
     range_for(j, range) {
       if (i == j)
         continue;
 
       std::size_t pairIdx = indices[j];
       const reco::btag::TrackIPData &pairTrackData = ipData[pairIdx];
       const TrackRef &pairTrack = tracks[pairIdx];
 
       if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
         continue;
 
       trackPairV0Test[1] = pairTrack;
       if (!trackPairV0Filter(trackPairV0Test)) {
         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::trackJetDistSig, data.distanceToJetAxis.significance(), true);
     //              vars.insert(btau::trackFirstTrackDist, data.distanceToFirstTrack, true);
     //              vars.insert(btau::trackGhostTrackVal, data.distanceToGhostTrack.value(), true);
     //              vars.insert(btau::trackGhostTrackSig, data.distanceToGhostTrack.significance(), true);
     vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);
 
     vars.insert(btau::trackMomentum, trackMag, true);
     vars.insert(btau::trackEta, trackMom.Eta(), true);
 
     // check for erroneous Perp^2 values before evaluating Perp (fix for DeepCSV NaN outputs)
     double perp_trackMom_jetDir = VectorUtil::Perp2(trackMom, jetDir);
     perp_trackMom_jetDir = (perp_trackMom_jetDir > 0. ? std::sqrt(perp_trackMom_jetDir) : 0.);
 
     vars.insert(btau::trackPtRel, 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, perp_trackMom_jetDir / trackMag, true);
     vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
   }
 
   if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin &&
       pseudoVertexV0Filter(pseudoVertexTracks)) {
     vtxType = btag::Vertices::PseudoVertex;
     for (typename std::vector<TrackRef>::const_iterator trkIt = pseudoVertexTracks.begin();
          trkIt != pseudoVertexTracks.end();
          ++trkIt) {
       vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, (*trkIt)->momentum()), true);
       vtx_track_ptSum += std::sqrt((*trkIt)->momentum().Perp2());
       vtx_track_ESum += std::sqrt((*trkIt)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
     }
   }
 
   vars.insert(btau::vertexCategory, vtxType, 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, reco::btag::IP3DSig, *jet, pv).ip3d.significance(), false),
               true);
   vars.insert(btau::trackSip3dValAboveCharm,
               flipValue(threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.value(), false),
               true);
   vars.insert(btau::trackSip2dSigAboveCharm,
               flipValue(threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.significance(), false),
               true);
   vars.insert(btau::trackSip2dValAboveCharm,
               flipValue(threshTrack(ipInfo, reco::btag::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();
     if (vtxType == btag::Vertices::RecoVertex && vertexMassCorrection) {
       const 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);
 
     double varPi = (vertexMass / 5.2794) *
                    (vtx_track_ESum / jet_track_ESum);  // 5.2794 should be the average B meson mass of PDG! CHECK!!!
     vars.insert(btau::massVertexEnergyFraction, varPi / (varPi + 0.04), true);
     double 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 != nullptr) {
     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 != nullptr && patJet->isPFJet()) {
     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 {
     vars.insert(btau::chargedHadronEnergyFraction, 0., true);
     vars.insert(btau::neutralHadronEnergyFraction, 0., true);
     vars.insert(btau::photonEnergyFraction, 0., true);
     vars.insert(btau::electronEnergyFraction, 0., true);
     vars.insert(btau::muonEnergyFraction, 0., true);
     vars.insert(btau::chargedHadronMultiplicity, 0, true);
     vars.insert(btau::neutralHadronMultiplicity, 0, true);
     vars.insert(btau::photonMultiplicity, 0, true);
     vars.insert(btau::electronMultiplicity, 0, true);
     vars.insert(btau::muonMultiplicity, 0, true);
     vars.insert(btau::hadronMultiplicity, 0, true);
     vars.insert(btau::hadronPhotonMultiplicity, 0, true);
     vars.insert(btau::totalMultiplicity, 0, true);
   }
 }

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

inline

Definition at line 31 of file CombinedSVComputer.cc.

References CombinedSVComputer::IterationRange::begin, CombinedSVComputer::IterationRange::end, CombinedSVComputer::IterationRange::increment, sistrip::SpyUtilities::range(), findQualityFiles::size, trackFlip, and vertexFlip.

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

                                                                                                    {
   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 CombinedSVComputer::flipValue	(	double	value,
		bool	vertex
	)		const

inline

Definition at line 27 of file CombinedSVComputer.cc.

References trackFlip, relativeConstraints::value, and vertexFlip.

Referenced by fillCommonVariables().

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

TaggingVariableList CombinedSVComputer::operator()	(	const reco::TrackIPTagInfo &	ipInfo,
		const reco::SecondaryVertexTagInfo &	svInfo
	)		const

virtual

Definition at line 133 of file CombinedSVComputer.cc.

References reco::btau::etaRel(), fillCommonVariables(), flipIterate(), reco::Vertex::hasRefittedTracks(), mps_fire::i, minTrackWeight, reco::LeafCandidate::momentum(), reco::TrackBase::momentum(), HLT_FULL_cff::normalizedChi2, BeamSpotPI::nTracks, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, range_for, reco::Vertex::refittedTrack(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), HGCalGeometryMode::Square, reco::btau::trackEtaRel, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), reco::btau::vertexFitProb, reco::btau::vertexNTracks, and w().

Referenced by CombinedSVSoftLeptonComputer::operator()().

                                                                                                {
   using namespace ROOT::Math;
 
   edm::RefToBase<Jet> jet = ipInfo.jet();
   math::XYZVector jetDir = jet->momentum().Unit();
   TaggingVariableList vars;
 
   TrackKinematics vertexKinematics;
 
   double vtx_track_ptSum = 0.;
   double vtx_track_ESum = 0.;
 
   // the following is specific depending on the type of vertex
   int vtx = -1;
   unsigned int numberofvertextracks = 0;
 
   IterationRange range = flipIterate(svInfo.nVertices(), true);
   range_for(i, range) {
     numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();
 
     const Vertex &vertex = svInfo.secondaryVertex(i);
     bool hasRefittedTracks = vertex.hasRefittedTracks();
     for (reco::Vertex::trackRef_iterator track = vertex.tracks_begin(); track != vertex.tracks_end(); track++) {
       double w = vertex.trackWeight(*track);
       if (w < minTrackWeight)
         continue;
       if (hasRefittedTracks) {
         const Track actualTrack = vertex.refittedTrack(*track);
         vertexKinematics.add(actualTrack, w);
         vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, actualTrack.momentum()), true);
         if (vtx < 0)  // calculate this only for the first vertex
         {
           vtx_track_ptSum += std::sqrt(actualTrack.momentum().Perp2());
           vtx_track_ESum += std::sqrt(actualTrack.momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
         }
       } else {
         vertexKinematics.add(**track, w);
         vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, (*track)->momentum()), true);
         if (vtx < 0)  // calculate this only for the first vertex
         {
           vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
           vtx_track_ESum += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
         }
       }
     }
 
     if (vtx < 0)
       vtx = i;
   }
   if (vtx >= 0) {
     vars.insert(btau::vertexNTracks, numberofvertextracks, true);
     vars.insert(btau::vertexFitProb, (svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
   }
 
   // after we collected vertex information we let the common code complete the job
   fillCommonVariables(vars, vertexKinematics, ipInfo, svInfo, vtx_track_ptSum, vtx_track_ESum);
 
   vars.finalize();
   return vars;
 }

TaggingVariableList CombinedSVComputer::operator()	(	const reco::CandIPTagInfo &	ipInfo,
		const reco::CandSecondaryVertexTagInfo &	svInfo
	)		const

virtual

Definition at line 195 of file CombinedSVComputer.cc.

References reco::CompositePtrCandidate::daughterPtrVector(), reco::btau::etaRel(), fillCommonVariables(), flipIterate(), mps_fire::i, reco::LeafCandidate::momentum(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, range_for, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), HGCalGeometryMode::Square, HLT_FULL_cff::track, reco::btau::trackEtaRel, reco::btau::vertexFitProb, and reco::btau::vertexNTracks.

                                                                                                    {
   using namespace ROOT::Math;
 
   edm::RefToBase<Jet> jet = ipInfo.jet();
   math::XYZVector jetDir = jet->momentum().Unit();
   TaggingVariableList vars;
 
   TrackKinematics vertexKinematics;
 
   double vtx_track_ptSum = 0.;
   double vtx_track_ESum = 0.;
 
   // the following is specific depending on the type of vertex
   int vtx = -1;
   unsigned int numberofvertextracks = 0;
 
   IterationRange range = flipIterate(svInfo.nVertices(), true);
   range_for(i, range) {
     numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).numberOfSourceCandidatePtrs();
 
     const reco::VertexCompositePtrCandidate &vertex = svInfo.secondaryVertex(i);
     const std::vector<CandidatePtr> &tracks = vertex.daughterPtrVector();
     for (std::vector<CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
       vertexKinematics.add(*track);
       vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, (*track)->momentum()), true);
       if (vtx < 0)  // calculate this only for the first vertex
       {
         vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
         vtx_track_ESum += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
       }
     }
 
     if (vtx < 0)
       vtx = i;
   }
   if (vtx >= 0) {
     vars.insert(btau::vertexNTracks, numberofvertextracks, true);
     vars.insert(btau::vertexFitProb, (svInfo.secondaryVertex(vtx)).vertexNormalizedChi2(), true);
   }
 
   // after we collected vertex information we let the common code complete the job
   fillCommonVariables(vars, vertexKinematics, ipInfo, svInfo, vtx_track_ptSum, vtx_track_ESum);
 
   vars.finalize();
   return vars;
 }

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

Referenced by fillCommonVariables().

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