df/d1d/CombinedSVComputer_8h_source.html

 #ifndef RecoBTag_SecondaryVertex_CombinedSVComputer_h

 #define RecoBTag_SecondaryVertex_CombinedSVComputer_h


 #include <iostream>

 #include <cstddef>

 #include <string>

 #include <cmath>

 #include <vector>


 #include <Math/VectorUtil.h>


 #include "FWCore/ParameterSet/interface/ParameterSet.h"

 #include "FWCore/Utilities/interface/Exception.h"

 #include "FWCore/ParameterSet/interface/ParameterSet.h"


 #include "DataFormats/Math/interface/Vector3D.h"

 #include "DataFormats/Math/interface/LorentzVector.h"

 #include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"

 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"

 #include "DataFormats/GeometryVector/interface/GlobalVector.h"

 #include "DataFormats/GeometryVector/interface/VectorUtil.h"

 #include "DataFormats/TrackReco/interface/Track.h"

 #include "DataFormats/TrackReco/interface/TrackFwd.h"

 #include "DataFormats/BTauReco/interface/SecondaryVertexTagInfo.h"

 #include "DataFormats/BTauReco/interface/CandSecondaryVertexTagInfo.h"

 #include "DataFormats/BTauReco/interface/TaggingVariable.h"

 #include "DataFormats/BTauReco/interface/VertexTypes.h"

 #include "DataFormats/BTauReco/interface/ParticleMasses.h"

 #include "DataFormats/JetReco/interface/PFJet.h"

 #include "DataFormats/PatCandidates/interface/Jet.h"


 #include "RecoBTag/SecondaryVertex/interface/TrackSelector.h"

 #include "RecoBTag/SecondaryVertex/interface/V0Filter.h"

 #include "RecoBTag/SecondaryVertex/interface/TrackSorting.h"

 #include "RecoBTag/SecondaryVertex/interface/TrackKinematics.h"


 #define range_for(i, x) for (int i = (x).begin; i != (x).end; i += (x).increment)


 class CombinedSVComputer {

 public:

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

   virtual ~CombinedSVComputer() = default;

   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;


   struct IterationRange {

     int begin, end, increment;

   };

   double flipValue(double value, bool vertex) const;

   IterationRange flipIterate(int size, bool vertex) const;


   edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset) 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;

   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;


 private:

   bool trackFlip;

   bool vertexFlip;

   double charmCut;

   reco::btag::SortCriteria sortCriterium;

   reco::TrackSelector trackSelector;

   reco::TrackSelector trackNoDeltaRSelector;

   reco::TrackSelector trackPseudoSelector;

   unsigned int pseudoMultiplicityMin;

   unsigned int trackMultiplicityMin;

   double minTrackWeight;

   bool useTrackWeights;

   bool vertexMassCorrection;

   reco::V0Filter pseudoVertexV0Filter;

   reco::V0Filter trackPairV0Filter;

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

 };


 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 {

   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);

   }

 }


 #endif  // RecoBTag_SecondaryVertex_CombinedSVComputer_h

metsig::jet
Definition: SignAlgoResolutions.h:47

reco::TaggingVariableList
Definition: TaggingVariable.h:194

reco::btau::jetEta
Definition: TaggingVariable.h:34

CombinedSVComputer::trackSelector
reco::TrackSelector trackSelector
Definition: CombinedSVComputer.h:77

MetAnalyzer.pv
def pv
Definition: MetAnalyzer.py:7

reco::ParticleMasses::piPlus
const double piPlus
Definition: ParticleMasses.h:9

reco::btag::IP2DSig
Definition: IPTagInfo.h:43

PV3DBase::mag2
T mag2() const
Definition: PV3DBase.h:63

HLT_FULL_cff.deltaR
tuple deltaR
Definition: HLT_FULL_cff.py:7048

reco::TrackKinematics::weightedVectorSum
const math::XYZTLorentzVector & weightedVectorSum() const
Definition: TrackKinematics.h:48

SecondaryVertexTagInfo.h

dqmiolumiharvest.j
tuple j
Definition: dqmiolumiharvest.py:66

mps_fire.i
i
Definition: mps_fire.py:428

reco::btau::flightDistance1dVal
Definition: TaggingVariable.h:82

reco::btau::trackEta
Definition: TaggingVariable.h:42

reco::btau::trackPtRatio
Definition: TaggingVariable.h:51

reco::btau::trackSip2dSig
Definition: TaggingVariable.h:55

reco::btau::trackPParRatio
Definition: TaggingVariable.h:52

CombinedSVComputer::trackFlip
bool trackFlip
Definition: CombinedSVComputer.h:73

reco::btau::trackSip3dValAboveCharm
Definition: TaggingVariable.h:91

reco::btau::photonMultiplicity
Definition: TaggingVariable.h:110

CombinedSVComputer::~CombinedSVComputer
virtual ~CombinedSVComputer()=default

ParticleMasses.h

CombinedSVComputer::pseudoMultiplicityMin
unsigned int pseudoMultiplicityMin
Definition: CombinedSVComputer.h:80

reco::btau::vertexJetDeltaR
Definition: TaggingVariable.h:80

reco::TrackKinematics::add
void add(const reco::Track &track, double weight=1.0)
Definition: TrackKinematics.cc:57

reco::btau::muonMultiplicity
Definition: TaggingVariable.h:112

edm::Ref< TrackCollection >

Vector3DBase
Definition: Vector3DBase.h:8

relativeConstraints.value
tuple value
Definition: relativeConstraints.py:55

CombinedSVComputer::vertexMassCorrection
bool vertexMassCorrection
Definition: CombinedSVComputer.h:84

reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20

reco::btau::etaRel
double etaRel(const math::XYZVector &dir, const math::XYZVector &track)
Definition: TaggingVariable.h:22

reco::btag::Vertices::RecoVertex
Definition: VertexTypes.h:18

reco::btag::TrackIPData::ip2d
Measurement1D ip2d
Definition: IPTagInfo.h:31

CombinedSVComputer::trackNoDeltaRSelector
reco::TrackSelector trackNoDeltaRSelector
Definition: CombinedSVComputer.h:78

reco::btau::trackMomentum
Definition: TaggingVariable.h:41

CombinedSVComputer::useTrackWeights
bool useTrackWeights
Definition: CombinedSVComputer.h:83

CombinedSVComputer::pseudoVertexV0Filter
reco::V0Filter pseudoVertexV0Filter
Definition: CombinedSVComputer.h:85

TrackValidation_cff.pset
tuple pset
Definition: TrackValidation_cff.py:591

reco::btau::trackSip3dSigAboveCharm
Definition: TaggingVariable.h:92

GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10

PV3DBase::y
T y() const
Definition: PV3DBase.h:60

reco::btau::jetAbsEta
Definition: TaggingVariable.h:35

reco::TemplatedSecondaryVertexTagInfo
Definition: TemplatedSecondaryVertexTagInfo.h:47

reco::btau::trackSumJetEtRatio
Definition: TaggingVariable.h:66

submitPVValidationJobs.params
list params
Definition: submitPVValidationJobs.py:487

reco::btau::trackSip2dVal
Definition: TaggingVariable.h:54

tracks
auto const & tracks
cannot be loose
Definition: CAHitNtupletGeneratorKernelsImpl.h:146

TrackFwd.h

CombinedSVComputer::operator()
virtual reco::TaggingVariableList operator()(const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const
Definition: CombinedSVComputer.cc:133

reco::btau::muonEnergyFraction
Definition: TaggingVariable.h:107

reco::btau::trackJetPt
Definition: TaggingVariable.h:33

HLT_FULL_cff.track
tuple track
Definition: HLT_FULL_cff.py:11953

CombinedSVComputer::CombinedSVComputer
CombinedSVComputer(const edm::ParameterSet &params)
Definition: CombinedSVComputer.cc:11

dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:111

reco::btau::flightDistance3dVal
Definition: TaggingVariable.h:86

reco::btau::trackSip2dSigAboveCharm
Definition: TaggingVariable.h:90

reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:20

edm::RefToBase< Jet >

reco::btau::trackSip3dSig
Definition: TaggingVariable.h:57

reco::V0Filter
Definition: V0Filter.h:14

reco::btau::chargedHadronEnergyFraction
Definition: TaggingVariable.h:103

reco::btag::Vertices::PseudoVertex
Definition: VertexTypes.h:18

sistrip::SpyUtilities::range
const uint16_t range(const Frame &aFrame)
Definition: SiStripSpyUtilities.cc:76

ParameterSet.h

reco::btag::TrackIPData
Definition: IPTagInfo.h:28

reco::btau::trackSumJetDeltaR
Definition: TaggingVariable.h:67

math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29

reco::btag::Vertices::NoVertex
Definition: VertexTypes.h:18

CombinedSVComputer::sortCriterium
reco::btag::SortCriteria sortCriterium
Definition: CombinedSVComputer.h:76

TrackSorting.h

reco::JetExtendedAssociation::value_type
Container::value_type value_type
Definition: JetExtendedAssociation.h:30

CombinedSVComputer
Definition: CombinedSVComputer.h:39

reco::btau::trackPPar
Definition: TaggingVariable.h:48

V0Filter.h

reco::btau::jetPt
Definition: TaggingVariable.h:32

CombinedSVComputer::IterationRange::end
int end
Definition: CombinedSVComputer.h:49

VertexTypes.h

CombinedSVComputer::trackPseudoSelector
reco::TrackSelector trackPseudoSelector
Definition: CombinedSVComputer.h:79

DeadROC_duringRun.dir
string dir
Definition: DeadROC_duringRun.py:23

CombinedSVComputer::charmCut
double charmCut
Definition: CombinedSVComputer.h:75

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19

reco::btau::neutralHadronEnergyFraction
Definition: TaggingVariable.h:104

reco::btau::totalMultiplicity
Definition: TaggingVariable.h:115

PV3DBase::z
T z() const
Definition: PV3DBase.h:61

HGCalGeometryMode::Square
Definition: HGCalGeometryMode.h:26

VectorUtil.h

reco::btau::jetNTracks
Definition: TaggingVariable.h:37

reco::btag::Vertices::VertexType
VertexType
Definition: VertexTypes.h:18

reco::TrackKinematics
Definition: TrackKinematics.h:16

reco::btau::electronEnergyFraction
Definition: TaggingVariable.h:106

reco::btau::massVertexEnergyFraction
Definition: TaggingVariable.h:117

reco::btau::vertexBoostOverSqrtJetPt
Definition: TaggingVariable.h:118

CandSecondaryVertexTagInfo.h

reco::btau::chargedHadronMultiplicity
Definition: TaggingVariable.h:108

reco::btau::trackSip3dVal
Definition: TaggingVariable.h:56

LorentzVector.h

reco::btag::TrackIPData::ip3d
Measurement1D ip3d
Definition: IPTagInfo.h:32

CombinedSVComputer::flipIterate
IterationRange flipIterate(int size, bool vertex) const
Definition: CombinedSVComputer.cc:31

reco::btau::flightDistance2dSig
Definition: TaggingVariable.h:85

reco::btau::flightDistance1dSig
Definition: TaggingVariable.h:83

GlobalVector.h

CombinedSVComputer::trackPairV0Filter
reco::V0Filter trackPairV0Filter
Definition: CombinedSVComputer.h:86

reco::btau::electronMultiplicity
Definition: TaggingVariable.h:111

CombinedSVComputer::taggingVariables
std::vector< reco::btau::TaggingVariableName > taggingVariables
Definition: CombinedSVComputer.h:87

CombinedSVComputer::vertexFlip
bool vertexFlip
Definition: CombinedSVComputer.h:74

reco::btau::vertexEnergyRatio
Definition: TaggingVariable.h:79

Exception.h

Measurement1D::significance
double significance() const
Definition: Measurement1D.h:29

reco::btau::trackDeltaR
Definition: TaggingVariable.h:50

reco::TrackKinematics::numberOfTracks
unsigned int numberOfTracks() const
Definition: TrackKinematics.h:44

reco::btau::photonEnergyFraction
Definition: TaggingVariable.h:105

range_for
#define range_for(i, x)
Definition: CombinedSVComputer.h:37

reco::btag::TrackIPData::closestToJetAxis
GlobalPoint closestToJetAxis
Definition: IPTagInfo.h:29

TrackKinematics.h

math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:31

reco::btau::flightDistance2dVal
Definition: TaggingVariable.h:84

reco::btau::trackSip2dValAboveCharm
Definition: TaggingVariable.h:89

Measurement1D.h

CombinedSVComputer::flipValue
double flipValue(double value, bool vertex) const
Definition: CombinedSVComputer.cc:27

reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20

pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77

CombinedSVComputer::dropDeltaR
edm::ParameterSet dropDeltaR(const edm::ParameterSet &pset) const
Definition: CombinedSVComputer.cc:5

reco::btau::hadronPhotonMultiplicity
Definition: TaggingVariable.h:114

Measurement1D::value
double value() const
Definition: Measurement1D.h:25

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

TrackSelector.h

reco::btag::TrackIPData::distanceToJetAxis
Measurement1D distanceToJetAxis
Definition: IPTagInfo.h:33

reco::TrackSelector
Definition: TrackSelector.h:14

Point3DBase< float, GlobalTag >

CombinedSVComputer::IterationRange::increment
int increment
Definition: CombinedSVComputer.h:49

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

TaggingVariable.h

data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79

reco::btau::flightDistance3dSig
Definition: TaggingVariable.h:87

CombinedSVComputer::minTrackWeight
double minTrackWeight
Definition: CombinedSVComputer.h:82

reco::TrackKinematics::vectorSum
const math::XYZTLorentzVector & vectorSum() const
Definition: TrackKinematics.h:47

Vector3D.h

reco::btag::SortCriteria
SortCriteria
Definition: IPTagInfo.h:43

CombinedSVComputer::IterationRange
Definition: CombinedSVComputer.h:48

Jet.h

reco::btau::hadronMultiplicity
Definition: TaggingVariable.h:113

Track.h

CombinedSVComputer::IterationRange::begin
int begin
Definition: CombinedSVComputer.h:49

edm::ParameterSet
Definition: ParameterSet.h:47

reco::btau::neutralHadronMultiplicity
Definition: TaggingVariable.h:109

vars
vars
Definition: DeepTauId.cc:164

HLT_FULL_cff.DeltaR
tuple DeltaR
Definition: HLT_FULL_cff.py:479

dqmdumpme.indices
list indices
Definition: dqmdumpme.py:50

PV3DBase::x
T x() const
Definition: PV3DBase.h:59

reco::btau::vertexNTracks
Definition: TaggingVariable.h:76

reco::btau::trackEtaRel
Definition: TaggingVariable.h:49

PFJet.h

convertSQLiteXML.ok
ok
Definition: convertSQLiteXML.py:98

reco::IPTagInfo
Definition: IPTagInfo.h:48

reco::JetExtendedAssociation::Container
edm::AssociationVector< reco::JetRefBaseProd, Values > Container
Definition: JetExtendedAssociation.h:29

reco::btau::jetNSecondaryVertices
Definition: TaggingVariable.h:72

reco::btau::trackPtRel
Definition: TaggingVariable.h:47

findQualityFiles.size
tuple size
Write out results.
Definition: findQualityFiles.py:443

reco::btau::vertexCategory
Definition: TaggingVariable.h:69

reco::btau::trackJetDistVal
Definition: TaggingVariable.h:60

reco::btau::trackDecayLenVal
Definition: TaggingVariable.h:58

reco::TaggingVariableList::insert
void insert(const TaggingVariable &variable, bool delayed=false)
Definition: TaggingVariable.cc:330

reco::btau::vertexMass
Definition: TaggingVariable.h:75

CombinedSVComputer::trackMultiplicityMin
unsigned int trackMultiplicityMin
Definition: CombinedSVComputer.h:81

GlobalPoint.h

reco::btag::IP3DSig
Definition: IPTagInfo.h:43