Imperial Analysis
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ICPFCandidateProducer.hh
Go to the documentation of this file.
1 #ifndef UserCode_ICHiggsTauTau_ICPFCandidateProducer_h
2 #define UserCode_ICHiggsTauTau_ICPFCandidateProducer_h
3 
4 #include <memory>
5 #include <vector>
6 #include "boost/functional/hash.hpp"
7 #include "boost/format.hpp"
8 #include "FWCore/Framework/interface/EDProducer.h"
9 #include "FWCore/ParameterSet/interface/ParameterSet.h"
10 #include "FWCore/Framework/interface/Event.h"
11 #include "FWCore/Framework/interface/EventSetup.h"
12 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
13 #if CMSSW_MAJOR_VERSION >= 7
14 #include "DataFormats/PatCandidates/interface/PackedCandidate.h"
15 #endif
16 // #include "DataFormats/VertexReco/interface/Vertex.h"
18 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
19 #include "DataFormats/TrackReco/interface/Track.h"
20 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
21 #include "DataFormats/EgammaCandidates/interface/Conversion.h"
26 
30 template <class T>
31 class ICPFCandidateProducer : public edm::EDProducer {
32  public:
33  explicit ICPFCandidateProducer(const edm::ParameterSet &);
35 
36  private:
37  virtual void beginJob();
38  virtual void produce(edm::Event &, const edm::EventSetup &);
39  virtual void endJob();
40  void constructSpecific(edm::Handle<edm::View<T> > const& cands_handle,
41  reco::TrackRefVector* trk_requests,
42  reco::GsfTrackRefVector* gsf_trk_requests,
43  edm::Event& event, const edm::EventSetup& setup);
44 
45  std::vector<ic::PFCandidate> *cands_;
46  edm::InputTag input_;
47  std::string branch_;
48  bool request_trks_;
49  bool request_gsf_trks_;
50  boost::hash<T const*> cand_hasher_;
51  boost::hash<reco::Track const*> track_hasher_;
52  edm::InputTag track_input_;
53 };
54 
55 // =============================
56 // Template class implementation
57 // =============================
58 template <class T>
59 ICPFCandidateProducer<T>::ICPFCandidateProducer(const edm::ParameterSet& config)
60  : input_(config.getParameter<edm::InputTag>("input")),
61  branch_(config.getParameter<std::string>("branch")),
62  request_trks_(config.getParameter<bool>("requestTracks")),
63  request_gsf_trks_(config.getParameter<bool>("requestGsfTracks")),
64  track_input_(config.getParameter<edm::InputTag>("inputUnpackedTracks")) {
65  consumes<edm::View<T>>(input_);
66  consumes<edm::View<reco::Track>>(track_input_);
67  cands_ = new std::vector<ic::PFCandidate>();
68 
69  if (request_trks_) {
70  produces<reco::TrackRefVector>("requestedTracks");
71  }
72 
73  if (request_gsf_trks_) {
74  produces<reco::GsfTrackRefVector>("requestedGsfTracks");
75  }
76 
77  PrintHeaderWithProduces(config, input_, branch_);
78  // PrintOptional(1, do_vertex_ip_, "includeVertexIP");
79  PrintOptional(1, request_trks_, "requestTracks");
80  PrintOptional(1, request_trks_, "requestGsfTracks");
81 }
82 
83 template <class T>
85 
86 // =============
87 // Main producer
88 // =============
89 template <class T>
90 void ICPFCandidateProducer<T>::produce(edm::Event& event,
91  const edm::EventSetup& setup) {
92  edm::Handle<edm::View<T> > cands_handle;
93  event.getByLabel(input_, cands_handle);
94 
95  // edm::Handle<edm::View<reco::Vertex> > vertices_handle;
96  // if (do_vertex_ip_) event.getByLabel(input_vertices_, vertices_handle);
97 
98  std::auto_ptr<reco::TrackRefVector> trk_requests(new reco::TrackRefVector());
99  std::auto_ptr<reco::GsfTrackRefVector> gsf_trk_requests(new reco::GsfTrackRefVector());
100 
101  cands_->clear();
102  cands_->resize(cands_handle->size(), ic::PFCandidate());
103  for (unsigned i = 0; i < cands_handle->size(); ++i) {
104  T const& src = cands_handle->at(i);
105  ic::PFCandidate& dest = cands_->at(i);
106 
107  dest.set_id(cand_hasher_(&src));
108  dest.set_pt(src.pt());
109  dest.set_eta(src.eta());
110  dest.set_phi(src.phi());
111  dest.set_energy(src.energy());
112  dest.set_charge(src.charge());
113  dest.set_pdgid(src.pdgId());
114 
115  // dest.set_vx(src.vx());
116  // dest.set_vy(src.vy());
117  // dest.set_vz(src.vz());
118  }
119  constructSpecific(cands_handle, trk_requests.get(), gsf_trk_requests.get(),
120  event, setup);
121  if (request_trks_) event.put(trk_requests, "requestedTracks");
122  if (request_gsf_trks_) event.put(gsf_trk_requests, "requestedGsfTracks");
123 }
124 
125 // ==================
126 // Specific producers
127 // ==================
128 template <class T>
130  edm::Handle<edm::View<T> > const& cands_handle,
131  reco::TrackRefVector* trk_requests,
132  reco::GsfTrackRefVector* gsf_trk_requests, edm::Event& event,
133  const edm::EventSetup& setup) {}
134 
135 template <>
137  edm::Handle<edm::View<reco::PFCandidate> > const& cands_handle,
138  reco::TrackRefVector* trk_requests,
139  reco::GsfTrackRefVector* gsf_trk_requests, edm::Event& event,
140  const edm::EventSetup& setup) {
141  for (unsigned i = 0; i < cands_handle->size(); ++i) {
142  reco::PFCandidate const& src = cands_handle->at(i);
143  ic::PFCandidate& dest = cands_->at(i);
144  unsigned flag_val = 0;
145  for (int i = ic::PFFlag::NORMAL; i <= ic::PFFlag::GAMMA_TO_GAMMACONV; ++i) {
146  if (src.flag(reco::PFCandidate::Flags(i))) flag_val = flag_val | (1 << i);
147  }
148  dest.set_flags(flag_val);
149 
150  std::vector<std::size_t> trk_ids;
151  if (request_trks_) {
152  if (src.trackRef().isNonnull()) {
153  reco::TrackRef const& trk = src.trackRef();
154  trk_requests->push_back(trk);
155  trk_ids.push_back(track_hasher_(&(*trk)));
156  }
157  dest.set_constituent_tracks(trk_ids);
158  }
159 
160  if (request_gsf_trks_) {
161  std::vector<std::size_t> gsf_trk_ids;
162  if (src.gsfTrackRef().isNonnull()) {
163  reco::GsfTrackRef const& trk = src.gsfTrackRef();
164  gsf_trk_requests->push_back(trk);
165  gsf_trk_ids.push_back(track_hasher_(&(*trk)));
166  }
167  dest.set_constituent_gsf_tracks(gsf_trk_ids);
168  }
169  }
170 }
171 
172 #if CMSSW_MAJOR_VERSION >= 7
173 template <>
175  edm::Handle<edm::View<pat::PackedCandidate> > const& cands_handle,
176  reco::TrackRefVector* trk_requests,
177  reco::GsfTrackRefVector* /*gsf_trk_requests*/, edm::Event& event,
178  const edm::EventSetup& setup) {
179  // To get tracks here we'd actually have to produce a new track collection
180  // first using pseudoTrack(), get it into the event, then produce the refs.
181  // Not trivial I think.
182 
183  edm::Handle<edm::View<reco::Track> > tracks_handle;
184  typedef std::set<reco::Track const*> TrackSet;
185  typedef std::map<reco::Track const*, unsigned> TrackMap;
186  TrackSet trk_set;
187  TrackMap trk_map;
188 
189  if(request_trks_){
190  event.getByLabel(track_input_, tracks_handle);
191  for (unsigned i = 0; i < tracks_handle->size(); ++i) {
192  trk_set.insert(&(tracks_handle->at(i)));
193  trk_map[&(tracks_handle->at(i))] = i;
194  }
195  }
196 
197  for (unsigned i = 0; i < cands_handle->size(); ++i) {
198  pat::PackedCandidate const& src = cands_handle->at(i);
199  ic::PFCandidate& dest = cands_->at(i);
200  // PackedCandidates don't store the same set of flags as PFCandidates, but
201  // they do store their own set of flags that we can get via the status()
202  // method, so let's just save this here. For details see:
203  // twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD
204  dest.set_flags(src.status());
205  std::vector<std::size_t> trk_ids;
206  if (request_trks_ && src.charge() != 0) {
207  reco::Track pseudo = src.pseudoTrack();
208  for (TrackSet::iterator it = trk_set.begin(); it != trk_set.end(); ++it) {
209  // Ok, comparing floats normally not a good idea, but here they really
210  // should be identical
211  if (pseudo.momentum().x() != (*it)->momentum().x() ||
212  pseudo.momentum().y() != (*it)->momentum().y() ||
213  pseudo.momentum().z() != (*it)->momentum().z()) continue;
214  trk_set.erase(it);
215  trk_requests->push_back(tracks_handle->refAt(trk_map.at(*it))
216  .template castTo<reco::TrackRef>());
217  trk_ids.push_back(track_hasher_(*it));
218  break;
219  }
220  // PhysicsTools/PatAlgos/plugins/TrackAndVertexUnpacker.cc doesn't create
221  // a Track for every charged PackedCandidate, just those that meet the
222  // conditions below.
223 
224  // UNCOMMENT TO CHECK IF WE'RE MISSING ANY TRACKS THAT SHOULD BE THERE
225  // if (src.charge() != 0 && src.numberOfHits() > 0 && trk_ids.size() == 0) {
226  // std::cout << "Have an unmatched track!\n";
227  // }
228  dest.set_constituent_tracks(trk_ids);
229  }
230 
231  // NB: can't do anything for gsf_trk_requests!
232  }
233 }
234 #endif
235 
236 template <class T>
238  ic::StaticTree::tree_->Branch(branch_.c_str(), &cands_);
239 }
240 
241 template <class T>
243 }
244 
245 #endif
void set_constituent_gsf_tracks(std::vector< std::size_t > const &constituent_gsf_tracks)
Definition: PFCandidate.hh:110
void set_phi(double const &phi)
Direct access to .
Definition: Candidate.hh:75
void set_id(std::size_t const &id)
Unique identifier.
Definition: Candidate.hh:66
Stores the basic properties of PFCandidates (and PackedCandidates for CMSSW 7_X_Y) ...
Definition: PFCandidate.hh:37
ICPFCandidateProducer(const edm::ParameterSet &)
void set_charge(int const &charge)
Electric charge.
Definition: Candidate.hh:81
static TTree * tree_
Definition: StaticTree.hh:13
void set_constituent_tracks(std::vector< std::size_t > const &constituent_tracks)
A vector to refer to the constituent track ic::Track::id() values.
Definition: PFCandidate.hh:105
See documentation here.
void set_pdgid(int const &pdgid)
PDG number to identify the PF candidate type.
Definition: PFCandidate.hh:99
void set_energy(double const &energy)
Direct access to the energy.
Definition: Candidate.hh:78
void set_flags(unsigned const &flags)
PF flags.
Definition: PFCandidate.hh:102
void PrintOptional(unsigned depth, bool value, std::string text)
Definition: Consumes.h:19
void set_pt(double const &pt)
Direct access to the .
Definition: Candidate.hh:69
void set_eta(double const &eta)
Direct access to .
Definition: Candidate.hh:72
void PrintHeaderWithProduces(edm::ParameterSet const &config, edm::InputTag const &in, std::string branch)