CMS 3D CMS Logo
RecoTauPiZeroStripPlugin2.cc
Go to the documentation of this file.
1 /*
2  * RecoTauPiZeroStripPlugin2
3  *
4  * Merges PFGammas in a PFJet into Candidate piZeros defined as
5  * strips in eta-phi.
6  *
7  * Author: Michail Bachtis (University of Wisconsin)
8  *
9  * Code modifications: Evan Friis (UC Davis),
10  * Christian Veelken (LLR)
11  *
12  */
13 
14 #include <algorithm>
15 #include <memory>
16 
17 #include "boost/bind.hpp"
18 
19 #include "RecoTauTag/RecoTau/interface/RecoTauPiZeroPlugins.h"
20 
21 #include "DataFormats/Candidate/interface/CandidateFwd.h"
22 #include "DataFormats/Candidate/interface/Candidate.h"
23 #include "DataFormats/VertexReco/interface/Vertex.h"
24 #include "DataFormats/VertexReco/interface/VertexFwd.h"
25 #include "DataFormats/TauReco/interface/RecoTauPiZero.h"
26 #include "DataFormats/JetReco/interface/PFJet.h"
27 #include "CommonTools/CandUtils/interface/AddFourMomenta.h"
28 #include "DataFormats/Math/interface/deltaPhi.h"
29 
30 #include "RecoTauTag/RecoTau/interface/RecoTauCommonUtilities.h"
31 #include "RecoTauTag/RecoTau/interface/RecoTauQualityCuts.h"
32 #include "RecoTauTag/RecoTau/interface/RecoTauVertexAssociator.h"
33 #include "RecoTauTag/RecoTau/interface/CombinatoricGenerator.h"
34 
35 //-------------------------------------------------------------------------------
36 // CV: the following headers are needed only for debug print-out
37 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
38 #include "DataFormats/TrackReco/interface/Track.h"
39 //-------------------------------------------------------------------------------
40 
41 namespace reco {
42  namespace tau {
43 
44  namespace {
45  // Apply a hypothesis on the mass of the strips.
46  math::XYZTLorentzVector applyMassConstraint(const math::XYZTLorentzVector& vec, double mass) {
47  double factor = sqrt(vec.energy() * vec.energy() - mass * mass) / vec.P();
48  return math::XYZTLorentzVector(vec.px() * factor, vec.py() * factor, vec.pz() * factor, vec.energy());
49  }
50  } // namespace
51 
52  class RecoTauPiZeroStripPlugin2 : public RecoTauPiZeroBuilderPlugin {
53  public:
54  explicit RecoTauPiZeroStripPlugin2(const edm::ParameterSet&, edm::ConsumesCollector&& iC);
55  ~RecoTauPiZeroStripPlugin2() override;
56  // Return type is unique_ptr<PiZeroVector>
57  return_type operator()(const reco::Jet&) const override;
58  // Hook to update PV information
59  void beginEvent() override;
60 
61  private:
62  typedef std::vector<reco::CandidatePtr> CandPtrs;
63  void addCandsToStrip(RecoTauPiZero&, CandPtrs&, const std::vector<bool>&, std::set<size_t>&, bool&) const;
64 
65  RecoTauVertexAssociator vertexAssociator_;
66 
67  RecoTauQualityCuts* qcuts_;
68  bool applyElecTrackQcuts_;
69  double minGammaEtStripSeed_;
70  double minGammaEtStripAdd_;
71 
72  double minStripEt_;
73 
74  std::vector<int> inputParticleIds_; // type of candidates to clusterize
75  double etaAssociationDistance_; // size of strip clustering window in eta direction
76  double phiAssociationDistance_; // size of strip clustering window in phi direction
77 
78  bool updateStripAfterEachDaughter_;
79  int maxStripBuildIterations_;
80 
81  // Parameters for build strip combinations
82  bool combineStrips_;
83  int maxStrips_;
84  double combinatoricStripMassHypo_;
85 
86  AddFourMomenta p4Builder_;
87 
88  int verbosity_;
89  };
90 
91  RecoTauPiZeroStripPlugin2::RecoTauPiZeroStripPlugin2(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC)
92  : RecoTauPiZeroBuilderPlugin(pset, std::move(iC)),
93  vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"), std::move(iC)),
94  qcuts_(nullptr) {
95  minGammaEtStripSeed_ = pset.getParameter<double>("minGammaEtStripSeed");
96  minGammaEtStripAdd_ = pset.getParameter<double>("minGammaEtStripAdd");
97 
98  minStripEt_ = pset.getParameter<double>("minStripEt");
99 
100  edm::ParameterSet qcuts_pset = pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts");
101  //-------------------------------------------------------------------------------
102  // CV: disable track quality cuts for PFElectronsPFElectron
103  // (treat PFElectrons like PFGammas for the purpose of building eta-phi strips)
104  applyElecTrackQcuts_ = pset.getParameter<bool>("applyElecTrackQcuts");
105  if (!applyElecTrackQcuts_) {
106  qcuts_pset.addParameter<double>("minTrackPt", std::min(minGammaEtStripSeed_, minGammaEtStripAdd_));
107  qcuts_pset.addParameter<double>("maxTrackChi2", 1.e+9);
108  qcuts_pset.addParameter<double>("maxTransverseImpactParameter", 1.e+9);
109  qcuts_pset.addParameter<double>("maxDeltaZ", 1.e+9);
110  qcuts_pset.addParameter<double>("minTrackVertexWeight", -1.);
111  qcuts_pset.addParameter<unsigned>("minTrackPixelHits", 0);
112  qcuts_pset.addParameter<unsigned>("minTrackHits", 0);
113  }
114  //-------------------------------------------------------------------------------
115  qcuts_pset.addParameter<double>("minGammaEt", std::min(minGammaEtStripSeed_, minGammaEtStripAdd_));
116  qcuts_ = new RecoTauQualityCuts(qcuts_pset);
117 
118  inputParticleIds_ = pset.getParameter<std::vector<int> >("stripCandidatesParticleIds");
119  etaAssociationDistance_ = pset.getParameter<double>("stripEtaAssociationDistance");
120  phiAssociationDistance_ = pset.getParameter<double>("stripPhiAssociationDistance");
121 
122  updateStripAfterEachDaughter_ = pset.getParameter<bool>("updateStripAfterEachDaughter");
123  maxStripBuildIterations_ = pset.getParameter<int>("maxStripBuildIterations");
124 
125  combineStrips_ = pset.getParameter<bool>("makeCombinatoricStrips");
126  if (combineStrips_) {
127  maxStrips_ = pset.getParameter<int>("maxInputStrips");
128  combinatoricStripMassHypo_ = pset.getParameter<double>("stripMassWhenCombining");
129  }
130 
131  verbosity_ = pset.getParameter<int>("verbosity");
132  }
133 
134  RecoTauPiZeroStripPlugin2::~RecoTauPiZeroStripPlugin2() { delete qcuts_; }
135 
136  // Update the primary vertex
137  void RecoTauPiZeroStripPlugin2::beginEvent() { vertexAssociator_.setEvent(*evt()); }
138 
139  void RecoTauPiZeroStripPlugin2::addCandsToStrip(RecoTauPiZero& strip,
140  CandPtrs& cands,
141  const std::vector<bool>& candFlags,
142  std::set<size_t>& candIdsCurrentStrip,
143  bool& isCandAdded) const {
144  if (verbosity_ >= 1) {
145  edm::LogPrint("RecoTauPiZeroStripPlugin2") << "<RecoTauPiZeroStripPlugin2::addCandsToStrip>:";
146  }
147  size_t numCands = cands.size();
148  for (size_t candId = 0; candId < numCands; ++candId) {
149  if ((!candFlags[candId]) &&
150  candIdsCurrentStrip.find(candId) == candIdsCurrentStrip.end()) { // do not include same cand twice
151  reco::CandidatePtr cand = cands[candId];
152  if (fabs(strip.eta() - cand->eta()) <
153  etaAssociationDistance_ && // check if cand is within eta-phi window centered on strip
154  fabs(strip.phi() - cand->phi()) < phiAssociationDistance_) {
155  if (verbosity_ >= 2) {
156  edm::LogPrint("RecoTauPiZeroStripPlugin2")
157  << "--> adding PFCand #" << candId << " (" << cand.id() << ":" << cand.key()
158  << "): Et = " << cand->et() << ", eta = " << cand->eta() << ", phi = " << cand->phi();
159  }
160  strip.addDaughter(cand);
161  if (updateStripAfterEachDaughter_)
162  p4Builder_.set(strip);
163  isCandAdded = true;
164  candIdsCurrentStrip.insert(candId);
165  }
166  }
167  }
168  }
169 
170  namespace {
171  void markCandsInStrip(std::vector<bool>& candFlags, const std::set<size_t>& candIds) {
172  for (std::set<size_t>::const_iterator candId = candIds.begin(); candId != candIds.end(); ++candId) {
173  candFlags[*candId] = true;
174  }
175  }
176 
177  inline const reco::TrackBaseRef getTrack(const Candidate& cand) {
178  const PFCandidate* pfCandPtr = dynamic_cast<const PFCandidate*>(&cand);
179  if (pfCandPtr) {
180  if (pfCandPtr->trackRef().isNonnull())
181  return reco::TrackBaseRef(pfCandPtr->trackRef());
182  else if (pfCandPtr->gsfTrackRef().isNonnull())
183  return reco::TrackBaseRef(pfCandPtr->gsfTrackRef());
184  else
185  return reco::TrackBaseRef();
186  }
187 
188  return reco::TrackBaseRef();
189  }
190  } // namespace
191 
192  RecoTauPiZeroStripPlugin2::return_type RecoTauPiZeroStripPlugin2::operator()(const reco::Jet& jet) const {
193  if (verbosity_ >= 1) {
194  edm::LogPrint("RecoTauPiZeroStripPlugin2") << "<RecoTauPiZeroStripPlugin2::operator()>:";
195  edm::LogPrint("RecoTauPiZeroStripPlugin2") << " minGammaEtStripSeed = " << minGammaEtStripSeed_;
196  edm::LogPrint("RecoTauPiZeroStripPlugin2") << " minGammaEtStripAdd = " << minGammaEtStripAdd_;
197  edm::LogPrint("RecoTauPiZeroStripPlugin2") << " minStripEt = " << minStripEt_;
198  }
199 
200  PiZeroVector output;
201 
202  // Get the candidates passing our quality cuts
203  qcuts_->setPV(vertexAssociator_.associatedVertex(jet));
204  CandPtrs candsVector = qcuts_->filterCandRefs(pfCandidates(jet, inputParticleIds_));
205 
206  // Convert to stl::list to allow fast deletions
207  CandPtrs seedCands;
208  CandPtrs addCands;
209  int idx = 0;
210  for (CandPtrs::iterator cand = candsVector.begin(); cand != candsVector.end(); ++cand) {
211  if (verbosity_ >= 1) {
212  edm::LogPrint("RecoTauPiZeroStripPlugin2")
213  << "PFGamma #" << idx << " (" << cand->id() << ":" << cand->key() << "): Et = " << (*cand)->et()
214  << ", eta = " << (*cand)->eta() << ", phi = " << (*cand)->phi();
215  }
216  if ((*cand)->et() > minGammaEtStripSeed_) {
217  if (verbosity_ >= 2) {
218  edm::LogPrint("RecoTauPiZeroStripPlugin2") << "--> assigning seedCandId = " << seedCands.size();
219  const reco::TrackBaseRef candTrack = getTrack(**cand);
220  if (candTrack.isNonnull()) {
221  edm::LogPrint("RecoTauPiZeroStripPlugin2")
222  << "track: Pt = " << candTrack->pt() << " eta = " << candTrack->eta()
223  << ", phi = " << candTrack->phi() << ", charge = " << candTrack->charge();
224  edm::LogPrint("RecoTauPiZeroStripPlugin2")
225  << " (dZ = " << candTrack->dz(vertexAssociator_.associatedVertex(jet)->position())
226  << ", dXY = " << candTrack->dxy(vertexAssociator_.associatedVertex(jet)->position()) << ","
227  << " numHits = " << candTrack->hitPattern().numberOfValidTrackerHits()
228  << ", numPxlHits = " << candTrack->hitPattern().numberOfValidPixelHits() << ","
229  << " chi2 = " << candTrack->normalizedChi2()
230  << ", dPt/Pt = " << (candTrack->ptError() / candTrack->pt()) << ")";
231  }
232  }
233  seedCands.push_back(*cand);
234  } else if ((*cand)->et() > minGammaEtStripAdd_) {
235  if (verbosity_ >= 2) {
236  edm::LogPrint("RecoTauPiZeroStripPlugin2") << "--> assigning addCandId = " << addCands.size();
237  }
238  addCands.push_back(*cand);
239  }
240  ++idx;
241  }
242 
243  std::vector<bool> seedCandFlags(seedCands.size()); // true/false: seedCand is already/not yet included in strip
244  std::vector<bool> addCandFlags(addCands.size()); // true/false: addCand is already/not yet included in strip
245 
246  std::set<size_t> seedCandIdsCurrentStrip;
247  std::set<size_t> addCandIdsCurrentStrip;
248 
249  size_t idxSeed = 0;
250  while (idxSeed < seedCands.size()) {
251  if (verbosity_ >= 2)
252  edm::LogPrint("RecoTauPiZeroStripPlugin2") << "processing seed #" << idxSeed;
253 
254  seedCandIdsCurrentStrip.clear();
255  addCandIdsCurrentStrip.clear();
256 
257  std::unique_ptr<RecoTauPiZero> strip(new RecoTauPiZero(*seedCands[idxSeed], RecoTauPiZero::kStrips));
258  strip->addDaughter(seedCands[idxSeed]);
259  seedCandIdsCurrentStrip.insert(idxSeed);
260 
261  bool isCandAdded;
262  int stripBuildIteration = 0;
263  do {
264  isCandAdded = false;
265 
266  //if ( verbosity_ >= 2 ) edm::LogPrint("RecoTauPiZeroStripPlugin2") << " adding seedCands to strip..." ;
267  addCandsToStrip(*strip, seedCands, seedCandFlags, seedCandIdsCurrentStrip, isCandAdded);
268  //if ( verbosity_ >= 2 ) edm::LogPrint("RecoTauPiZeroStripPlugin2") << " adding addCands to strip..." ;
269  addCandsToStrip(*strip, addCands, addCandFlags, addCandIdsCurrentStrip, isCandAdded);
270 
271  if (!updateStripAfterEachDaughter_)
272  p4Builder_.set(*strip);
273 
274  ++stripBuildIteration;
275  } while (isCandAdded && (stripBuildIteration < maxStripBuildIterations_ || maxStripBuildIterations_ == -1));
276 
277  if (strip->et() > minStripEt_) { // strip passed Et cuts, add it to the event
278  if (verbosity_ >= 2)
279  edm::LogPrint("RecoTauPiZeroStripPlugin2")
280  << "Building strip: Et = " << strip->et() << ", eta = " << strip->eta() << ", phi = " << strip->phi();
281 
282  // Update the vertex
283  if (strip->daughterPtr(0).isNonnull())
284  strip->setVertex(strip->daughterPtr(0)->vertex());
285  output.push_back(std::move(strip));
286 
287  // Mark daughters as being part of this strip
288  markCandsInStrip(seedCandFlags, seedCandIdsCurrentStrip);
289  markCandsInStrip(addCandFlags, addCandIdsCurrentStrip);
290  } else { // strip failed Et cuts, just skip it
291  if (verbosity_ >= 2)
292  edm::LogPrint("RecoTauPiZeroStripPlugin2")
293  << "Discarding strip: Et = " << strip->et() << ", eta = " << strip->eta() << ", phi = " << strip->phi();
294  }
295 
296  ++idxSeed;
297  while (idxSeed < seedCands.size() && seedCandFlags[idxSeed]) {
298  ++idxSeed; // fast-forward to next seed cand not yet included in any strip
299  }
300  }
301 
302  // Check if we want to combine our strips
303  if (combineStrips_ && output.size() > 1) {
304  PiZeroVector stripCombinations;
305  // Sort the output by descending pt
306  output.sort(
307  output.begin(), output.end(), boost::bind(&RecoTauPiZero::pt, _1) > boost::bind(&RecoTauPiZero::pt, _2));
308  // Get the end of interesting set of strips to try and combine
309  PiZeroVector::const_iterator end_iter = takeNElements(output.begin(), output.end(), maxStrips_);
310 
311  // Look at all the combinations
312  for (PiZeroVector::const_iterator first = output.begin(); first != end_iter - 1; ++first) {
313  for (PiZeroVector::const_iterator second = first + 1; second != end_iter; ++second) {
314  Candidate::LorentzVector firstP4 = first->p4();
315  Candidate::LorentzVector secondP4 = second->p4();
316  // If we assume a certain mass for each strip apply it here.
317  firstP4 = applyMassConstraint(firstP4, combinatoricStripMassHypo_);
318  secondP4 = applyMassConstraint(secondP4, combinatoricStripMassHypo_);
319  Candidate::LorentzVector totalP4 = firstP4 + secondP4;
320  // Make our new combined strip
321  std::unique_ptr<RecoTauPiZero> combinedStrips(
322  new RecoTauPiZero(0,
323  totalP4,
324  Candidate::Point(0, 0, 0),
325  //111, 10001, true, RecoTauPiZero::kCombinatoricStrips));
326  111,
327  10001,
328  true,
329  RecoTauPiZero::kUndefined));
330 
331  // Now loop over the strip members
332  for (auto const& gamma : first->daughterPtrVector()) {
333  combinedStrips->addDaughter(gamma);
334  }
335  for (auto const& gamma : second->daughterPtrVector()) {
336  combinedStrips->addDaughter(gamma);
337  }
338  // Update the vertex
339  if (combinedStrips->daughterPtr(0).isNonnull())
340  combinedStrips->setVertex(combinedStrips->daughterPtr(0)->vertex());
341  // Add to our collection of combined strips
342  stripCombinations.push_back(std::move(combinedStrips));
343  }
344  }
345  // When done doing all the combinations, add the combined strips to the
346  // output.
347  output.transfer(output.end(), stripCombinations);
348  }
349 
350  return output.release();
351  }
352  } // namespace tau
353 } // namespace reco
354 
355 #include "FWCore/Framework/interface/MakerMacros.h"
356 DEFINE_EDM_PLUGIN(RecoTauPiZeroBuilderPluginFactory, reco::tau::RecoTauPiZeroStripPlugin2, "RecoTauPiZeroStripPlugin2");
reco::tau::RecoTauEventHolderPlugin::evt
const edm::Event * evt() const
Definition: RecoTauPluginsCommon.cc:16
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:702
reco::tau::RecoTauPiZeroStripPlugin2::beginEvent
void beginEvent() override
Hook called at the beginning of the event.
Definition: RecoTauPiZeroStripPlugin2.cc:137
configurableAnalysis::Candidate
char Candidate[]
Definition: modules.cc:20
reco::tau::RecoTauQualityCuts
Definition: RecoTauQualityCuts.h:34
metsig::tau
Definition: SignAlgoResolutions.h:49
reco::tau::RecoTauPiZeroStripPlugin2::maxStrips_
int maxStrips_
Definition: RecoTauPiZeroStripPlugin2.cc:83
reco::tau::RecoTauPiZeroStripPlugin2::vertexAssociator_
RecoTauVertexAssociator vertexAssociator_
Definition: RecoTauPiZeroStripPlugin2.cc:65
convertSQLitetoXML_cfg.output
output
Definition: convertSQLitetoXML_cfg.py:32
min
T min(T a, T b)
Definition: MathUtil.h:58
edm
HLT enums.
Definition: AlignableModifier.h:19
digitizers_cfi.strip
strip
Definition: digitizers_cfi.py:19
PFJet.h
CustomPhysics_cfi.gamma
gamma
Definition: CustomPhysics_cfi.py:17
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:215
reco::tau::RecoTauPiZeroStripPlugin2::verbosity_
int verbosity_
Definition: RecoTauPiZeroStripPlugin2.cc:88
reco::TrackBaseRef
edm::RefToBase< reco::Track > TrackBaseRef
persistent reference to a Track, using views
Definition: TrackFwd.h:35
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
RecoTauPiZeroPlugins.h
RecoTauPiZero.h
training_settings.idx
idx
Definition: training_settings.py:16
reco::tau::RecoTauPiZeroStripPlugin2::operator()
return_type operator()(const reco::Jet &) const override
Build a collection of piZeros from objects in the input jet.
Definition: RecoTauPiZeroStripPlugin2.cc:192
reco::tau::RecoTauPiZeroStripPlugin2
Definition: RecoTauPiZeroStripPlugin2.cc:52
dqmdumpme.first
first
Definition: dqmdumpme.py:55
RecoTauVertexAssociator.h
reco::tau::RecoTauPiZeroStripPlugin2::inputParticleIds_
std::vector< int > inputParticleIds_
Definition: RecoTauPiZeroStripPlugin2.cc:74
reco::tau::RecoTauPiZeroStripPlugin2::CandPtrs
std::vector< reco::CandidatePtr > CandPtrs
Definition: RecoTauPiZeroStripPlugin2.cc:62
CandidateFwd.h
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:608
reco::tau::RecoTauPiZeroStripPlugin2::p4Builder_
AddFourMomenta p4Builder_
Definition: RecoTauPiZeroStripPlugin2.cc:86
pfElectronTranslator_cfi.PFCandidate
PFCandidate
Definition: pfElectronTranslator_cfi.py:6
MakerMacros.h
reco::tau::RecoTauPiZeroStripPlugin2::combineStrips_
bool combineStrips_
Definition: RecoTauPiZeroStripPlugin2.cc:82
reco::RecoTauPiZero::kUndefined
Definition: RecoTauPiZero.h:11
reco::tau::RecoTauVertexAssociator
Definition: RecoTauVertexAssociator.h:50
Track.h
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
reco::tau::RecoTauPiZeroStripPlugin2::minGammaEtStripSeed_
double minGammaEtStripSeed_
Definition: RecoTauPiZeroStripPlugin2.cc:69
reco::tau::RecoTauQualityCuts::setPV
void setPV(const reco::VertexRef &vtx)
Update the primary vertex.
Definition: RecoTauQualityCuts.h:46
DQMScaleToClient_cfi.factor
factor
Definition: DQMScaleToClient_cfi.py:8
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:581
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:602
RecoTauCommonUtilities.h
DEFINE_EDM_PLUGIN
#define DEFINE_EDM_PLUGIN(factory, type, name)
Definition: PluginFactory.h:124
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:620
Vertex.h
reco::tau::RecoTauPiZeroBuilderPlugin::PiZeroVector
boost::ptr_vector< RecoTauPiZero > PiZeroVector
Definition: RecoTauPiZeroPlugins.h:36
RecoTauQualityCuts.h
CombinatoricGenerator.h
reco::tau::RecoTauQualityCuts::filterCandRefs
Coll filterCandRefs(const Coll &refcoll, bool invert=false) const
Filter a ref vector of Candidates.
Definition: RecoTauQualityCuts.h:85
reco::tau::RecoTauVertexAssociator::associatedVertex
reco::VertexRef associatedVertex(const Jet &jet) const
Definition: RecoTauVertexAssociator.cc:378
edm::ParameterSet
Definition: ParameterSet.h:36
reco::tau::RecoTauPiZeroStripPlugin2::applyElecTrackQcuts_
bool applyElecTrackQcuts_
Definition: RecoTauPiZeroStripPlugin2.cc:68
reco::tau::RecoTauPiZeroStripPlugin2::maxStripBuildIterations_
int maxStripBuildIterations_
Definition: RecoTauPiZeroStripPlugin2.cc:79
reco::tau::RecoTauPiZeroStripPlugin2::updateStripAfterEachDaughter_
bool updateStripAfterEachDaughter_
Definition: RecoTauPiZeroStripPlugin2.cc:78
ParameterSet
Definition: Functions.h:16
edmplugin::PluginFactory
Definition: PluginFactory.h:34
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:623
cand
Definition: decayParser.h:34
AddFourMomenta.h
GsfTrack.h
reco::tau::RecoTauPiZeroStripPlugin2::minGammaEtStripAdd_
double minGammaEtStripAdd_
Definition: RecoTauPiZeroStripPlugin2.cc:70
reco::tau::RecoTauPiZeroStripPlugin2::qcuts_
RecoTauQualityCuts * qcuts_
Definition: RecoTauPiZeroStripPlugin2.cc:67
edm::LogPrint
Definition: MessageLogger.h:342
reco::tau::RecoTauPiZeroStripPlugin2::addCandsToStrip
void addCandsToStrip(RecoTauPiZero &, CandPtrs &, const std::vector< bool > &, std::set< size_t > &, bool &) const
Definition: RecoTauPiZeroStripPlugin2.cc:139
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:578
reco::tau::RecoTauPiZeroStripPlugin2::phiAssociationDistance_
double phiAssociationDistance_
Definition: RecoTauPiZeroStripPlugin2.cc:76
reco::tau::RecoTauVertexAssociator::setEvent
void setEvent(const edm::Event &evt)
Load the vertices from the event.
Definition: RecoTauVertexAssociator.cc:242
edm::Ptr< Candidate >
VertexFwd.h
getTrack
static const TrackGhostTrackState * getTrack(const BasicGhostTrackState *basic)
Definition: GhostTrackState.cc:49
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:489
reco::tau::takeNElements
InputIterator takeNElements(const InputIterator &begin, const InputIterator &end, size_t N)
Definition: RecoTauCommonUtilities.h:104
reco::RecoTauPiZero
Definition: RecoTauPiZero.h:7
eostools.move
def move(src, dest)
Definition: eostools.py:511
std
Definition: JetResolutionObject.h:76
reco::tau::RecoTauPiZeroStripPlugin2::RecoTauPiZeroStripPlugin2
RecoTauPiZeroStripPlugin2(const edm::ParameterSet &, edm::ConsumesCollector &&iC)
Definition: RecoTauPiZeroStripPlugin2.cc:91
reco::HitPattern::numberOfValidTrackerHits
int numberOfValidTrackerHits() const
Definition: HitPattern.h:788
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
metsig::jet
Definition: SignAlgoResolutions.h:47
edm::RefToBase::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: RefToBase.h:301
reco::tau::RecoTauPiZeroBuilderPlugin
Definition: RecoTauPiZeroPlugins.h:33
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
AddFourMomenta::set
void set(reco::Candidate &c) const
set up a candidate
Definition: AddFourMomenta.cc:6
HLT_2018_cff.cands
cands
Definition: HLT_2018_cff.py:13762
edm::RefToBase< reco::Track >
reco::tau::RecoTauPiZeroStripPlugin2::etaAssociationDistance_
double etaAssociationDistance_
Definition: RecoTauPiZeroStripPlugin2.cc:75
reco::HitPattern::numberOfValidPixelHits
int numberOfValidPixelHits() const
Definition: HitPattern.h:800
AddFourMomenta
Definition: AddFourMomenta.h:18
Candidate.h
reco::tau::RecoTauPiZeroStripPlugin2::~RecoTauPiZeroStripPlugin2
~RecoTauPiZeroStripPlugin2() override
Definition: RecoTauPiZeroStripPlugin2.cc:134
reco::tau::pfCandidates
std::vector< CandidatePtr > pfCandidates(const Jet &jet, int particleId, bool sort=true)
Definition: RecoTauCommonUtilities.cc:59
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:36
reco::Candidate::Point
math::XYZPoint Point
point in the space
Definition: Candidate.h:40
reco::tau::RecoTauPiZeroStripPlugin2::combinatoricStripMassHypo_
double combinatoricStripMassHypo_
Definition: RecoTauPiZeroStripPlugin2.cc:84
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:593
edm::ConsumesCollector
Definition: ConsumesCollector.h:39
deltaPhi.h
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
reco::tau::RecoTauPiZeroStripPlugin2::minStripEt_
double minStripEt_
Definition: RecoTauPiZeroStripPlugin2.cc:72
reco::RecoTauPiZero::kStrips
Definition: RecoTauPiZero.h:14
reco::tau::RecoTauPiZeroBuilderPlugin::return_type
std::unique_ptr< PiZeroVector > return_type
Definition: RecoTauPiZeroPlugins.h:39
Generated for CMSSW Reference Manual by doxygen 1.8.16