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


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


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

     }


     std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);

     const std::vector<reco::btag::TrackIPData> &ipData = ipInfo.impactParameterData();


     const typename IPTI::input_container &tracks = ipInfo.selectedTracks();

     std::vector<const Track *> pseudoVertexTracks;


         const Track * 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 Track * trackPtr = reco::btag::toTrack(tracks[idx]);

                 const Track &track = *trackPtr;


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

                         vertexKinematics.add(track);

                 }


                 // check against all other tracks for V0 track pairs

                 trackPairV0Test[0] = reco::btag::toTrack(tracks[idx]);

                 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 Track * pairTrackPtr = reco::btag::toTrack(tracks[pairIdx]);

                         const Track &pairTrack = *pairTrackPtr;


                         if (!trackSelector(pairTrack, pairTrackData, *jet, pv))

                                 continue;


                         trackPairV0Test[1] = pairTrackPtr;

                         if (!trackPairV0Filter(trackPairV0Test, 2)) {

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


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

         }


         if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks))

         {

                 vtxType = btag::Vertices::PseudoVertex;

                 for(std::vector<const Track *>::const_iterator track = pseudoVertexTracks.begin(); track != pseudoVertexTracks.end(); ++track)

                 {

                         vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*track)->momentum()), true);

                         vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());

                         vtx_track_ESum  += std::sqrt((*track)->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) {

                         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 != 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 && 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:40

reco::TaggingVariableList
Definition: TaggingVariable.h:164

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

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

MetAnalyzer.pv
def pv
Definition: MetAnalyzer.py:6

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

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

i
int i
Definition: DBlmapReader.cc:9

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

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

SecondaryVertexTagInfo.h

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

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

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

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

CombinedSVComputer::trackFlip
bool trackFlip
Definition: CombinedSVComputer.h:77

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

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

ParticleMasses.h

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

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

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

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

Vector3DBase< float, GlobalTag >

relativeConstraints.value
tuple value
Definition: relativeConstraints.py:54

CombinedSVComputer::vertexMassCorrection
bool vertexMassCorrection
Definition: CombinedSVComputer.h:88

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:23

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:82

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

CombinedSVComputer::useTrackWeights
bool useTrackWeights
Definition: CombinedSVComputer.h:87

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

python.multivaluedict.sort
def sort
Definition: multivaluedict.py:161

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

GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10

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

reco::TemplatedSecondaryVertexTagInfo< reco::TrackIPTagInfo, reco::Vertex >

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

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

TrackFwd.h

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

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

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

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

reco::TrackBase::momentum
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:662

dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:106

reco::btag::toTrack
const reco::Track * toTrack(const reco::TrackBaseRef &t)
Definition: IPTagInfo.h:24

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

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

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

edm::RefToBase< Jet >

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

reco::V0Filter
Definition: V0Filter.h:13

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

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

ParameterSet.h

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

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

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:80

TrackSorting.h

CombinedSVComputer
Definition: CombinedSVComputer.h:42

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

V0Filter.h

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

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

VertexTypes.h

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

CombinedSVComputer::charmCut
double charmCut
Definition: CombinedSVComputer.h:79

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

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

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

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

VectorUtil.h

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

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

j
int j
Definition: DBlmapReader.cc:9

reco::TrackKinematics
Definition: TrackKinematics.h:14

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

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

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

CandSecondaryVertexTagInfo.h

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

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

LorentzVector.h

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

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

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

GlobalVector.h

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

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

deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17

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

CombinedSVComputer::vertexFlip
bool vertexFlip
Definition: CombinedSVComputer.h:78

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

Exception.h

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

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

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

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

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

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

TrackKinematics.h

testEve_cfg.tracks
tuple tracks
Definition: testEve_cfg.py:39

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

customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15

HLT_25ns14e33_v1_cff.DeltaR
tuple DeltaR
Definition: HLT_25ns14e33_v1_cff.py:6041

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

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

Measurement1D.h

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

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

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

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

reco::Track
Definition: Track.h:28

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

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:13

Point3DBase< float, GlobalTag >

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

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:95

TaggingVariable.h

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

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

CombinedSVComputer::minTrackWeight
double minTrackWeight
Definition: CombinedSVComputer.h:86

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

Vector3D.h

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

CombinedSVComputer::IterationRange
Definition: CombinedSVComputer.h:53

Jet.h

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

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

edm::ParameterSet
Definition: ParameterSet.h:36

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

dir
dbl *** dir
Definition: mlp_gen.cc:35

Track.h

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

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

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

convertSQLiteXML.ok
ok
Definition: convertSQLiteXML.py:97

reco::IPTagInfo
Definition: IPTagInfo.h:51

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

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

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

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

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

PFJet.h

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

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

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

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

GlobalPoint.h

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