Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:18:22 

0001 /** \class HLTGetDigi
0002  *
0003  * See header file for documentation
0004  *
0005  *
0006  *  \author various
0007  *
0008  */
0009 
0010 // system include files
0011 #include <memory>
0012 #include <vector>
0013 #include <map>
0014 
0015 #include "DataFormats/Common/interface/Handle.h"
0016 #include "FWCore/Framework/interface/EventSetup.h"
0017 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0018 #include "FWCore/Utilities/interface/InputTag.h"
0019 
0020 #include "HLTGetDigi.h"
0021 
0022 using namespace edm;
0023 using namespace std;
0024 
0025 //
0026 // constructors and destructor
0027 //
0028 HLTGetDigi::HLTGetDigi(const edm::ParameterSet& ps) : l1GtParamsToken_(esConsumes()) {
0029   EBdigiCollection_ = ps.getParameter<edm::InputTag>("EBdigiCollection");
0030   EEdigiCollection_ = ps.getParameter<edm::InputTag>("EEdigiCollection");
0031   ESdigiCollection_ = ps.getParameter<edm::InputTag>("ESdigiCollection");
0032   HBHEdigiCollection_ = ps.getParameter<edm::InputTag>("HBHEdigiCollection");
0033   HOdigiCollection_ = ps.getParameter<edm::InputTag>("HOdigiCollection");
0034   HFdigiCollection_ = ps.getParameter<edm::InputTag>("HFdigiCollection");
0035   PXLdigiCollection_ = ps.getParameter<edm::InputTag>("SiPixeldigiCollection");
0036   SSTdigiCollection_ = ps.getParameter<edm::InputTag>("SiStripdigiCollection");
0037   CSCStripdigiCollection_ = ps.getParameter<edm::InputTag>("CSCStripdigiCollection");
0038   CSCWiredigiCollection_ = ps.getParameter<edm::InputTag>("CSCWiredigiCollection");
0039   DTdigiCollection_ = ps.getParameter<edm::InputTag>("DTdigiCollection");
0040   RPCdigiCollection_ = ps.getParameter<edm::InputTag>("RPCdigiCollection");
0041 
0042   GctCaloEmLabel_ = ps.getParameter<edm::InputTag>("L1CaloEmCollection");
0043   GctCaloRegionLabel_ = ps.getParameter<edm::InputTag>("L1CaloRegionCollection");
0044 
0045   GctIsoEmLabel_ = ps.getParameter<edm::InputTag>("GctIsoEmCollection");
0046   GctNonIsoEmLabel_ = ps.getParameter<edm::InputTag>("GctNonIsoEmCollection");
0047 
0048   GctCenJetLabel_ = ps.getParameter<edm::InputTag>("GctCenJetCollection");
0049   GctForJetLabel_ = ps.getParameter<edm::InputTag>("GctForJetCollection");
0050   GctTauJetLabel_ = ps.getParameter<edm::InputTag>("GctTauJetCollection");
0051   GctJetCountsLabel_ = ps.getParameter<edm::InputTag>("GctJetCounts");
0052 
0053   GctEtHadLabel_ = ps.getParameter<edm::InputTag>("GctEtHadCollection");
0054   GctEtMissLabel_ = ps.getParameter<edm::InputTag>("GctEtMissCollection");
0055   GctEtTotalLabel_ = ps.getParameter<edm::InputTag>("GctEtTotalCollection");
0056 
0057   GtEvmRRLabel_ = ps.getParameter<edm::InputTag>("GtEvmReadoutRecord");
0058   GtObjectMapLabel_ = ps.getParameter<edm::InputTag>("GtObjectMapRecord");
0059   GtRRLabel_ = ps.getParameter<edm::InputTag>("GtReadoutRecord");
0060 
0061   GmtCandsLabel_ = ps.getParameter<edm::InputTag>("GmtCands");
0062   GmtReadoutCollection_ = ps.getParameter<edm::InputTag>("GmtReadoutCollection");
0063 
0064   //--- Define which digis we want ---//
0065   getEcalDigis_ = ps.getUntrackedParameter<bool>("getEcal", true);
0066   getEcalESDigis_ = ps.getUntrackedParameter<bool>("getEcalES", true);
0067   getHcalDigis_ = ps.getUntrackedParameter<bool>("getHcal", true);
0068   getPixelDigis_ = ps.getUntrackedParameter<bool>("getPixels", true);
0069   getStripDigis_ = ps.getUntrackedParameter<bool>("getStrips", true);
0070   getCSCDigis_ = ps.getUntrackedParameter<bool>("getCSC", true);
0071   getDTDigis_ = ps.getUntrackedParameter<bool>("getDT", true);
0072   getRPCDigis_ = ps.getUntrackedParameter<bool>("getRPC", true);
0073   getGctEmDigis_ = ps.getUntrackedParameter<bool>("getGctEm", true);
0074   getGctJetDigis_ = ps.getUntrackedParameter<bool>("getGctJet", true);
0075   getGctJetCounts_ = ps.getUntrackedParameter<bool>("getGctJetCounts", true);
0076   getGctEtDigis_ = ps.getUntrackedParameter<bool>("getGctEt", true);
0077   getL1Calo_ = ps.getUntrackedParameter<bool>("getL1Calo", true);
0078   getGtEvmRR_ = ps.getUntrackedParameter<bool>("getGtEvmRR", true);
0079   getGtObjectMap_ = ps.getUntrackedParameter<bool>("getGtObjectMap", true);
0080   getGtRR_ = ps.getUntrackedParameter<bool>("getGtReadoutRecord", true);
0081   getGmtCands_ = ps.getUntrackedParameter<bool>("getGmtCands", true);
0082   getGmtRC_ = ps.getUntrackedParameter<bool>("getGmtReadout", true);
0083 
0084   //--- Declare consums ---//
0085   if (getEcalDigis_) {
0086     EBdigiToken_ = consumes<EBDigiCollection>(EBdigiCollection_);
0087     EEdigiToken_ = consumes<EEDigiCollection>(EEdigiCollection_);
0088   }
0089   if (getEcalESDigis_) {
0090     ESdigiToken_ = consumes<ESDigiCollection>(ESdigiCollection_);
0091   }
0092   if (getHcalDigis_) {
0093     HBHEdigiToken_ = consumes<HBHEDigiCollection>(HBHEdigiCollection_);
0094     HOdigiToken_ = consumes<HODigiCollection>(HOdigiCollection_);
0095     HFdigiToken_ = consumes<HFDigiCollection>(HFdigiCollection_);
0096   }
0097   if (getPixelDigis_) {
0098     PXLdigiToken_ = consumes<edm::DetSetVector<PixelDigi> >(PXLdigiCollection_);
0099   }
0100   if (getStripDigis_) {
0101     SSTdigiToken_ = consumes<edm::DetSetVector<SiStripDigi> >(SSTdigiCollection_);
0102   }
0103   if (getCSCDigis_) {
0104     CSCStripdigiToken_ = consumes<CSCStripDigiCollection>(CSCStripdigiCollection_);
0105     CSCWiredigiToken_ = consumes<CSCWireDigiCollection>(CSCWiredigiCollection_);
0106   }
0107   if (getDTDigis_) {
0108     DTdigiToken_ = consumes<DTDigiCollection>(DTdigiCollection_);
0109   }
0110   if (getRPCDigis_) {
0111     RPCdigiToken_ = consumes<RPCDigiCollection>(RPCdigiCollection_);
0112   }
0113   if (getGctEmDigis_) {
0114     GctIsoEmToken_ = consumes<L1GctEmCandCollection>(GctIsoEmLabel_);
0115     GctNonIsoEmToken_ = consumes<L1GctEmCandCollection>(GctNonIsoEmLabel_);
0116   }
0117   if (getGctJetDigis_) {
0118     GctCenJetToken_ = consumes<L1GctJetCandCollection>(GctCenJetLabel_);
0119     GctForJetToken_ = consumes<L1GctJetCandCollection>(GctForJetLabel_);
0120     GctTauJetToken_ = consumes<L1GctJetCandCollection>(GctTauJetLabel_);
0121   }
0122   if (getGctJetCounts_) {
0123     GctJetCountsToken_ = consumes<L1GctJetCounts>(GctJetCountsLabel_);
0124   }
0125   if (getGctEtDigis_) {
0126     GctEtHadToken_ = consumes<L1GctEtHad>(GctEtHadLabel_);
0127     GctEtMissToken_ = consumes<L1GctEtMiss>(GctEtMissLabel_);
0128     GctEtTotalToken_ = consumes<L1GctEtTotal>(GctEtTotalLabel_);
0129   }
0130   if (getL1Calo_) {
0131     GctCaloEmToken_ = consumes<L1CaloEmCollection>(GctCaloEmLabel_);
0132     GctCaloRegionToken_ = consumes<L1CaloRegionCollection>(GctCaloRegionLabel_);
0133   }
0134   if (getGtEvmRR_) {
0135     GtEvmRRToken_ = consumes<L1GlobalTriggerEvmReadoutRecord>(GtEvmRRLabel_);
0136   }
0137   if (getGtObjectMap_) {
0138     GtObjectMapToken_ = consumes<L1GlobalTriggerObjectMapRecord>(GtObjectMapLabel_);
0139   }
0140   if (getGtRR_) {
0141     GtRRToken_ = consumes<L1GlobalTriggerReadoutRecord>(GtRRLabel_);
0142   }
0143   if (getGmtCands_) {
0144     GmtCandsToken_ = consumes<std::vector<L1MuGMTCand> >(GmtCandsLabel_);
0145   }
0146   if (getGmtRC_) {
0147     GmtReadoutToken_ = consumes<L1MuGMTReadoutCollection>(GmtReadoutCollection_);
0148   }
0149 }
0150 
0151 HLTGetDigi::~HLTGetDigi() = default;
0152 
0153 void HLTGetDigi::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0154   edm::ParameterSetDescription desc;
0155   desc.add<edm::InputTag>("EEdigiCollection", edm::InputTag("ecalDigis", "eeDigis"));
0156   desc.add<edm::InputTag>("HBHEdigiCollection", edm::InputTag("hcalDigis"));
0157   desc.add<edm::InputTag>("GctIsoEmCollection", edm::InputTag("gctDigis", "isoEm"));
0158   desc.add<edm::InputTag>("ESdigiCollection", edm::InputTag("ecalPreshowerDigis"));
0159   desc.add<edm::InputTag>("GctEtHadCollection", edm::InputTag("gctDigis"));
0160   desc.add<edm::InputTag>("CSCStripdigiCollection", edm::InputTag("muonCSCDigis", "MuonCSCStripDigi"));
0161   desc.add<edm::InputTag>("GmtCands", edm::InputTag("gmtDigis"));
0162   desc.add<edm::InputTag>("GctEtTotalCollection", edm::InputTag("gctDigis"));
0163   desc.add<edm::InputTag>("SiStripdigiCollection", edm::InputTag("siStripDigis"));
0164   desc.add<edm::InputTag>("GctJetCounts", edm::InputTag("gctDigis"));
0165   desc.add<edm::InputTag>("DTdigiCollection", edm::InputTag("muonDTDigis"));
0166   desc.add<edm::InputTag>("GctTauJetCollection ", edm::InputTag("gctDigis", "tauJets"));
0167   desc.add<edm::InputTag>("L1CaloRegionCollection", edm::InputTag("rctDigis"));
0168   desc.add<edm::InputTag>("GtObjectMapRecord", edm::InputTag("gtDigis"));
0169   desc.add<edm::InputTag>("GmtReadoutCollection", edm::InputTag("gmtDigis"));
0170   desc.add<edm::InputTag>("HOdigiCollection", edm::InputTag("hcalDigis"));
0171   desc.add<edm::InputTag>("RPCdigiCollection", edm::InputTag("muonRPCDigis"));
0172   desc.add<edm::InputTag>("CSCWiredigiCollection", edm::InputTag("muonCSCDigis", "MuonCSCWireDigi"));
0173   desc.add<edm::InputTag>("GctForJetCollection", edm::InputTag("gctDigis", "tauJets"));
0174   desc.add<edm::InputTag>("HFdigiCollection", edm::InputTag("hcalDigis"));
0175   desc.add<edm::InputTag>("SiPixeldigiCollection", edm::InputTag("siPixelDigis"));
0176   desc.add<edm::InputTag>("GctNonIsoEmCollection", edm::InputTag("gctDigis", "nonIsoEm"));
0177   desc.add<edm::InputTag>("GtEvmReadoutRecord", edm::InputTag("gtDigis"));
0178   desc.add<edm::InputTag>("L1CaloEmCollection", edm::InputTag("rctDigis"));
0179   desc.add<edm::InputTag>("GctCenJetCollection", edm::InputTag("gctDigis", "cenJets"));
0180   desc.add<edm::InputTag>("GtReadoutRecord", edm::InputTag("gtDigis"));
0181   desc.add<edm::InputTag>("GctEtMissCollection", edm::InputTag("gctDigis"));
0182   desc.add<edm::InputTag>("EBdigiCollection", edm::InputTag("ecalDigis", "ebDigis"));
0183   desc.addUntracked<bool>("getGctEt", true);
0184   desc.addUntracked<bool>("getGtReadoutRecord", true);
0185   desc.addUntracked<bool>("getGtEvmRR", true);
0186   desc.addUntracked<bool>("getGctEm", true);
0187   desc.addUntracked<bool>("getPixels", true);
0188   desc.addUntracked<bool>("getGctJet", true);
0189   desc.addUntracked<bool>("getHcal", true);
0190   desc.addUntracked<bool>("getGctJetCounts", true);
0191   desc.addUntracked<bool>("getL1Calo", false);
0192   desc.addUntracked<bool>("getStrips", true);
0193   desc.addUntracked<bool>("getDT", true);
0194   desc.addUntracked<bool>("getGtObjectMap", true);
0195   desc.addUntracked<bool>("getGmtCands", true);
0196   desc.addUntracked<bool>("getRPC", true);
0197   desc.addUntracked<bool>("getEcal", true);
0198   desc.addUntracked<bool>("getGmtReadout", true);
0199   desc.addUntracked<bool>("getEcalES", true);
0200   desc.addUntracked<bool>("getCSC", true);
0201   descriptions.add("hltGetDigi", desc);
0202 }
0203 
0204 //
0205 // member functions
0206 //
0207 
0208 // ------------ method called to produce the data  ------------
0209 void HLTGetDigi::analyze(edm::StreamID, const edm::Event& iEvent, const edm::EventSetup& iSetup) const {
0210   using namespace edm;
0211 
0212   //--- L1 GCT and GT Digis ---//
0213   edm::Handle<L1GctEtHad> GctEtHad;
0214   edm::Handle<L1GctEtMiss> GctEtMiss;
0215   edm::Handle<L1GctEtTotal> GctEtTotal;
0216 
0217   const L1GctEtHad* etHad = nullptr;
0218   const L1GctEtMiss* etMiss = nullptr;
0219   const L1GctEtTotal* etTotal = nullptr;
0220 
0221   if (getGctEtDigis_) {
0222     iEvent.getByToken(GctEtHadToken_, GctEtHad);
0223     iEvent.getByToken(GctEtMissToken_, GctEtMiss);
0224     iEvent.getByToken(GctEtTotalToken_, GctEtTotal);
0225     etHad = GctEtHad.product();
0226     etMiss = GctEtMiss.product();
0227     etTotal = GctEtTotal.product();
0228 
0229     LogDebug("DigiInfo") << "Value of L1GctEtHad::et(): " << etHad->et();
0230     LogDebug("DigiInfo") << "Value of L1GctEtMiss::et(): " << etMiss->et() << ", phi(): " << etMiss->phi();
0231     LogDebug("DigiInfo") << "Value of L1GctEtTotal::et(): " << etTotal->et();
0232   }
0233 
0234   edm::Handle<L1GctEmCandCollection> GctIsoEM;
0235   edm::Handle<L1GctEmCandCollection> GctNonIsoEM;
0236 
0237   const L1GctEmCandCollection* isoEMdigis = nullptr;
0238   const L1GctEmCandCollection* nonIsoEMdigis = nullptr;
0239   if (getGctEmDigis_) {
0240     iEvent.getByToken(GctIsoEmToken_, GctIsoEM);
0241     isoEMdigis = GctIsoEM.product();
0242     iEvent.getByToken(GctNonIsoEmToken_, GctNonIsoEM);
0243     nonIsoEMdigis = GctNonIsoEM.product();
0244     LogDebug("DigiInfo") << "total # Gct Iso EM digis: " << isoEMdigis->size();
0245     LogDebug("DigiInfo") << "total # Gct non-Iso EM digis: " << nonIsoEMdigis->size();
0246   }
0247 
0248   edm::Handle<L1GctJetCandCollection> GctCenJets;
0249   edm::Handle<L1GctJetCandCollection> GctForJets;
0250   edm::Handle<L1GctJetCandCollection> GctTauJets;
0251   edm::Handle<L1GctJetCounts> GctJetCounts;
0252 
0253   const L1GctJetCandCollection* cenJetDigis = nullptr;
0254   const L1GctJetCandCollection* forJetDigis = nullptr;
0255   const L1GctJetCandCollection* tauJetDigis = nullptr;
0256   std::unique_ptr<L1GctJetCounts> newCounts(new L1GctJetCounts());
0257   L1GctJetCounts* counts = newCounts.get();
0258 
0259   if (getGctJetDigis_) {
0260     iEvent.getByToken(GctCenJetToken_, GctCenJets);
0261     cenJetDigis = GctCenJets.product();
0262     iEvent.getByToken(GctForJetToken_, GctForJets);
0263     forJetDigis = GctForJets.product();
0264     iEvent.getByToken(GctTauJetToken_, GctTauJets);
0265     tauJetDigis = GctTauJets.product();
0266     LogDebug("DigiInfo") << "total # Gct central Jet digis: " << cenJetDigis->size();
0267     LogDebug("DigiInfo") << "total # Gct forward Jet digis: " << forJetDigis->size();
0268     LogDebug("DigiInfo") << "total # Gct tau Jet digis: " << tauJetDigis->size();
0269   }
0270 
0271   if (getGctJetCounts_) {
0272     iEvent.getByToken(GctJetCountsToken_, GctJetCounts);
0273     *counts = *GctJetCounts.product();
0274   }
0275 
0276   edm::Handle<L1CaloEmCollection> GctCaloEm;
0277   edm::Handle<L1CaloRegionCollection> GctCaloRegion;
0278 
0279   const L1CaloEmCollection* caloEm = nullptr;
0280   const L1CaloRegionCollection* caloRegion = nullptr;
0281 
0282   if (getL1Calo_) {
0283     iEvent.getByToken(GctCaloEmToken_, GctCaloEm);
0284     iEvent.getByToken(GctCaloRegionToken_, GctCaloRegion);
0285 
0286     caloEm = GctCaloEm.product();
0287     caloRegion = GctCaloRegion.product();
0288 
0289     LogDebug("DigiInfo") << "Calo EM size: " << caloEm->size();
0290     LogDebug("DigiInfo") << "Calo region size: " << caloRegion->size();
0291   }
0292 
0293   edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmRR;
0294   edm::Handle<L1GlobalTriggerObjectMapRecord> gtMap;
0295   edm::Handle<L1GlobalTriggerReadoutRecord> gtRR;
0296 
0297   auto const& l1GtParamsHandle = iSetup.getHandle(l1GtParamsToken_);
0298   auto const nBx = l1GtParamsHandle->gtTotalBxInEvent();
0299 
0300   std::unique_ptr<L1GlobalTriggerEvmReadoutRecord> newGtEvm(new L1GlobalTriggerEvmReadoutRecord(nBx));
0301   std::unique_ptr<L1GlobalTriggerObjectMapRecord> newGtMap(new L1GlobalTriggerObjectMapRecord());
0302   std::unique_ptr<L1GlobalTriggerReadoutRecord> newGtRR(new L1GlobalTriggerReadoutRecord(nBx));
0303   L1GlobalTriggerEvmReadoutRecord* evm = newGtEvm.get();
0304   L1GlobalTriggerObjectMapRecord* map = newGtMap.get();
0305   L1GlobalTriggerReadoutRecord* rr = newGtRR.get();
0306 
0307   if (getGtEvmRR_) {
0308     iEvent.getByToken(GtEvmRRToken_, gtEvmRR);
0309     *evm = *gtEvmRR.product();
0310   }
0311   if (getGtObjectMap_) {
0312     iEvent.getByToken(GtObjectMapToken_, gtMap);
0313     *map = *gtMap.product();
0314   }
0315   if (getGtRR_) {
0316     iEvent.getByToken(GtRRToken_, gtRR);
0317     *rr = *gtRR.product();
0318   }
0319 
0320   edm::Handle<std::vector<L1MuGMTCand> > GmtCands;
0321   edm::Handle<L1MuGMTReadoutCollection> GmtMuCollection;
0322   std::unique_ptr<std::vector<L1MuGMTCand> > cands(new std::vector<L1MuGMTCand>);
0323   std::unique_ptr<L1MuGMTReadoutCollection> muCollection(new L1MuGMTReadoutCollection(nBx));
0324 
0325   if (getGmtCands_) {
0326     iEvent.getByToken(GmtCandsToken_, GmtCands);
0327     *cands = *GmtCands.product();
0328   }
0329   if (getGmtRC_) {
0330     iEvent.getByToken(GmtReadoutToken_, GmtMuCollection);
0331     *muCollection = *GmtMuCollection.product();
0332     std::vector<L1MuGMTExtendedCand> muons = muCollection->getRecord().getGMTCands();
0333     LogDebug("DigiInfo") << "GMT muons present: " << muons.size();
0334   }
0335 
0336   edm::Handle<DetSetVector<PixelDigi> > input;
0337   unique_ptr<DetSetVector<PixelDigi> > NewPixelDigi(new DetSetVector<PixelDigi>);
0338   DetSetVector<PixelDigi>* tt = NewPixelDigi.get();
0339   if (getPixelDigis_) {
0340     iEvent.getByToken(PXLdigiToken_, input);
0341     *tt = *input.product();
0342   }
0343 
0344   edm::Handle<edm::DetSetVector<SiStripDigi> > input2;
0345   unique_ptr<DetSetVector<SiStripDigi> > NewSiDigi(new DetSetVector<SiStripDigi>);
0346   DetSetVector<SiStripDigi>* uu = NewSiDigi.get();
0347   if (getStripDigis_) {
0348     iEvent.getByToken(SSTdigiToken_, input2);
0349     *uu = *input2.product();
0350   }
0351 
0352   Handle<EBDigiCollection> EcalDigiEB;
0353   Handle<EEDigiCollection> EcalDigiEE;
0354   Handle<ESDigiCollection> EcalDigiES;
0355   const EBDigiCollection* EBdigis = nullptr;
0356   const EEDigiCollection* EEdigis = nullptr;
0357   const ESDigiCollection* ESdigis = nullptr;
0358 
0359   if (getEcalDigis_) {
0360     iEvent.getByToken(EBdigiToken_, EcalDigiEB);
0361     EBdigis = EcalDigiEB.product();
0362     LogDebug("DigiInfo") << "total # EBdigis: " << EBdigis->size();
0363 
0364     iEvent.getByToken(EEdigiToken_, EcalDigiEE);
0365     EEdigis = EcalDigiEE.product();
0366     LogDebug("DigiInfo") << "total # EEdigis: " << EEdigis->size();
0367   }
0368 
0369   if (getEcalESDigis_) {
0370     iEvent.getByToken(ESdigiToken_, EcalDigiES);
0371     ESdigis = EcalDigiES.product();
0372     LogDebug("DigiInfo") << "total # ESdigis: " << ESdigis->size();
0373   }
0374 
0375   Handle<HBHEDigiCollection> HcalDigiHBHE;
0376   Handle<HODigiCollection> HcalDigiHO;
0377   Handle<HFDigiCollection> HcalDigiHF;
0378   const HBHEDigiCollection* HBHEdigis = nullptr;
0379   const HODigiCollection* HOdigis = nullptr;
0380   const HFDigiCollection* HFdigis = nullptr;
0381 
0382   if (getHcalDigis_) {
0383     iEvent.getByToken(HBHEdigiToken_, HcalDigiHBHE);
0384     HBHEdigis = HcalDigiHBHE.product();
0385     LogDebug("DigiInfo") << "total # HBHEdigis: " << HBHEdigis->size();
0386 
0387     iEvent.getByToken(HOdigiToken_, HcalDigiHO);
0388     HOdigis = HcalDigiHO.product();
0389     LogDebug("DigiInfo") << "total # HOdigis: " << HOdigis->size();
0390 
0391     iEvent.getByToken(HFdigiToken_, HcalDigiHF);
0392     HFdigis = HcalDigiHF.product();
0393     LogDebug("DigiInfo") << "total # HFdigis: " << HFdigis->size();
0394   }
0395 
0396   Handle<CSCStripDigiCollection> CSCDigiStrip;
0397   Handle<CSCWireDigiCollection> CSCDigiWire;
0398 
0399   if (getCSCDigis_) {
0400     iEvent.getByToken(CSCStripdigiToken_, CSCDigiStrip);
0401     iEvent.getByToken(CSCWiredigiToken_, CSCDigiWire);
0402 
0403     int numDigis = 0;
0404     for (auto&& iter : *CSCDigiStrip) {
0405       for (auto digiIter = iter.second.first; digiIter != iter.second.second; digiIter++)
0406         numDigis++;
0407     }
0408     LogDebug("DigiInfo") << "total # CSCstripdigis: " << numDigis;
0409     numDigis = 0;
0410     for (auto&& iter : *CSCDigiWire) {
0411       for (auto digiIter = iter.second.first; digiIter != iter.second.second; digiIter++)
0412         numDigis++;
0413     }
0414     LogDebug("DigiInfo") << "total # CSCwiredigis: " << numDigis;
0415   }
0416 
0417   Handle<DTDigiCollection> DTDigiHandle;
0418 
0419   if (getDTDigis_) {
0420     iEvent.getByToken(DTdigiToken_, DTDigiHandle);
0421 
0422     int numDigis = 0;
0423     for (auto&& iter : *DTDigiHandle) {
0424       for (auto digiIter = iter.second.first; digiIter != iter.second.second; digiIter++)
0425         numDigis++;
0426     }
0427     LogDebug("DigiInfo") << "total # DTdigis: " << numDigis;
0428   }
0429 
0430   Handle<RPCDigiCollection> RPCDigiHandle;
0431 
0432   if (getRPCDigis_) {
0433     iEvent.getByToken(RPCdigiToken_, RPCDigiHandle);
0434 
0435     int numDigis = 0;
0436     for (auto&& iter : *RPCDigiHandle) {
0437       for (auto digiIter = iter.second.first; digiIter != iter.second.second; digiIter++)
0438         numDigis++;
0439     }
0440     LogDebug("DigiInfo") << "total # RPCdigis: " << numDigis;
0441   }
0442 
0443   LogDebug("DigiInfo") << "***--------------- End of Event -----------------***";
0444 }
0445 
0446 // declare this class as a framework plugin
0447 #include "FWCore/Framework/interface/MakerMacros.h"
0448 DEFINE_FWK_MODULE(HLTGetDigi);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!