CMS 3D CMS Logo

/data/refman/pasoursint/CMSSW_4_1_8_patch12/src/RecoTauTag/RecoTau/src/RecoTauDiscriminantFunctions.cc

Go to the documentation of this file.
00001 #include "RecoTauTag/RecoTau/interface/RecoTauDiscriminantFunctions.h"
00002 #include "DataFormats/Math/interface/deltaR.h"
00003 #include <algorithm>
00004 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
00005 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
00006 #include "DataFormats/TauReco/interface/RecoTauPiZero.h"
00007 #include <boost/foreach.hpp>
00008 
00009 namespace reco { namespace tau { namespace disc {
00010 
00011 // Helper functions
00012 namespace {
00013 
00014 const PFCandidate& removeRef(const PFCandidateRef& pfRef) {
00015   return *pfRef;
00016 }
00017 
00018 const RecoTauPiZero& removeRef(const RecoTauPiZero& piZero) {
00019   return piZero;
00020 }
00021 
00022 // A PFTau member function
00023 template<typename Collection, typename Function>
00024 VDouble extract(const Collection& cands, Function func) {
00025   // #define CALL_MEMBER_FN(object,ptrToMember)  ((object).*(ptrToMember))
00026   VDouble output;
00027   output.reserve(cands.size());
00028   for(typename Collection::const_iterator cand = cands.begin();
00029       cand != cands.end(); ++cand) {
00030     output.push_back(func(removeRef(*cand)));
00031   }
00032   return output;
00033 }
00034 
00035 class DeltaRToAxis {
00036   public:
00037     DeltaRToAxis(const reco::Candidate::LorentzVector& axis):axis_(axis){}
00038     double operator()(const Candidate& cand)
00039     {
00040       return deltaR(cand.p4(), axis_);
00041     }
00042   private:
00043     const reco::Candidate::LorentzVector& axis_;
00044 };
00045 
00046 } // end helper functions
00047 
00048 PFCandidateRef mainTrack(Tau tau) {
00049   if (tau.signalPFChargedHadrCands().size() ==  3) {
00050     for (size_t itrk = 0; itrk < 3; ++itrk) {
00051       if (tau.signalPFChargedHadrCands()[itrk]->charge() * tau.charge() < 0)
00052         return tau.signalPFChargedHadrCands()[itrk];
00053     }
00054   }
00055   return tau.leadPFChargedHadrCand();
00056 }
00057 
00058 PFCandidateRefVector notMainTrack(Tau tau)
00059 {
00060   const PFCandidateRef& mainTrackRef = mainTrack(tau);
00061   PFCandidateRefVector output;
00062   output.reserve(tau.signalPFChargedHadrCands().size() - 1);
00063   BOOST_FOREACH(const PFCandidateRef& ref, tau.signalPFChargedHadrCands()) {
00064     if (ref != mainTrackRef)
00065       output.push_back(ref);
00066   }
00067   return output;
00068 }
00069 
00070 /*
00071  * HPStanc variables
00072  */
00073 
00074 double JetPt(Tau tau) {
00075   return tau.jetRef()->pt();
00076 }
00077 
00078 double JetEta(Tau tau) {
00079   return tau.jetRef()->eta();
00080 }
00081 
00082 double JetWidth(Tau tau) {
00083   return std::sqrt(
00084       std::abs(tau.jetRef()->etaetaMoment()) +
00085       std::abs(tau.jetRef()->phiphiMoment()));
00086 }
00087 
00088 double SignalPtFraction(Tau tau) {
00089   return tau.pt()/tau.jetRef()->pt();
00090 }
00091 
00092 double IsolationChargedPtFraction(Tau tau) {
00093   return tau.isolationPFChargedHadrCandsPtSum()/tau.jetRef()->pt();
00094 }
00095 
00096 double IsolationECALPtFraction(Tau tau) {
00097   return tau.isolationPFGammaCandsEtSum()/tau.jetRef()->pt();
00098 }
00099 
00100 double IsolationNeutralHadronPtFraction(Tau tau) {
00101   double sum = 0.0;
00102   BOOST_FOREACH(PFCandidateRef cand, tau.isolationPFNeutrHadrCands()) {
00103     sum += cand->pt();
00104   }
00105   return sum/tau.jetRef()->pt();
00106 }
00107 
00108 double ScaledEtaJetCollimation(Tau tau) {
00109   return tau.jetRef()->pt()*sqrt(std::abs(
00110           tau.jetRef()->etaetaMoment()));
00111 }
00112 
00113 double ScaledOpeningDeltaR(Tau tau) {
00114   double max = 0.0;
00115   const PFCandidateRefVector& cands = tau.signalPFCands();
00116   for (size_t i = 0; i < cands.size()-1; ++i) {
00117     for (size_t j = i+1; j < cands.size(); ++j) {
00118       double deltaRVal = deltaR(cands[i]->p4(), cands[j]->p4());
00119       if (deltaRVal > max) {
00120         max = deltaRVal;
00121       }
00122     }
00123   }
00124   // Correct for resolution
00125   if ( max < 0.05 )
00126     max = 0.05;
00127   // Make invariant of PT
00128   return max*tau.pt();;
00129 }
00130 
00131 double ScaledPhiJetCollimation(Tau tau) {
00132   return tau.jetRef()->pt()*sqrt(std::abs(
00133           tau.jetRef()->phiphiMoment()));
00134 }
00135 
00136 double IsolationChargedAveragePtFraction(Tau tau) {
00137   size_t nIsoCharged = tau.isolationPFChargedHadrCands().size();
00138   double averagePt = (nIsoCharged) ?
00139       tau.isolationPFChargedHadrCandsPtSum()/nIsoCharged : 0;
00140   return averagePt/tau.leadPFChargedHadrCand()->pt();
00141 }
00142 
00143 double MainTrackPtFraction(Tau tau) {
00144   return mainTrack(tau)->pt()/tau.jetRef()->pt();
00145 }
00146 
00147 VDouble Dalitz2(Tau tau) {
00148   PFCandidateRef theMainTrack = mainTrack(tau);
00149   PFCandidateRefVector otherSignalTracks = notMainTrack(tau);
00150   const std::vector<RecoTauPiZero> &pizeros = tau.signalPiZeroCandidates();
00151   VDouble output;
00152   output.reserve(otherSignalTracks.size() + pizeros.size());
00153   // Add combos with tracks
00154   BOOST_FOREACH(PFCandidateRef trk, otherSignalTracks) {
00155     reco::Candidate::LorentzVector p4 = theMainTrack->p4() + trk->p4();
00156     output.push_back(p4.mass());
00157   }
00158   // Add combos with pizeros
00159   BOOST_FOREACH(const RecoTauPiZero &pizero, pizeros) {
00160     reco::Candidate::LorentzVector p4 = theMainTrack->p4() + pizero.p4();
00161     output.push_back(p4.mass());
00162   }
00163   return output;
00164 }
00165 
00166 double IsolationChargedSumHard(Tau tau) {
00167   VDouble isocands = extract(tau.isolationPFChargedHadrCands(),
00168                              std::mem_fun_ref(&PFCandidate::pt));
00169   double output = 0.0;
00170   BOOST_FOREACH(double pt, isocands) {
00171     if (pt > 1.0)
00172       output += pt;
00173   }
00174   return output;
00175 }
00176 
00177 double IsolationChargedSumSoft(Tau tau) {
00178   VDouble isocands = extract(tau.isolationPFChargedHadrCands(),
00179                              std::mem_fun_ref(&PFCandidate::pt));
00180   double output = 0.0;
00181   BOOST_FOREACH(double pt, isocands) {
00182     if (pt < 1.0)
00183       output += pt;
00184   }
00185   return output;
00186 }
00187 
00188 // Relative versions.
00189 double IsolationChargedSumHardRelative(Tau tau) {
00190   return IsolationChargedSumHard(tau)/tau.jetRef()->pt();
00191 }
00192 
00193 double IsolationChargedSumSoftRelative(Tau tau) {
00194   return IsolationChargedSumSoft(tau)/tau.jetRef()->pt();
00195 }
00196 
00197 double IsolationECALSumHard(Tau tau) {
00198   VDouble isocands = extract(tau.isolationPFGammaCands(),
00199                              std::mem_fun_ref(&PFCandidate::pt));
00200   double output = 0.0;
00201   BOOST_FOREACH(double pt, isocands) {
00202     if (pt > 1.5)
00203       output += pt;
00204   }
00205   return output;
00206 }
00207 
00208 double IsolationECALSumSoft(Tau tau) {
00209   VDouble isocands = extract(tau.isolationPFGammaCands(),
00210                              std::mem_fun_ref(&PFCandidate::pt));
00211   double output = 0.0;
00212   BOOST_FOREACH(double pt, isocands) {
00213     if (pt < 1.5)
00214       output += pt;
00215   }
00216   return output;
00217 }
00218 
00219 // Relative versions.
00220 double IsolationECALSumHardRelative(Tau tau) {
00221   return IsolationECALSumHard(tau)/tau.jetRef()->pt();
00222 }
00223 double IsolationECALSumSoftRelative(Tau tau) {
00224   return IsolationECALSumSoft(tau)/tau.jetRef()->pt();
00225 }
00226 
00227 double EMFraction(Tau tau) {
00228   return tau.emFraction();
00229 }
00230 
00231 double ImpactParameterSignificance(Tau tau) {
00232   return std::abs(tau.leadPFChargedHadrCandsignedSipt());
00233 }
00234 
00235 double OutlierN(Tau tau) {
00236   return tau.isolationPFChargedHadrCands().size() +
00237       tau.isolationPFGammaCands().size();
00238 }
00239 
00240 double OutlierNCharged(Tau tau) {
00241   return tau.isolationPFChargedHadrCands().size();
00242 }
00243 
00244 double MainTrackPt(Tau tau) {
00245   PFCandidateRef trk = mainTrack(tau);
00246   return (!trk) ? 0.0 : trk->pt();
00247 }
00248 
00249 double MainTrackEta(Tau tau) {
00250   PFCandidateRef trk = mainTrack(tau);
00251   return (!trk) ? 0.0 : trk->eta();
00252 }
00253 
00254 double MainTrackAngle(Tau tau) {
00255   PFCandidateRef trk = mainTrack(tau);
00256   return (!trk) ? 0.0 : deltaR(trk->p4(), tau.p4());
00257 }
00258 
00259 double OutlierSumPt(Tau tau) {
00260   return tau.isolationPFChargedHadrCandsPtSum() +
00261       tau.isolationPFGammaCandsEtSum();
00262 }
00263 
00264 double ChargedOutlierSumPt(Tau tau) {
00265   return tau.isolationPFChargedHadrCandsPtSum();
00266 }
00267 
00268 double NeutralOutlierSumPt(Tau tau) {
00269   return tau.isolationPFGammaCandsEtSum();
00270 }
00271 
00272 // Quantities associated to tracks - that are not the main track
00273 VDouble TrackPt(Tau tau) {
00274   return extract(notMainTrack(tau), std::mem_fun_ref(&PFCandidate::pt));
00275 }
00276 
00277 VDouble TrackEta(Tau tau) {
00278   return extract(notMainTrack(tau), std::mem_fun_ref(&PFCandidate::eta));
00279 }
00280 
00281 VDouble TrackAngle(Tau tau) {
00282   return extract(notMainTrack(tau), DeltaRToAxis(tau.p4()));
00283 }
00284 
00285 // Quantities associated to PiZeros
00286 VDouble PiZeroPt(Tau tau) {
00287   return extract(tau.signalPiZeroCandidates(), std::mem_fun_ref(&RecoTauPiZero::pt));
00288 }
00289 
00290 VDouble PiZeroEta(Tau tau) {
00291   return extract(tau.signalPiZeroCandidates(), std::mem_fun_ref(&RecoTauPiZero::eta));
00292 }
00293 
00294 VDouble PiZeroAngle(Tau tau) {
00295   return extract(tau.signalPiZeroCandidates(), DeltaRToAxis(tau.p4()));
00296 }
00297 
00298 // Isolation quantities
00299 VDouble OutlierPt(Tau tau) {
00300   return extract(tau.isolationPFCands(), std::mem_fun_ref(&PFCandidate::pt));
00301 }
00302 
00303 VDouble OutlierAngle(Tau tau) {
00304   return extract(tau.isolationPFCands(), DeltaRToAxis(tau.p4()));
00305 }
00306 
00307 VDouble ChargedOutlierPt(Tau tau) {
00308   return extract(tau.isolationPFChargedHadrCands(),
00309                  std::mem_fun_ref(&PFCandidate::pt));
00310 }
00311 
00312 VDouble ChargedOutlierAngle(Tau tau) {
00313   return extract(tau.isolationPFChargedHadrCands(), DeltaRToAxis(tau.p4()));
00314 }
00315 
00316 VDouble NeutralOutlierPt(Tau tau) {
00317   return extract(tau.isolationPFGammaCands(),
00318                  std::mem_fun_ref(&PFCandidate::pt));
00319 }
00320 
00321 VDouble NeutralOutlierAngle(Tau tau) {
00322   return extract(tau.isolationPFGammaCands(), DeltaRToAxis(tau.p4()));
00323 }
00324 
00325 // Invariant mass of main track with other combinations
00326 VDouble Dalitz(Tau tau) {
00327   return Dalitz2(tau);
00328 }
00329 
00330 // The below functions are deprecated.
00331 // Not used, for backwards compatability
00332 VDouble FilteredObjectPt(Tau tau) { return VDouble(); }
00333 VDouble GammaOccupancy(Tau tau) { return VDouble(); }
00334 VDouble GammaPt(Tau tau) { return VDouble(); }
00335 VDouble InvariantMassOfSignalWithFiltered(Tau tau) { return VDouble(); }
00336 VDouble InvariantMass(Tau tau) { return VDouble(); }
00337 VDouble OutlierMass(Tau tau) { return VDouble(); }
00338 
00339 }}} // end reco::tau::disc namespace
00340