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
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
00023 template<typename Collection, typename Function>
00024 VDouble extract(const Collection& cands, Function func) {
00025
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 }
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
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
00125 if ( max < 0.05 )
00126 max = 0.05;
00127
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
00154 BOOST_FOREACH(PFCandidateRef trk, otherSignalTracks) {
00155 reco::Candidate::LorentzVector p4 = theMainTrack->p4() + trk->p4();
00156 output.push_back(p4.mass());
00157 }
00158
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
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
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
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
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
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
00326 VDouble Dalitz(Tau tau) {
00327 return Dalitz2(tau);
00328 }
00329
00330
00331
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 }}}
00340