Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-01-08 03:36:26 

0001 #include "RecoBTag/SecondaryVertex/interface/CombinedSVComputer.h"
0002 
0003 using namespace reco;
0004 
0005 inline edm::ParameterSet CombinedSVComputer::dropDeltaR(const edm::ParameterSet &pset) const {
0006   edm::ParameterSet psetCopy(pset);
0007   psetCopy.addParameter<double>("jetDeltaRMax", 99999.0);
0008   return psetCopy;
0009 }
0010 
0011 CombinedSVComputer::CombinedSVComputer(const edm::ParameterSet &params)
0012     : trackFlip(params.getParameter<bool>("trackFlip")),
0013       vertexFlip(params.getParameter<bool>("vertexFlip")),
0014       charmCut(params.getParameter<double>("charmCut")),
0015       sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
0016       trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
0017       trackNoDeltaRSelector(dropDeltaR(params.getParameter<edm::ParameterSet>("trackSelection"))),
0018       trackPseudoSelector(params.getParameter<edm::ParameterSet>("trackPseudoSelection")),
0019       pseudoMultiplicityMin(params.getParameter<unsigned int>("pseudoMultiplicityMin")),
0020       trackMultiplicityMin(params.getParameter<unsigned int>("trackMultiplicityMin")),
0021       minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
0022       useTrackWeights(params.getParameter<bool>("useTrackWeights")),
0023       vertexMassCorrection(params.getParameter<bool>("correctVertexMass")),
0024       pseudoVertexV0Filter(params.getParameter<edm::ParameterSet>("pseudoVertexV0Filter")),
0025       trackPairV0Filter(params.getParameter<edm::ParameterSet>("trackPairV0Filter")) {}
0026 
0027 inline double CombinedSVComputer::flipValue(double value, bool vertex) const {
0028   return (vertex ? vertexFlip : trackFlip) ? -value : value;
0029 }
0030 
0031 inline CombinedSVComputer::IterationRange CombinedSVComputer::flipIterate(int size, bool vertex) const {
0032   IterationRange range;
0033   if (vertex ? vertexFlip : trackFlip) {
0034     range.begin = size - 1;
0035     range.end = -1;
0036     range.increment = -1;
0037   } else {
0038     range.begin = 0;
0039     range.end = size;
0040     range.increment = +1;
0041   }
0042 
0043   return range;
0044 }
0045 
0046 const btag::TrackIPData &CombinedSVComputer::threshTrack(const CandIPTagInfo &trackIPTagInfo,
0047                                                          const btag::SortCriteria sort,
0048                                                          const reco::Jet &jet,
0049                                                          const GlobalPoint &pv) const {
0050   const CandIPTagInfo::input_container &tracks = trackIPTagInfo.selectedTracks();
0051   const std::vector<btag::TrackIPData> &ipData = trackIPTagInfo.impactParameterData();
0052   std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);
0053 
0054   IterationRange range = flipIterate(indices.size(), false);
0055   TrackKinematics kin;
0056   range_for(i, range) {
0057     std::size_t idx = indices[i];
0058     const btag::TrackIPData &data = ipData[idx];
0059     const CandidatePtr &track = tracks[idx];
0060 
0061     if (!trackNoDeltaRSelector(track, data, jet, pv))
0062       continue;
0063 
0064     kin.add(track);
0065     if (kin.vectorSum().M() > charmCut)
0066       return data;
0067   }
0068   if (trackFlip) {
0069     static const btag::TrackIPData dummy = {GlobalPoint(),
0070                                             GlobalPoint(),
0071                                             Measurement1D(1.0, 1.0),
0072                                             Measurement1D(1.0, 1.0),
0073                                             Measurement1D(1.0, 1.0),
0074                                             Measurement1D(1.0, 1.0),
0075                                             0.};
0076     return dummy;
0077   } else {
0078     static const btag::TrackIPData dummy = {GlobalPoint(),
0079                                             GlobalPoint(),
0080                                             Measurement1D(-1.0, 1.0),
0081                                             Measurement1D(-1.0, 1.0),
0082                                             Measurement1D(-1.0, 1.0),
0083                                             Measurement1D(-1.0, 1.0),
0084                                             0.};
0085     return dummy;
0086   }
0087 }
0088 
0089 const btag::TrackIPData &CombinedSVComputer::threshTrack(const TrackIPTagInfo &trackIPTagInfo,
0090                                                          const btag::SortCriteria sort,
0091                                                          const reco::Jet &jet,
0092                                                          const GlobalPoint &pv) const {
0093   const edm::RefVector<TrackCollection> &tracks = trackIPTagInfo.selectedTracks();
0094   const std::vector<btag::TrackIPData> &ipData = trackIPTagInfo.impactParameterData();
0095   std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);
0096 
0097   IterationRange range = flipIterate(indices.size(), false);
0098   TrackKinematics kin;
0099   range_for(i, range) {
0100     std::size_t idx = indices[i];
0101     const btag::TrackIPData &data = ipData[idx];
0102     const Track &track = *tracks[idx];
0103 
0104     if (!trackNoDeltaRSelector(track, data, jet, pv))
0105       continue;
0106 
0107     kin.add(track);
0108     if (kin.vectorSum().M() > charmCut)
0109       return data;
0110   }
0111 
0112   if (trackFlip) {
0113     static const btag::TrackIPData dummy = {GlobalPoint(),
0114                                             GlobalPoint(),
0115                                             Measurement1D(1.0, 1.0),
0116                                             Measurement1D(1.0, 1.0),
0117                                             Measurement1D(1.0, 1.0),
0118                                             Measurement1D(1.0, 1.0),
0119                                             0.};
0120     return dummy;
0121   } else {
0122     static const btag::TrackIPData dummy = {GlobalPoint(),
0123                                             GlobalPoint(),
0124                                             Measurement1D(-1.0, 1.0),
0125                                             Measurement1D(-1.0, 1.0),
0126                                             Measurement1D(-1.0, 1.0),
0127                                             Measurement1D(-1.0, 1.0),
0128                                             0.};
0129     return dummy;
0130   }
0131 }
0132 
0133 TaggingVariableList CombinedSVComputer::operator()(const TrackIPTagInfo &ipInfo,
0134                                                    const SecondaryVertexTagInfo &svInfo) const {
0135   using namespace ROOT::Math;
0136 
0137   edm::RefToBase<Jet> jet = ipInfo.jet();
0138   math::XYZVector jetDir = jet->momentum().Unit();
0139   TaggingVariableList vars;
0140 
0141   TrackKinematics vertexKinematics;
0142 
0143   double vtx_track_ptSum = 0.;
0144   double vtx_track_ESum = 0.;
0145 
0146   // the following is specific depending on the type of vertex
0147   int vtx = -1;
0148   unsigned int numberofvertextracks = 0;
0149 
0150   IterationRange range = flipIterate(svInfo.nVertices(), true);
0151   range_for(i, range) {
0152     numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();
0153 
0154     const Vertex &vertex = svInfo.secondaryVertex(i);
0155     bool hasRefittedTracks = vertex.hasRefittedTracks();
0156     for (reco::Vertex::trackRef_iterator track = vertex.tracks_begin(); track != vertex.tracks_end(); track++) {
0157       double w = vertex.trackWeight(*track);
0158       if (w < minTrackWeight)
0159         continue;
0160       if (hasRefittedTracks) {
0161         const Track actualTrack = vertex.refittedTrack(*track);
0162         vertexKinematics.add(actualTrack, w);
0163         vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, actualTrack.momentum()), true);
0164         if (vtx < 0)  // calculate this only for the first vertex
0165         {
0166           vtx_track_ptSum += std::sqrt(actualTrack.momentum().Perp2());
0167           vtx_track_ESum += std::sqrt(actualTrack.momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
0168         }
0169       } else {
0170         vertexKinematics.add(**track, w);
0171         vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, (*track)->momentum()), true);
0172         if (vtx < 0)  // calculate this only for the first vertex
0173         {
0174           vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
0175           vtx_track_ESum += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
0176         }
0177       }
0178     }
0179 
0180     if (vtx < 0)
0181       vtx = i;
0182   }
0183   if (vtx >= 0) {
0184     vars.insert(btau::vertexNTracks, numberofvertextracks, true);
0185     vars.insert(btau::vertexFitProb, (svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
0186   }
0187 
0188   // after we collected vertex information we let the common code complete the job
0189   fillCommonVariables(vars, vertexKinematics, ipInfo, svInfo, vtx_track_ptSum, vtx_track_ESum);
0190 
0191   vars.finalize();
0192   return vars;
0193 }
0194 
0195 TaggingVariableList CombinedSVComputer::operator()(const CandIPTagInfo &ipInfo,
0196                                                    const CandSecondaryVertexTagInfo &svInfo) const {
0197   using namespace ROOT::Math;
0198 
0199   edm::RefToBase<Jet> jet = ipInfo.jet();
0200   math::XYZVector jetDir = jet->momentum().Unit();
0201   TaggingVariableList vars;
0202 
0203   TrackKinematics vertexKinematics;
0204 
0205   double vtx_track_ptSum = 0.;
0206   double vtx_track_ESum = 0.;
0207 
0208   // the following is specific depending on the type of vertex
0209   int vtx = -1;
0210   unsigned int numberofvertextracks = 0;
0211 
0212   IterationRange range = flipIterate(svInfo.nVertices(), true);
0213   range_for(i, range) {
0214     numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).numberOfSourceCandidatePtrs();
0215 
0216     const reco::VertexCompositePtrCandidate &vertex = svInfo.secondaryVertex(i);
0217     const std::vector<CandidatePtr> &tracks = vertex.daughterPtrVector();
0218     for (std::vector<CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
0219       vertexKinematics.add(*track);
0220       vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir, (*track)->momentum()), true);
0221       if (vtx < 0)  // calculate this only for the first vertex
0222       {
0223         vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
0224         vtx_track_ESum += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
0225       }
0226     }
0227 
0228     if (vtx < 0)
0229       vtx = i;
0230   }
0231   if (vtx >= 0) {
0232     vars.insert(btau::vertexNTracks, numberofvertextracks, true);
0233     vars.insert(btau::vertexFitProb, (svInfo.secondaryVertex(vtx)).vertexNormalizedChi2(), true);
0234   }
0235 
0236   // after we collected vertex information we let the common code complete the job
0237   fillCommonVariables(vars, vertexKinematics, ipInfo, svInfo, vtx_track_ptSum, vtx_track_ESum);
0238 
0239   vars.finalize();
0240   return vars;
0241 }
0242 
0243 void CombinedSVComputer::fillPSetDescription(edm::ParameterSetDescription &desc) {
0244   {
0245     edm::ParameterSetDescription trackPseudoSelection;
0246     trackPseudoSelection.add<double>("max_pT_dRcut", 0.1);
0247     trackPseudoSelection.add<double>("b_dR", 0.6263);
0248     trackPseudoSelection.add<double>("min_pT", 120.0);
0249     trackPseudoSelection.add<double>("b_pT", 0.3684);
0250     trackPseudoSelection.add<double>("ptMin", 0.0);
0251     trackPseudoSelection.add<double>("max_pT_trackPTcut", 3.0);
0252     trackPseudoSelection.add<double>("max_pT", 500.0);
0253     trackPseudoSelection.add<bool>("useVariableJTA", false);
0254     trackPseudoSelection.add<double>("maxDecayLen", 5.0);
0255     trackPseudoSelection.add<std::string>("qualityClass", "any");
0256     trackPseudoSelection.add<double>("normChi2Max", 99999.9);
0257     trackPseudoSelection.add<double>("sip2dValMin", -99999.9);
0258     trackPseudoSelection.add<double>("sip3dValMin", -99999.9);
0259     trackPseudoSelection.add<double>("a_dR", -0.001053);
0260     trackPseudoSelection.add<double>("maxDistToAxis", 0.07);
0261     trackPseudoSelection.add<uint32_t>("totalHitsMin", 3);
0262     trackPseudoSelection.add<double>("a_pT", 0.005263);
0263     trackPseudoSelection.add<double>("sip2dSigMax", 99999.9);
0264     trackPseudoSelection.add<double>("sip2dValMax", 99999.9);
0265     trackPseudoSelection.add<double>("sip3dSigMax", 99999.9);
0266     trackPseudoSelection.add<double>("sip3dValMax", 99999.9);
0267     trackPseudoSelection.add<double>("min_pT_dRcut", 0.5);
0268     trackPseudoSelection.add<double>("jetDeltaRMax", 0.3);
0269     trackPseudoSelection.add<uint32_t>("pixelHitsMin", 0);
0270     trackPseudoSelection.add<double>("sip3dSigMin", -99999.9);
0271     trackPseudoSelection.add<double>("sip2dSigMin", 2.0);
0272     desc.add("trackPseudoSelection", trackPseudoSelection);
0273   }
0274 
0275   {
0276     edm::ParameterSetDescription trackSelection;
0277     trackSelection.add<double>("max_pT_dRcut", 0.1);
0278     trackSelection.add<double>("b_dR", 0.6263);
0279     trackSelection.add<double>("min_pT", 120.0);
0280     trackSelection.add<double>("b_pT", 0.3684);
0281     trackSelection.add<double>("ptMin", 0.0);
0282     trackSelection.add<double>("max_pT_trackPTcut", 3.0);
0283     trackSelection.add<double>("max_pT", 500.0);
0284     trackSelection.add<bool>("useVariableJTA", false);
0285     trackSelection.add<double>("maxDecayLen", 5.0);
0286     trackSelection.add<std::string>("qualityClass", "any");
0287     trackSelection.add<double>("normChi2Max", 99999.9);
0288     trackSelection.add<double>("sip2dValMin", -99999.9);
0289     trackSelection.add<double>("sip3dValMin", -99999.9);
0290     trackSelection.add<double>("a_dR", -0.001053);
0291     trackSelection.add<double>("maxDistToAxis", 0.07);
0292     trackSelection.add<uint32_t>("totalHitsMin", 3);
0293     trackSelection.add<double>("a_pT", 0.005263);
0294     trackSelection.add<double>("sip2dSigMax", 99999.9);
0295     trackSelection.add<double>("sip2dValMax", 99999.9);
0296     trackSelection.add<double>("sip3dSigMax", 99999.9);
0297     trackSelection.add<double>("sip3dValMax", 99999.9);
0298     trackSelection.add<double>("min_pT_dRcut", 0.5);
0299     trackSelection.add<double>("jetDeltaRMax", 0.3);
0300     trackSelection.add<uint32_t>("pixelHitsMin", 2);
0301     trackSelection.add<double>("sip3dSigMin", -99999.9);
0302     trackSelection.add<double>("sip2dSigMin", -99999.9);
0303     desc.add("trackSelection", trackSelection);
0304   }
0305 
0306   edm::ParameterSetDescription trackPairV0Filter;
0307   trackPairV0Filter.add<double>("k0sMassWindow", 0.03);
0308   desc.add("trackPairV0Filter", trackPairV0Filter);
0309 
0310   edm::ParameterSetDescription pseudoVertexV0Filter;
0311   pseudoVertexV0Filter.add<double>("k0sMassWindow", 0.05);
0312   desc.add("pseudoVertexV0Filter", pseudoVertexV0Filter);
0313 
0314   desc.add<bool>("trackFlip", false);
0315   desc.add<bool>("useTrackWeights", true);
0316   desc.add<bool>("SoftLeptonFlip", false);
0317   desc.add<uint32_t>("pseudoMultiplicityMin", 2);
0318   desc.add<bool>("correctVertexMass", true);
0319   desc.add<double>("minimumTrackWeight", 0.5);
0320   desc.add<double>("charmCut", 1.5);
0321   desc.add<std::string>("trackSort", "sip2dSig");
0322   desc.add<uint32_t>("trackMultiplicityMin", 2);
0323   desc.add<bool>("vertexFlip", false);
0324 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!