CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
HLTGetDigi.cc
Go to the documentation of this file.
1 
10 #include "HLTrigger/HLTanalyzers/interface/HLTGetDigi.h"
11 
12 #include "DataFormats/Common/interface/Handle.h"
13 #include "FWCore/Framework/interface/EventSetup.h"
14 #include "FWCore/Framework/interface/ESHandle.h"
15 
16 // system include files
17 #include <memory>
18 #include <vector>
19 #include <map>
20 
21 #include "FWCore/MessageLogger/interface/MessageLogger.h"
22 #include "FWCore/Utilities/interface/InputTag.h"
23 
24 using namespace edm;
25 using namespace std;
26 
27 //
28 // constructors and destructor
29 //
30 HLTGetDigi::HLTGetDigi(const edm::ParameterSet& ps)
31 {
32  EBdigiCollection_ = ps.getParameter<edm::InputTag>("EBdigiCollection");
33  EEdigiCollection_ = ps.getParameter<edm::InputTag>("EEdigiCollection");
34  ESdigiCollection_ = ps.getParameter<edm::InputTag>("ESdigiCollection");
35  HBHEdigiCollection_ = ps.getParameter<edm::InputTag>("HBHEdigiCollection");
36  HOdigiCollection_ = ps.getParameter<edm::InputTag>("HOdigiCollection");
37  HFdigiCollection_ = ps.getParameter<edm::InputTag>("HFdigiCollection");
38  PXLdigiCollection_ = ps.getParameter<edm::InputTag>("SiPixeldigiCollection");
39  SSTdigiCollection_ = ps.getParameter<edm::InputTag>("SiStripdigiCollection");
40  CSCStripdigiCollection_ = ps.getParameter<edm::InputTag>("CSCStripdigiCollection");
41  CSCWiredigiCollection_ = ps.getParameter<edm::InputTag>("CSCWiredigiCollection");
42  DTdigiCollection_ = ps.getParameter<edm::InputTag>("DTdigiCollection");
43  RPCdigiCollection_ = ps.getParameter<edm::InputTag>("RPCdigiCollection");
44 
45  GctCaloEmLabel_ = ps.getParameter<edm::InputTag>("L1CaloEmCollection");
46  GctCaloRegionLabel_ = ps.getParameter<edm::InputTag>("L1CaloRegionCollection");
47 
48  GctIsoEmLabel_ = ps.getParameter<edm::InputTag>("GctIsoEmCollection");
49  GctNonIsoEmLabel_ = ps.getParameter<edm::InputTag>("GctNonIsoEmCollection");
50 
51  GctCenJetLabel_ = ps.getParameter<edm::InputTag>("GctCenJetCollection");
52  GctForJetLabel_ = ps.getParameter<edm::InputTag>("GctForJetCollection");
53  GctTauJetLabel_ = ps.getParameter<edm::InputTag>("GctTauJetCollection");
54  GctJetCountsLabel_ = ps.getParameter<edm::InputTag>("GctJetCounts");
55 
56  GctEtHadLabel_ = ps.getParameter<edm::InputTag>("GctEtHadCollection");
57  GctEtMissLabel_ = ps.getParameter<edm::InputTag>("GctEtMissCollection");
58  GctEtTotalLabel_ = ps.getParameter<edm::InputTag>("GctEtTotalCollection");
59 
60  GtEvmRRLabel_ = ps.getParameter<edm::InputTag>("GtEvmReadoutRecord");
61  GtObjectMapLabel_ = ps.getParameter<edm::InputTag>("GtObjectMapRecord");
62  GtRRLabel_ = ps.getParameter<edm::InputTag>("GtReadoutRecord");
63 
64  GmtCandsLabel_ = ps.getParameter<edm::InputTag>("GmtCands");
65  GmtReadoutCollection_ = ps.getParameter<edm::InputTag>("GmtReadoutCollection");
66 
67  //--- Define which digis we want ---//
68  getEcalDigis_ = ps.getUntrackedParameter<bool>("getEcal",true) ;
69  getEcalESDigis_ = ps.getUntrackedParameter<bool>("getEcalES",true) ;
70  getHcalDigis_ = ps.getUntrackedParameter<bool>("getHcal",true) ;
71  getPixelDigis_ = ps.getUntrackedParameter<bool>("getPixels",true) ;
72  getStripDigis_ = ps.getUntrackedParameter<bool>("getStrips",true) ;
73  getCSCDigis_ = ps.getUntrackedParameter<bool>("getCSC",true) ;
74  getDTDigis_ = ps.getUntrackedParameter<bool>("getDT",true) ;
75  getRPCDigis_ = ps.getUntrackedParameter<bool>("getRPC",true) ;
76  getGctEmDigis_ = ps.getUntrackedParameter<bool>("getGctEm",true) ;
77  getGctJetDigis_ = ps.getUntrackedParameter<bool>("getGctJet",true) ;
78  getGctJetCounts_ = ps.getUntrackedParameter<bool>("getGctJetCounts",true) ;
79  getGctEtDigis_ = ps.getUntrackedParameter<bool>("getGctEt",true) ;
80  getL1Calo_ = ps.getUntrackedParameter<bool>("getL1Calo",true) ;
81  getGtEvmRR_ = ps.getUntrackedParameter<bool>("getGtEvmRR",true) ;
82  getGtObjectMap_ = ps.getUntrackedParameter<bool>("getGtObjectMap",true) ;
83  getGtRR_ = ps.getUntrackedParameter<bool>("getGtReadoutRecord",true) ;
84  getGmtCands_ = ps.getUntrackedParameter<bool>("getGmtCands",true) ;
85  getGmtRC_ = ps.getUntrackedParameter<bool>("getGmtReadout",true) ;
86 
87  //--- Declare consums ---//
88  if (getEcalDigis_) {
89  EBdigiToken_ = consumes<EBDigiCollection>(EBdigiCollection_);
90  EEdigiToken_ = consumes<EEDigiCollection>(EEdigiCollection_);
91  }
92  if (getEcalESDigis_) {
93  ESdigiToken_ = consumes<ESDigiCollection>(ESdigiCollection_);
94  }
95  if (getHcalDigis_) {
96  HBHEdigiToken_ = consumes<HBHEDigiCollection>(HBHEdigiCollection_);
97  HOdigiToken_ = consumes<HODigiCollection>(HOdigiCollection_);
98  HFdigiToken_ = consumes<HFDigiCollection>(HFdigiCollection_);
99  }
100  if (getPixelDigis_) {
101  PXLdigiToken_ = consumes<edm::DetSetVector<PixelDigi> >(PXLdigiCollection_);
102  }
103  if (getStripDigis_) {
104  SSTdigiToken_ = consumes<edm::DetSetVector<SiStripDigi> >(SSTdigiCollection_);
105  }
106  if (getCSCDigis_) {
107  CSCStripdigiToken_ = consumes<CSCStripDigiCollection>(CSCStripdigiCollection_);
108  CSCWiredigiToken_ = consumes<CSCWireDigiCollection>(CSCWiredigiCollection_);
109  }
110  if (getDTDigis_) {
111  DTdigiToken_ = consumes<DTDigiCollection>(DTdigiCollection_);
112  }
113  if (getRPCDigis_) {
114  RPCdigiToken_ = consumes<RPCDigiCollection>(RPCdigiCollection_);
115  }
116  if (getGctEmDigis_) {
117  GctIsoEmToken_ = consumes<L1GctEmCandCollection>(GctIsoEmLabel_);
118  GctNonIsoEmToken_ = consumes<L1GctEmCandCollection>(GctNonIsoEmLabel_);
119  }
120  if (getGctJetDigis_) {
121  GctCenJetToken_ = consumes<L1GctJetCandCollection>(GctCenJetLabel_);
122  GctForJetToken_ = consumes<L1GctJetCandCollection>(GctForJetLabel_);
123  GctTauJetToken_ = consumes<L1GctJetCandCollection>(GctTauJetLabel_);
124  }
125  if (getGctJetCounts_) {
126  GctJetCountsToken_ = consumes<L1GctJetCounts>(GctJetCountsLabel_);
127  }
128  if (getGctEtDigis_) {
129  GctEtHadToken_ = consumes<L1GctEtHad>(GctEtHadLabel_);
130  GctEtMissToken_ = consumes<L1GctEtMiss>(GctEtMissLabel_);
131  GctEtTotalToken_ = consumes<L1GctEtTotal>(GctEtTotalLabel_);
132  }
133  if (getL1Calo_) {
134  GctCaloEmToken_ = consumes<L1CaloEmCollection>(GctCaloEmLabel_);
135  GctCaloRegionToken_ = consumes<L1CaloRegionCollection>(GctCaloRegionLabel_);
136  }
137  if (getGtEvmRR_) {
138  GtEvmRRToken_ = consumes<L1GlobalTriggerEvmReadoutRecord>(GtEvmRRLabel_);
139  }
140  if (getGtObjectMap_) {
141  GtObjectMapToken_ = consumes<L1GlobalTriggerObjectMapRecord>(GtObjectMapLabel_);
142  }
143  if (getGtRR_) {
144  GtRRToken_ = consumes<L1GlobalTriggerReadoutRecord>(GtRRLabel_);
145  }
146  if (getGmtCands_) {
147  GmtCandsToken_ = consumes<std::vector<L1MuGMTCand> >(GmtCandsLabel_);
148  }
149  if (getGmtRC_) {
150  GmtReadoutToken_ = consumes<L1MuGMTReadoutCollection>(GmtReadoutCollection_);
151  }
152 
153 }
154 
155 HLTGetDigi::~HLTGetDigi()
156 { }
157 
158 void
159 HLTGetDigi::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
160  edm::ParameterSetDescription desc;
161  desc.add<edm::InputTag>("EEdigiCollection",edm::InputTag("ecalDigis","eeDigis"));
162  desc.add<edm::InputTag>("HBHEdigiCollection",edm::InputTag("hcalDigis"));
163  desc.add<edm::InputTag>("GctIsoEmCollection",edm::InputTag("gctDigis","isoEm"));
164  desc.add<edm::InputTag>("ESdigiCollection",edm::InputTag("ecalPreshowerDigis"));
165  desc.add<edm::InputTag>("GctEtHadCollection",edm::InputTag("gctDigis"));
166  desc.add<edm::InputTag>("CSCStripdigiCollection",edm::InputTag("muonCSCDigis","MuonCSCStripDigi"));
167  desc.add<edm::InputTag>("GmtCands",edm::InputTag("gmtDigis"));
168  desc.add<edm::InputTag>("GctEtTotalCollection",edm::InputTag("gctDigis"));
169  desc.add<edm::InputTag>("SiStripdigiCollection",edm::InputTag("siStripDigis"));
170  desc.add<edm::InputTag>("GctJetCounts",edm::InputTag("gctDigis"));
171  desc.add<edm::InputTag>("DTdigiCollection",edm::InputTag("muonDTDigis"));
172  desc.add<edm::InputTag>("GctTauJetCollection ",edm::InputTag("gctDigis","tauJets"));
173  desc.add<edm::InputTag>("L1CaloRegionCollection",edm::InputTag("rctDigis"));
174  desc.add<edm::InputTag>("GtObjectMapRecord",edm::InputTag("gtDigis"));
175  desc.add<edm::InputTag>("GmtReadoutCollection",edm::InputTag("gmtDigis"));
176  desc.add<edm::InputTag>("HOdigiCollection",edm::InputTag("hcalDigis"));
177  desc.add<edm::InputTag>("RPCdigiCollection",edm::InputTag("muonRPCDigis"));
178  desc.add<edm::InputTag>("CSCWiredigiCollection",edm::InputTag("muonCSCDigis","MuonCSCWireDigi"));
179  desc.add<edm::InputTag>("GctForJetCollection",edm::InputTag("gctDigis","tauJets"));
180  desc.add<edm::InputTag>("HFdigiCollection",edm::InputTag("hcalDigis"));
181  desc.add<edm::InputTag>("SiPixeldigiCollection",edm::InputTag("siPixelDigis"));
182  desc.add<edm::InputTag>("GctNonIsoEmCollection",edm::InputTag("gctDigis","nonIsoEm"));
183  desc.add<edm::InputTag>("GtEvmReadoutRecord",edm::InputTag("gtDigis"));
184  desc.add<edm::InputTag>("L1CaloEmCollection",edm::InputTag("rctDigis"));
185  desc.add<edm::InputTag>("GctCenJetCollection",edm::InputTag("gctDigis","cenJets"));
186  desc.add<edm::InputTag>("GtReadoutRecord",edm::InputTag("gtDigis"));
187  desc.add<edm::InputTag>("GctEtMissCollection",edm::InputTag("gctDigis"));
188  desc.add<edm::InputTag>("EBdigiCollection",edm::InputTag("ecalDigis","ebDigis"));
189  desc.addUntracked<bool>("getGctEt",true);
190  desc.addUntracked<bool>("getGtReadoutRecord",true);
191  desc.addUntracked<bool>("getGtEvmRR",true);
192  desc.addUntracked<bool>("getGctEm",true);
193  desc.addUntracked<bool>("getPixels",true);
194  desc.addUntracked<bool>("getGctJet",true);
195  desc.addUntracked<bool>("getHcal",true);
196  desc.addUntracked<bool>("getGctJetCounts",true);
197  desc.addUntracked<bool>("getL1Calo",false);
198  desc.addUntracked<bool>("getStrips",true);
199  desc.addUntracked<bool>("getDT",true);
200  desc.addUntracked<bool>("getGtObjectMap",true);
201  desc.addUntracked<bool>("getGmtCands",true);
202  desc.addUntracked<bool>("getRPC",true);
203  desc.addUntracked<bool>("getEcal",true);
204  desc.addUntracked<bool>("getGmtReadout",true);
205  desc.addUntracked<bool>("getEcalES",true);
206  desc.addUntracked<bool>("getCSC",true);
207  descriptions.add("hltGetDigi",desc);
208 }
209 
210 //
211 // member functions
212 //
213 
214 // ------------ method called to produce the data ------------
215 void
216 HLTGetDigi::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
217 {
218  using namespace edm;
219 
220  //--- L1 GCT and GT Digis ---//
221  edm::Handle<L1GctEtHad> GctEtHad ;
222  edm::Handle<L1GctEtMiss> GctEtMiss ;
223  edm::Handle<L1GctEtTotal> GctEtTotal ;
224 
225  const L1GctEtHad* etHad = 0 ;
226  const L1GctEtMiss* etMiss = 0 ;
227  const L1GctEtTotal* etTotal = 0 ;
228 
229  if (getGctEtDigis_) {
230  iEvent.getByToken(GctEtHadToken_,GctEtHad) ;
231  iEvent.getByToken(GctEtMissToken_,GctEtMiss) ;
232  iEvent.getByToken(GctEtTotalToken_,GctEtTotal) ;
233  etHad = GctEtHad.product() ;
234  etMiss = GctEtMiss.product() ;
235  etTotal = GctEtTotal.product() ;
236 
237  LogDebug("DigiInfo") << "Value of L1GctEtHad::et(): " << etHad->et() ;
238  LogDebug("DigiInfo") << "Value of L1GctEtMiss::et(): " << etMiss->et() << ", phi(): " << etMiss->phi() ;
239  LogDebug("DigiInfo") << "Value of L1GctEtTotal::et(): " << etTotal->et() ;
240  }
241 
242  edm::Handle<L1GctEmCandCollection> GctIsoEM ;
243  edm::Handle<L1GctEmCandCollection> GctNonIsoEM ;
244 
245  const L1GctEmCandCollection* isoEMdigis = 0 ;
246  const L1GctEmCandCollection* nonIsoEMdigis = 0 ;
247  if (getGctEmDigis_) {
248  iEvent.getByToken(GctIsoEmToken_,GctIsoEM) ;
249  isoEMdigis = GctIsoEM.product() ;
250  iEvent.getByToken(GctNonIsoEmToken_,GctNonIsoEM) ;
251  nonIsoEMdigis = GctNonIsoEM.product() ;
252  LogDebug("DigiInfo") << "total # Gct Iso EM digis: " << isoEMdigis->size() ;
253  LogDebug("DigiInfo") << "total # Gct non-Iso EM digis: " << nonIsoEMdigis->size() ;
254  }
255 
256  edm::Handle<L1GctJetCandCollection> GctCenJets ;
257  edm::Handle<L1GctJetCandCollection> GctForJets ;
258  edm::Handle<L1GctJetCandCollection> GctTauJets ;
259  edm::Handle<L1GctJetCounts> GctJetCounts ;
260 
261  const L1GctJetCandCollection* cenJetDigis = 0 ;
262  const L1GctJetCandCollection* forJetDigis = 0 ;
263  const L1GctJetCandCollection* tauJetDigis = 0 ;
264  std::auto_ptr<L1GctJetCounts> newCounts( new L1GctJetCounts() ) ;
265  L1GctJetCounts* counts = newCounts.get() ;
266 
267  if (getGctJetDigis_) {
268  iEvent.getByToken(GctCenJetToken_,GctCenJets) ;
269  cenJetDigis = GctCenJets.product() ;
270  iEvent.getByToken(GctForJetToken_,GctForJets) ;
271  forJetDigis = GctForJets.product() ;
272  iEvent.getByToken(GctTauJetToken_,GctTauJets) ;
273  tauJetDigis = GctTauJets.product() ;
274  LogDebug("DigiInfo") << "total # Gct central Jet digis: " << cenJetDigis->size() ;
275  LogDebug("DigiInfo") << "total # Gct forward Jet digis: " << forJetDigis->size() ;
276  LogDebug("DigiInfo") << "total # Gct tau Jet digis: " << tauJetDigis->size() ;
277  }
278 
279  if (getGctJetCounts_) {
280  iEvent.getByToken(GctJetCountsToken_,GctJetCounts) ;
281  *counts = *GctJetCounts.product() ;
282  }
283 
284  edm::Handle<L1CaloEmCollection> GctCaloEm ;
285  edm::Handle<L1CaloRegionCollection> GctCaloRegion ;
286 
287  const L1CaloEmCollection* caloEm = 0 ;
288  const L1CaloRegionCollection* caloRegion = 0 ;
289 
290  if (getL1Calo_) {
291  iEvent.getByToken(GctCaloEmToken_,GctCaloEm) ;
292  iEvent.getByToken(GctCaloRegionToken_,GctCaloRegion) ;
293 
294  caloEm = GctCaloEm.product() ;
295  caloRegion = GctCaloRegion.product() ;
296 
297  LogDebug("DigiInfo") << "Calo EM size: " << caloEm->size() ;
298  LogDebug("DigiInfo") << "Calo region size: " << caloRegion->size() ;
299  }
300 
301  edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmRR ;
302  edm::Handle<L1GlobalTriggerObjectMapRecord> gtMap ;
303  edm::Handle<L1GlobalTriggerReadoutRecord> gtRR ;
304 
305  edm::ESHandle< L1GtParameters > l1GtPar ;
306  iSetup.get< L1GtParametersRcd >().get( l1GtPar ) ;
307  int nBx = l1GtPar->gtTotalBxInEvent() ;
308 
309  std::auto_ptr<L1GlobalTriggerEvmReadoutRecord> newGtEvm( new L1GlobalTriggerEvmReadoutRecord(nBx) ) ;
310  std::auto_ptr<L1GlobalTriggerObjectMapRecord> newGtMap( new L1GlobalTriggerObjectMapRecord() ) ;
311  std::auto_ptr<L1GlobalTriggerReadoutRecord> newGtRR( new L1GlobalTriggerReadoutRecord(nBx) ) ;
312  L1GlobalTriggerEvmReadoutRecord* evm = newGtEvm.get() ;
313  L1GlobalTriggerObjectMapRecord* map = newGtMap.get() ;
314  L1GlobalTriggerReadoutRecord* rr = newGtRR.get() ;
315 
316  if (getGtEvmRR_) {
317  iEvent.getByToken(GtEvmRRToken_, gtEvmRR) ;
318  *evm = *gtEvmRR.product() ;
319  }
320  if (getGtObjectMap_) {
321  iEvent.getByToken(GtObjectMapToken_, gtMap) ;
322  *map = *gtMap.product() ;
323  }
324  if (getGtRR_) {
325  iEvent.getByToken(GtRRToken_, gtRR) ;
326  *rr = *gtRR.product() ;
327  }
328 
329  edm::Handle< std::vector<L1MuGMTCand> > GmtCands ;
330  edm::Handle<L1MuGMTReadoutCollection> GmtMuCollection ;
331  std::auto_ptr<std::vector<L1MuGMTCand> > cands( new std::vector<L1MuGMTCand> ) ;
332  std::auto_ptr<L1MuGMTReadoutCollection> muCollection(new L1MuGMTReadoutCollection(nBx)) ;
333 
334  if (getGmtCands_) {
335  iEvent.getByToken(GmtCandsToken_,GmtCands) ;
336  *cands = *GmtCands.product() ;
337  }
338  if (getGmtRC_) {
339  iEvent.getByToken(GmtReadoutToken_,GmtMuCollection) ;
340  *muCollection = *GmtMuCollection.product() ;
341  std::vector<L1MuGMTExtendedCand> muons = muCollection->getRecord().getGMTCands() ;
342  LogDebug("DigiInfo") << "GMT muons present: " << muons.size() ;
343  }
344 
345  edm::Handle< DetSetVector<PixelDigi> > input;
346  auto_ptr<DetSetVector<PixelDigi> > NewPixelDigi(new DetSetVector<PixelDigi> );
347  DetSetVector<PixelDigi>* tt = NewPixelDigi.get();
348  if (getPixelDigis_) {
349  iEvent.getByToken(PXLdigiToken_, input);
350  *tt = *input.product();
351  }
352 
353  edm::Handle< edm::DetSetVector<SiStripDigi> > input2;
354  auto_ptr<DetSetVector<SiStripDigi> > NewSiDigi(new DetSetVector<SiStripDigi> );
355  DetSetVector<SiStripDigi>* uu = NewSiDigi.get();
356  if (getStripDigis_) {
357  iEvent.getByToken(SSTdigiToken_, input2);
358  *uu = *input2.product();
359  }
360 
361  Handle<EBDigiCollection> EcalDigiEB;
362  Handle<EEDigiCollection> EcalDigiEE;
363  Handle<ESDigiCollection> EcalDigiES;
364  const EBDigiCollection* EBdigis = 0;
365  const EEDigiCollection* EEdigis = 0;
366  const ESDigiCollection* ESdigis = 0;
367 
368  if (getEcalDigis_) {
369  iEvent.getByToken( EBdigiToken_, EcalDigiEB );
370  EBdigis = EcalDigiEB.product();
371  LogDebug("DigiInfo") << "total # EBdigis: " << EBdigis->size() ;
372 
373  iEvent.getByToken( EEdigiToken_, EcalDigiEE );
374  EEdigis = EcalDigiEE.product();
375  LogDebug("DigiInfo") << "total # EEdigis: " << EEdigis->size() ;
376  }
377 
378  if (getEcalESDigis_) {
379  iEvent.getByToken( ESdigiToken_, EcalDigiES );
380  ESdigis = EcalDigiES.product();
381  LogDebug("DigiInfo") << "total # ESdigis: " << ESdigis->size() ;
382  }
383 
384  Handle<HBHEDigiCollection> HcalDigiHBHE ;
385  Handle<HODigiCollection> HcalDigiHO ;
386  Handle<HFDigiCollection> HcalDigiHF ;
387  const HBHEDigiCollection* HBHEdigis = 0 ;
388  const HODigiCollection* HOdigis = 0 ;
389  const HFDigiCollection* HFdigis = 0 ;
390 
391  if (getHcalDigis_) {
392  iEvent.getByToken( HBHEdigiToken_, HcalDigiHBHE );
393  HBHEdigis = HcalDigiHBHE.product();
394  LogDebug("DigiInfo") << "total # HBHEdigis: " << HBHEdigis->size() ;
395 
396  iEvent.getByToken( HOdigiToken_, HcalDigiHO );
397  HOdigis = HcalDigiHO.product();
398  LogDebug("DigiInfo") << "total # HOdigis: " << HOdigis->size() ;
399 
400  iEvent.getByToken( HFdigiToken_, HcalDigiHF );
401  HFdigis = HcalDigiHF.product();
402  LogDebug("DigiInfo") << "total # HFdigis: " << HFdigis->size() ;
403  }
404 
405  Handle<CSCStripDigiCollection> CSCDigiStrip ;
406  Handle<CSCWireDigiCollection> CSCDigiWire ;
407 
408  if (getCSCDigis_) {
409  iEvent.getByToken( CSCStripdigiToken_, CSCDigiStrip );
410  iEvent.getByToken( CSCWiredigiToken_, CSCDigiWire );
411 
412  int numDigis = 0 ;
413  for (CSCStripDigiCollection::DigiRangeIterator iter=CSCDigiStrip->begin();
414  iter!=CSCDigiStrip->end(); iter++) {
415  for ( vector<CSCStripDigi>::const_iterator digiIter = (*iter).second.first;
416  digiIter != (*iter).second.second; digiIter++) numDigis++ ;
417  }
418  LogDebug("DigiInfo") << "total # CSCstripdigis: " << numDigis ;
419  numDigis = 0 ;
420  for (CSCWireDigiCollection::DigiRangeIterator iter=CSCDigiWire->begin();
421  iter!=CSCDigiWire->end(); iter++) {
422  for ( vector<CSCWireDigi>::const_iterator digiIter = (*iter).second.first;
423  digiIter != (*iter).second.second; digiIter++) numDigis++ ;
424  }
425  LogDebug("DigiInfo") << "total # CSCwiredigis: " << numDigis ;
426  }
427 
428  Handle<DTDigiCollection> DTDigiHandle ;
429 
430  if (getDTDigis_) {
431  iEvent.getByToken( DTdigiToken_, DTDigiHandle );
432 
433  int numDigis = 0 ;
434  for (DTDigiCollection::DigiRangeIterator iter=DTDigiHandle->begin();
435  iter!=DTDigiHandle->end(); iter++) {
436  for ( vector<DTDigi>::const_iterator digiIter = (*iter).second.first;
437  digiIter != (*iter).second.second; digiIter++) numDigis++ ;
438  }
439  LogDebug("DigiInfo") << "total # DTdigis: " << numDigis ;
440  }
441 
442  Handle<RPCDigiCollection> RPCDigiHandle ;
443 
444  if (getRPCDigis_) {
445  iEvent.getByToken( RPCdigiToken_, RPCDigiHandle );
446 
447  int numDigis = 0 ;
448  for (RPCDigiCollection::DigiRangeIterator iter=RPCDigiHandle->begin();
449  iter!=RPCDigiHandle->end(); iter++) {
450  for ( vector<RPCDigi>::const_iterator digiIter = (*iter).second.first;
451  digiIter != (*iter).second.second; digiIter++) numDigis++ ;
452  }
453  LogDebug("DigiInfo") << "total # RPCdigis: " << numDigis ;
454  }
455 
456  LogDebug("DigiInfo") << "***--------------- End of Event -----------------***" ;
457 
458 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
L1CaloEmCollection
std::vector< L1CaloEmCand > L1CaloEmCollection
Definition: L1CaloCollections.h:10
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:94
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:446
L1GctEtMiss
Persistable copy of missing Et measured at Level-1.
Definition: L1GctEtMiss.h:18
HLTGetDigi::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: HLTGetDigi.cc:159
input2
#define input2
Definition: AMPTWrapper.h:149
input
static std::string const input
Definition: EdmProvDump.cc:44
L1GctJetCandCollection
std::vector< L1GctJetCand > L1GctJetCandCollection
Definition: L1GctCollections.h:31
iEvent
int iEvent
Definition: GenABIO.cc:230
L1GctEtTotal
Persistable copy of total Et measured at Level-1.
Definition: L1GctEtTotal.h:18
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:89
L1GctEtHad
Persistable copy of total Ht measured at Level-1.
Definition: L1GctEtHad.h:18
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:65
HLTGetDigi::analyze
void analyze(const edm::Event &, const edm::EventSetup &)
Definition: HLTGetDigi.cc:216
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
HLTGetDigi::HLTGetDigi
HLTGetDigi(const edm::ParameterSet &)
Definition: HLTGetDigi.cc:30
L1CaloRegionCollection
std::vector< L1CaloRegion > L1CaloRegionCollection
Definition: L1CaloCollections.h:11
L1GctEmCandCollection
std::vector< L1GctEmCand > L1GctEmCandCollection
Definition: L1GctCollections.h:30
Generated for CMSSW Reference Manual by doxygen 1.8.5