CMS 3D CMS Logo

ConversionTrackCandidateProducer.cc
Go to the documentation of this file.
1 
46 
47 #include <vector>
48 
50 public:
52 
53  void beginRun(edm::Run const&, edm::EventSetup const& es) final;
54  void produce(edm::Event& evt, const edm::EventSetup& es) override;
55 
56  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
57 
58 private:
60  void setEventSetup(const edm::EventSetup& es);
61 
64 
67 
76 
80 
82  double maxHOverE_;
83  double minSCEt_;
84  double isoConeR_;
86  double isoEtaSlice_;
87  double isoEtMin_;
88  double isoEMin_;
91 
92  std::vector<int> flagsexclEB_;
93  std::vector<int> flagsexclEE_;
94  std::vector<int> severitiesexclEB_;
95  std::vector<int> severitiesexclEE_;
96 
99 
101 
102  std::unique_ptr<BaseCkfTrajectoryBuilder> theTrajectoryBuilder_;
103 
108 
109  std::vector<edm::Ptr<reco::CaloCluster>> caloPtrVecOutIn_;
110  std::vector<edm::Ptr<reco::CaloCluster>> caloPtrVecInOut_;
111 
112  std::vector<edm::Ref<reco::SuperClusterCollection>> vecOfSCRefForOutIn;
113  std::vector<edm::Ref<reco::SuperClusterCollection>> vecOfSCRefForInOut;
114 
115  std::unique_ptr<ElectronHcalHelper> hcalHelper_;
116 
119  HcalPFCuts const* hcalCuts = nullptr;
120 
121  void buildCollections(bool detector,
122  const edm::Handle<edm::View<reco::CaloCluster>>& scHandle,
123  const edm::Handle<edm::View<reco::CaloCluster>>& bcHandle,
124  const EcalRecHitCollection& ecalRecHits,
125  const EcalSeverityLevelAlgo* sevLev,
126  ElectronHcalHelper const& hcalHelper,
127  TrackCandidateCollection& outInTracks,
128  TrackCandidateCollection& inOutTracks,
131 };
132 
135 
136 namespace {
137  auto createBaseCkfTrajectoryBuilder(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC) {
138  return BaseCkfTrajectoryBuilderFactory::get()->create(pset.getParameter<std::string>("ComponentType"), pset, iC);
139  }
140 } // namespace
141 
143  : bcBarrelCollection_{consumes(config.getParameter<edm::InputTag>("bcBarrelCollection"))},
144  bcEndcapCollection_{consumes(config.getParameter<edm::InputTag>("bcEndcapCollection"))},
145  scHybridBarrelProducer_{consumes(config.getParameter<edm::InputTag>("scHybridBarrelProducer"))},
146  scIslandEndcapProducer_{consumes(config.getParameter<edm::InputTag>("scIslandEndcapProducer"))},
147 
148  hbheRecHits_{consumes(config.getParameter<edm::InputTag>("hbheRecHits"))},
149  barrelecalCollection_{consumes(config.getParameter<edm::InputTag>("barrelEcalRecHitCollection"))},
150  endcapecalCollection_{consumes(config.getParameter<edm::InputTag>("endcapEcalRecHitCollection"))},
151  measurementTrkEvtToken_{consumes(edm::InputTag("MeasurementTrackerEvent"))},
152 
153  navToken_(esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("", "SimpleNavigationSchool"))),
154  theCaloGeomToken_(esConsumes()),
155  sevlvToken_(esConsumes()),
156 
157  theTrajectoryBuilder_(createBaseCkfTrajectoryBuilder(
158  config.getParameter<edm::ParameterSet>("TrajectoryBuilderPSet"), consumesCollector())),
159  outInSeedFinder_{config, consumesCollector()},
160  outInTrackFinder_{config, theTrajectoryBuilder_.get(), consumesCollector()},
161  inOutSeedFinder_{config, consumesCollector()},
162  inOutTrackFinder_{config, theTrajectoryBuilder_.get(), consumesCollector()} {
163  OutInTrackCandidateCollection_ = config.getParameter<std::string>("outInTrackCandidateCollection");
164  InOutTrackCandidateCollection_ = config.getParameter<std::string>("inOutTrackCandidateCollection");
165 
166  OutInTrackSCAssociationCollection_ = config.getParameter<std::string>("outInTrackCandidateSCAssociationCollection");
167  InOutTrackSCAssociationCollection_ = config.getParameter<std::string>("inOutTrackCandidateSCAssociationCollection");
168 
169  cutsFromDB = config.getParameter<bool>("usePFThresholdsFromDB");
170  if (cutsFromDB) {
171  hcalCutsToken_ = esConsumes<HcalPFCuts, HcalPFCutsRcd, edm::Transition::BeginRun>(edm::ESInputTag("", "withTopo"));
172  }
173  hOverEConeSize_ = config.getParameter<double>("hOverEConeSize");
174  maxHOverE_ = config.getParameter<double>("maxHOverE");
175  minSCEt_ = config.getParameter<double>("minSCEt");
176  isoConeR_ = config.getParameter<double>("isoConeR");
177  isoInnerConeR_ = config.getParameter<double>("isoInnerConeR");
178  isoEtaSlice_ = config.getParameter<double>("isoEtaSlice");
179  isoEtMin_ = config.getParameter<double>("isoEtMin");
180  isoEMin_ = config.getParameter<double>("isoEMin");
181  vetoClusteredHits_ = config.getParameter<bool>("vetoClusteredHits");
182  useNumXtals_ = config.getParameter<bool>("useNumXstals");
183  ecalIsoCut_offset_ = config.getParameter<double>("ecalIsoCut_offset");
184  ecalIsoCut_slope_ = config.getParameter<double>("ecalIsoCut_slope");
185 
186  //Flags and Severities to be excluded from photon calculations
187  auto const& flagnamesEB = config.getParameter<std::vector<std::string>>("RecHitFlagToBeExcludedEB");
188  auto const& flagnamesEE = config.getParameter<std::vector<std::string>>("RecHitFlagToBeExcludedEE");
189 
190  flagsexclEB_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
191  flagsexclEE_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
192 
193  auto const& severitynamesEB = config.getParameter<std::vector<std::string>>("RecHitSeverityToBeExcludedEB");
194  auto const& severitynamesEE = config.getParameter<std::vector<std::string>>("RecHitSeverityToBeExcludedEE");
195 
196  severitiesexclEB_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEB);
197  severitiesexclEE_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEE);
198 
199  // Register the product
200  produces<TrackCandidateCollection>(OutInTrackCandidateCollection_);
201  produces<TrackCandidateCollection>(InOutTrackCandidateCollection_);
202 
203  produces<reco::TrackCandidateCaloClusterPtrAssociation>(OutInTrackSCAssociationCollection_);
204  produces<reco::TrackCandidateCaloClusterPtrAssociation>(InOutTrackSCAssociationCollection_);
205 
207  cfgCone.hOverEConeSize = hOverEConeSize_;
208  if (cfgCone.hOverEConeSize > 0) {
209  cfgCone.onlyBehindCluster = false;
210  cfgCone.checkHcalStatus = false;
211 
212  cfgCone.hbheRecHits = hbheRecHits_;
213 
214  cfgCone.eThresHB = config.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
215  cfgCone.maxSeverityHB = config.getParameter<int>("maxHcalRecHitSeverity");
216  cfgCone.eThresHE = config.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
217  cfgCone.maxSeverityHE = cfgCone.maxSeverityHB;
218  }
219 
220  hcalHelper_ = std::make_unique<ElectronHcalHelper>(cfgCone, consumesCollector());
221 }
222 
224  outInSeedFinder_.setEventSetup(theEventSetup);
225  inOutSeedFinder_.setEventSetup(theEventSetup);
226  outInTrackFinder_.setEventSetup(theEventSetup);
227  inOutTrackFinder_.setEventSetup(theEventSetup);
228 }
229 
231  const NavigationSchool* navigation = &theEventSetup.getData(navToken_);
232  theTrajectoryBuilder_->setNavigationSchool(navigation);
235 
236  if (cutsFromDB) {
237  hcalCuts = &theEventSetup.getData(hcalCutsToken_);
238  }
239 }
240 
242  // get the trajectory builder and initialize it with the data
243  theTrajectoryBuilder_->setEvent(theEvent, theEventSetup, &theEvent.get(measurementTrkEvtToken_));
244 
245  // this need to be done after the initialization of the TrajectoryBuilder!
246  setEventSetup(theEventSetup);
247 
248  outInSeedFinder_.setEvent(theEvent);
249  inOutSeedFinder_.setEvent(theEvent);
250 
251  //
252  // create empty output collections
253  //
254  // Out In Track Candidates
255  auto outInTrackCandidate_p = std::make_unique<TrackCandidateCollection>();
256  // In Out Track Candidates
257  auto inOutTrackCandidate_p = std::make_unique<TrackCandidateCollection>();
258  // Track Candidate calo Cluster Association
259  auto outInAssoc_p = std::make_unique<reco::TrackCandidateCaloClusterPtrAssociation>();
260  auto inOutAssoc_p = std::make_unique<reco::TrackCandidateCaloClusterPtrAssociation>();
261 
262  // Get the basic cluster collection in the Barrel
263  bool validBarrelBCHandle = true;
264  auto bcBarrelHandle = theEvent.getHandle(bcBarrelCollection_);
265  if (!bcBarrelHandle.isValid()) {
266  edm::LogError("ConversionTrackCandidateProducer") << "Error! Can't get the Barrel Basic Clusters!";
267  validBarrelBCHandle = false;
268  }
269 
270  // Get the basic cluster collection in the Endcap
271  bool validEndcapBCHandle = true;
272  auto bcEndcapHandle = theEvent.getHandle(bcEndcapCollection_);
273  if (!bcEndcapHandle.isValid()) {
274  edm::LogError("CoonversionTrackCandidateProducer") << "Error! Can't get the Endcap Basic Clusters";
275  validEndcapBCHandle = false;
276  }
277 
278  // Get the Super Cluster collection in the Barrel
279  bool validBarrelSCHandle = true;
280  auto scBarrelHandle = theEvent.getHandle(scHybridBarrelProducer_);
281  if (!scBarrelHandle.isValid()) {
282  edm::LogError("CoonversionTrackCandidateProducer") << "Error! Can't get the barrel superclusters!";
283  validBarrelSCHandle = false;
284  }
285 
286  // Get the Super Cluster collection in the Endcap
287  bool validEndcapSCHandle = true;
288  auto scEndcapHandle = theEvent.getHandle(scIslandEndcapProducer_);
289  if (!scEndcapHandle.isValid()) {
290  edm::LogError("CoonversionTrackCandidateProducer") << "Error! Can't get the endcap superclusters!";
291  validEndcapSCHandle = false;
292  }
293 
294  // get the geometry from the event setup:
295  theCaloGeom_ = theEventSetup.getHandle(theCaloGeomToken_);
296 
297  hcalHelper_->beginEvent(theEvent, theEventSetup);
298 
299  auto const& ecalhitsCollEB = theEvent.get(barrelecalCollection_);
300  auto const& ecalhitsCollEE = theEvent.get(endcapecalCollection_);
301 
302  const EcalSeverityLevelAlgo* sevLevel = &theEventSetup.getData(sevlvToken_);
303 
304  caloPtrVecOutIn_.clear();
305  caloPtrVecInOut_.clear();
306 
307  bool isBarrel = true;
308  if (validBarrelBCHandle && validBarrelSCHandle)
310  scBarrelHandle,
311  bcBarrelHandle,
312  ecalhitsCollEB,
313  sevLevel,
314  *hcalHelper_,
315  *outInTrackCandidate_p,
316  *inOutTrackCandidate_p,
319 
320  if (validEndcapBCHandle && validEndcapSCHandle) {
321  isBarrel = false;
323  scEndcapHandle,
324  bcEndcapHandle,
325  ecalhitsCollEE,
326  sevLevel,
327  *hcalHelper_,
328  *outInTrackCandidate_p,
329  *inOutTrackCandidate_p,
332  }
333 
334  // std::cout << " ConversionTrackCandidateProducer caloPtrVecOutIn_ size " << caloPtrVecOutIn_.size() << " caloPtrVecInOut_ size " << caloPtrVecInOut_.size() << "\n";
335 
336  // put all products in the event
337  // Barrel
338  //std::cout << "ConversionTrackCandidateProducer Putting in the event " << (*outInTrackCandidate_p).size() << " Out In track Candidates " << "\n";
339  auto const refprodOutInTrackC = theEvent.put(std::move(outInTrackCandidate_p), OutInTrackCandidateCollection_);
340  //std::cout << "ConversionTrackCandidateProducer refprodOutInTrackC size " << (*(refprodOutInTrackC.product())).size() << "\n";
341  //
342  //std::cout << "ConversionTrackCandidateProducer Putting in the event " << (*inOutTrackCandidate_p).size() << " In Out track Candidates " << "\n";
343  auto const refprodInOutTrackC = theEvent.put(std::move(inOutTrackCandidate_p), InOutTrackCandidateCollection_);
344  //std::cout << "ConversionTrackCandidateProducer refprodInOutTrackC size " << (*(refprodInOutTrackC.product())).size() << "\n";
345 
346  edm::ValueMap<reco::CaloClusterPtr>::Filler fillerOI(*outInAssoc_p);
347  fillerOI.insert(refprodOutInTrackC, caloPtrVecOutIn_.begin(), caloPtrVecOutIn_.end());
348  fillerOI.fill();
349  edm::ValueMap<reco::CaloClusterPtr>::Filler fillerIO(*inOutAssoc_p);
350  fillerIO.insert(refprodInOutTrackC, caloPtrVecInOut_.begin(), caloPtrVecInOut_.end());
351  fillerIO.fill();
352 
353  // std::cout << "ConversionTrackCandidateProducer Putting in the event OutIn track - SC association: size " << (*outInAssoc_p).size() << "\n";
354  theEvent.put(std::move(outInAssoc_p), OutInTrackSCAssociationCollection_);
355 
356  // std::cout << "ConversionTrackCandidateProducer Putting in the event InOut track - SC association: size " << (*inOutAssoc_p).size() << "\n";
357  theEvent.put(std::move(inOutAssoc_p), InOutTrackSCAssociationCollection_);
358 
361 }
362 
364  const edm::Handle<edm::View<reco::CaloCluster>>& scHandle,
365  const edm::Handle<edm::View<reco::CaloCluster>>& bcHandle,
366  EcalRecHitCollection const& ecalRecHits,
367  const EcalSeverityLevelAlgo* sevLevel,
368  ElectronHcalHelper const& hcalHelper,
369  TrackCandidateCollection& outInTrackCandidates,
370  TrackCandidateCollection& inOutTrackCandidates,
373 
374 {
375  // Loop over SC in the barrel and reconstruct converted photons
376  for (auto const& aClus : scHandle->ptrs()) {
377  // preselection based in Et and H/E cut.
378  if (aClus->energy() / cosh(aClus->eta()) <= minSCEt_)
379  continue;
380  if (aClus->eta() > 1.479 && aClus->eta() < 1.556)
381  continue;
382 
383  const reco::CaloCluster* pClus = &(*aClus);
384  const reco::SuperCluster* sc = dynamic_cast<const reco::SuperCluster*>(pClus);
385  double scEt = sc->energy() / cosh(sc->eta());
386  double HoE = hcalHelper.hcalESum(*sc, 0, hcalCuts) / sc->energy();
387  if (HoE >= maxHOverE_)
388  continue;
389 
393 
394  ecalIso.setVetoClustered(vetoClusteredHits_);
395  ecalIso.setUseNumCrystals(useNumXtals_);
396  if (isBarrel) {
397  ecalIso.doFlagChecks(flagsexclEB_);
398  ecalIso.doSeverityChecks(&ecalRecHits, severitiesexclEB_);
399  } else {
400  ecalIso.doFlagChecks(flagsexclEE_);
401  ecalIso.doSeverityChecks(&ecalRecHits, severitiesexclEE_);
402  }
403 
404  double ecalIsolation = ecalIso.getEtSum(sc);
406  continue;
407 
408  // Now launch the seed finding
410  GlobalPoint(pClus->position().x(), pClus->position().y(), pClus->position().z()));
411  outInSeedFinder_.makeSeeds(bcHandle);
412 
413  std::vector<Trajectory> theOutInTracks = outInTrackFinder_.tracks(outInSeedFinder_.seeds(), outInTrackCandidates);
414 
416  GlobalPoint(pClus->position().x(), pClus->position().y(), pClus->position().z()));
417  inOutSeedFinder_.setTracks(theOutInTracks);
418  inOutSeedFinder_.makeSeeds(bcHandle);
419 
420  std::vector<Trajectory> theInOutTracks = inOutTrackFinder_.tracks(inOutSeedFinder_.seeds(), inOutTrackCandidates);
421 
422  // Debug
423  // std::cout << "ConversionTrackCandidateProducer theOutInTracks.size() " << theOutInTracks.size() << " theInOutTracks.size() " << theInOutTracks.size() << " Event pointer to out in track size barrel " << outInTrackCandidates.size() << " in out track size " << inOutTrackCandidates.size() << "\n";
424 
426  for (auto it = theOutInTracks.begin(); it != theOutInTracks.end(); ++it) {
427  vecRecOI.push_back(aClus);
428  // std::cout << "ConversionTrackCandidateProducer Barrel OutIn Tracks Number of hits " << (*it).foundHits() << "\n";
429  }
430 
431  for (auto it = theInOutTracks.begin(); it != theInOutTracks.end(); ++it) {
432  vecRecIO.push_back(aClus);
433  // std::cout << "ConversionTrackCandidateProducer Barrel InOut Tracks Number of hits " << (*it).foundHits() << "\n";
434  }
435  }
436 }
437 
439  // conversionTrackCandidates
441 
442  desc.add<edm::InputTag>("bcBarrelCollection", {"particleFlowSuperClusterECAL", "particleFlowBasicClusterECALBarrel"});
443  desc.add<edm::InputTag>("bcEndcapCollection", {"particleFlowSuperClusterECAL", "particleFlowBasicClusterECALEndcap"});
444  desc.add<edm::InputTag>("scHybridBarrelProducer",
445  {"particleFlowSuperClusterECAL", "particleFlowSuperClusterECALBarrel"});
446  desc.add<edm::InputTag>("scIslandEndcapProducer",
447  {"particleFlowSuperClusterECAL", "particleFlowSuperClusterECALEndcapWithPreshower"});
448 
449  desc.add<std::string>("outInTrackCandidateSCAssociationCollection", "outInTrackCandidateSCAssociationCollection");
450  desc.add<std::string>("inOutTrackCandidateSCAssociationCollection", "inOutTrackCandidateSCAssociationCollection");
451  desc.add<std::string>("outInTrackCandidateCollection", "outInTracksFromConversions");
452  desc.add<std::string>("inOutTrackCandidateCollection", "inOutTracksFromConversions");
453 
454  desc.add<edm::InputTag>("barrelEcalRecHitCollection", {"ecalRecHit", "EcalRecHitsEB"});
455  desc.add<edm::InputTag>("endcapEcalRecHitCollection", {"ecalRecHit", "EcalRecHitsEE"});
456  desc.add<std::string>("MeasurementTrackerName", "");
457  desc.add<std::string>("OutInRedundantSeedCleaner", "CachingSeedCleanerBySharedInput");
458  desc.add<std::string>("InOutRedundantSeedCleaner", "CachingSeedCleanerBySharedInput");
459  desc.add<bool>("useHitsSplitting", false);
460  desc.add<int>("maxNumOfSeedsOutIn", 50);
461  desc.add<int>("maxNumOfSeedsInOut", 50);
462  desc.add<double>("bcEtCut", 1.5);
463  desc.add<double>("bcECut", 1.5);
464  desc.add<bool>("useEtCut", true);
465 
466  desc.add<edm::InputTag>("hbheRecHits", {"hbhereco"});
467  desc.add<std::vector<double>>("recHitEThresholdHB", {0., 0., 0., 0.});
468  desc.add<std::vector<double>>("recHitEThresholdHE", {0., 0., 0., 0., 0., 0., 0.});
469  desc.add<bool>("usePFThresholdsFromDB", false);
470  desc.add<int>("maxHcalRecHitSeverity", 999999);
471 
472  desc.add<double>("minSCEt", 20.0);
473  desc.add<double>("hOverEConeSize", 0.15);
474  desc.add<double>("maxHOverE", 0.15);
475  desc.add<double>("isoInnerConeR", 3.5);
476  desc.add<double>("isoConeR", 0.4);
477  desc.add<double>("isoEtaSlice", 2.5);
478  desc.add<double>("isoEtMin", 0.0);
479  desc.add<double>("isoEMin", 0.08);
480  desc.add<bool>("vetoClusteredHits", false);
481  desc.add<bool>("useNumXstals", true);
482  desc.add<double>("ecalIsoCut_offset", 999999999); // alternative value: 4.2
483  desc.add<double>("ecalIsoCut_slope", 0.0); // alternative value: 0.003
484 
485  desc.add<std::vector<std::string>>("RecHitFlagToBeExcludedEB", {});
486  desc.add<std::vector<std::string>>("RecHitSeverityToBeExcludedEB", {});
487  desc.add<std::vector<std::string>>("RecHitFlagToBeExcludedEE", {});
488  desc.add<std::vector<std::string>>("RecHitSeverityToBeExcludedEE", {});
489 
490  desc.add<double>("fractionShared", 0.5);
491  desc.add<std::string>("TrajectoryBuilder", "TrajectoryBuilderForConversions");
492  {
494  psd0.setUnknown();
495  desc.add<edm::ParameterSetDescription>("TrajectoryBuilderPSet", psd0);
496  }
497  {
499  psd0.add<std::string>("propagatorAlongTISE", "alongMomElePropagator");
500  psd0.add<int>("numberMeasurementsForFit", 4);
501  psd0.add<std::string>("propagatorOppositeTISE", "oppositeToMomElePropagator");
502  desc.add<edm::ParameterSetDescription>("TransientInitialStateEstimatorParameters", psd0);
503  }
504  desc.add<bool>("allowSharedFirstHit", true);
505  desc.add<double>("ValidHitBonus", 5.0);
506  desc.add<double>("MissingHitPenalty", 20.0);
507 
508  descriptions.add("conversionTrackCandidatesDefault", desc);
509  // or use the following to generate the label from the module's C++ type
510  //descriptions.addWithDefaultLabel(desc);
511 }
std::vector< Trajectory > tracks(const TrajectorySeedCollection &seeds, TrackCandidateCollection &candidates) const override
const math::XYZPoint & position() const
cluster centroid position
Definition: CaloCluster.h:153
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:133
void setTracks(std::vector< Trajectory > const &in)
T const & getData(const ESGetToken< T, R > &iToken) const noexcept(false)
Definition: EventSetup.h:119
bool get(ProductID const &oid, Handle< PROD > &result) const
Definition: Event.h:344
edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd > hcalCutsToken_
edm::EDGetTokenT< edm::View< reco::CaloCluster > > scIslandEndcapProducer_
const edm::ESGetToken< NavigationSchool, NavigationSchoolRecord > navToken_
std::vector< TrackCandidate > TrackCandidateCollection
std::vector< edm::Ref< reco::SuperClusterCollection > > vecOfSCRefForOutIn
void insert(const H &h, I begin, I end)
Definition: ValueMap.h:53
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
edm::EDGetTokenT< EcalRecHitCollection > endcapecalCollection_
Definition: config.py:1
std::vector< edm::Ptr< reco::CaloCluster > > caloPtrVecInOut_
Log< level::Error, false > LogError
edm::EDGetTokenT< MeasurementTrackerEvent > measurementTrkEvtToken_
std::unique_ptr< BaseCkfTrajectoryBuilder > theTrajectoryBuilder_
void setNavigationSchool(const NavigationSchool *navigation)
void makeSeeds(const edm::Handle< edm::View< reco::CaloCluster > > &allBc) override
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
void makeSeeds(const edm::Handle< edm::View< reco::CaloCluster > > &allBc) override
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
ParameterDescriptionBase * add(U const &iLabel, T const &value)
ConversionTrackCandidateProducer(const edm::ParameterSet &ps)
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:130
void buildCollections(bool detector, const edm::Handle< edm::View< reco::CaloCluster >> &scHandle, const edm::Handle< edm::View< reco::CaloCluster >> &bcHandle, const EcalRecHitCollection &ecalRecHits, const EcalSeverityLevelAlgo *sevLev, ElectronHcalHelper const &hcalHelper, TrackCandidateCollection &outInTracks, TrackCandidateCollection &inOutTracks, std::vector< edm::Ptr< reco::CaloCluster >> &vecRecOI, std::vector< edm::Ptr< reco::CaloCluster >> &vecRecIO)
std::unique_ptr< ElectronHcalHelper > hcalHelper_
double energy() const
cluster energy
Definition: CaloCluster.h:148
virtual void setCandidate(float e, GlobalPoint pos)
std::vector< edm::Ref< reco::SuperClusterCollection > > vecOfSCRefForInOut
std::vector< edm::Ptr< reco::CaloCluster > > caloPtrVecOutIn_
edm::EDGetTokenT< edm::View< reco::CaloCluster > > scHybridBarrelProducer_
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord > theCaloGeomToken_
TrajectorySeedCollection & seeds()
void setEvent(const edm::Event &e)
void add(std::string const &label, ParameterSetDescription const &psetDescription)
void setEventSetup(const edm::EventSetup &es)
Initialize EventSetup objects at each event.
void setEventSetup(const edm::EventSetup &es)
Initialize EventSetup objects at each event.
Handle< PROD > getHandle(EDGetTokenT< PROD > token) const
Definition: Event.h:552
edm::EDGetTokenT< edm::View< reco::CaloCluster > > bcBarrelCollection_
edm::EDGetTokenT< edm::View< reco::CaloCluster > > bcEndcapCollection_
edm::EDGetTokenT< HBHERecHitCollection > hbheRecHits_
dictionary config
Read in AllInOne config in JSON format.
Definition: DiMuonV_cfg.py:29
double eta() const
pseudorapidity of cluster centroid
Definition: CaloCluster.h:180
void produce(edm::Event &evt, const edm::EventSetup &es) override
void beginRun(edm::Run const &, edm::EventSetup const &es) final
#define get
double hcalESum(const reco::SuperCluster &, int depth, const HcalPFCuts *hcalCuts) const
std::array< double, 4 > arrayHB
std::vector< Trajectory > tracks(const TrajectorySeedCollection &seeds, TrackCandidateCollection &candidate) const override
edm::EDGetTokenT< EcalRecHitCollection > barrelecalCollection_
void setEventSetup(const edm::EventSetup &es)
Initialize EventSetup objects at each event.
const edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd > sevlvToken_
def move(src, dest)
Definition: eostools.py:511
Definition: Run.h:45
std::array< double, 7 > arrayHE