Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-03-17 11:27:33 

0001 /** \file GlobalDigisProducer.cc
0002  *
0003  *  See header file for description of class
0004  *
0005  *  \author M. Strang SUNY-Buffalo
0006  */
0007 
0008 #include "CondFormats/EcalObjects/interface/EcalMGPAGainRatio.h"
0009 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
0010 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
0011 #include "Validation/GlobalDigis/interface/GlobalDigisProducer.h"
0012 
0013 GlobalDigisProducer::GlobalDigisProducer(const edm::ParameterSet &iPSet)
0014     : fName(""),
0015       verbosity(0),
0016       frequency(0),
0017       label(""),
0018       getAllProvenances(false),
0019       printProvenanceInfo(false),
0020       theCSCStripPedestalSum(0),
0021       theCSCStripPedestalCount(0),
0022       count(0) {
0023   std::string MsgLoggerCat = "GlobalDigisProducer_GlobalDigisProducer";
0024 
0025   // get information from parameter set
0026   fName = iPSet.getUntrackedParameter<std::string>("Name");
0027   verbosity = iPSet.getUntrackedParameter<int>("Verbosity");
0028   frequency = iPSet.getUntrackedParameter<int>("Frequency");
0029   label = iPSet.getParameter<std::string>("Label");
0030   edm::ParameterSet m_Prov = iPSet.getParameter<edm::ParameterSet>("ProvenanceLookup");
0031   getAllProvenances = m_Prov.getUntrackedParameter<bool>("GetAllProvenances");
0032   printProvenanceInfo = m_Prov.getUntrackedParameter<bool>("PrintProvenanceInfo");
0033 
0034   // get Labels to use to extract information
0035   ECalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalEBSrc");
0036   ECalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalEESrc");
0037   ECalESSrc_ = iPSet.getParameter<edm::InputTag>("ECalESSrc");
0038   HCalSrc_ = iPSet.getParameter<edm::InputTag>("HCalSrc");
0039   HCalDigi_ = iPSet.getParameter<edm::InputTag>("HCalDigi");
0040   SiStripSrc_ = iPSet.getParameter<edm::InputTag>("SiStripSrc");
0041   SiPxlSrc_ = iPSet.getParameter<edm::InputTag>("SiPxlSrc");
0042   MuDTSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSrc");
0043   MuCSCStripSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCStripSrc");
0044   MuCSCWireSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCWireSrc");
0045   // fix for consumes
0046   ECalEBSrc_Token_ = consumes<EBDigiCollection>(iPSet.getParameter<edm::InputTag>("ECalEBSrc"));
0047   ECalEESrc_Token_ = consumes<EEDigiCollection>(iPSet.getParameter<edm::InputTag>("ECalEESrc"));
0048   ECalESSrc_Token_ = consumes<ESDigiCollection>(iPSet.getParameter<edm::InputTag>("ECalESSrc"));
0049   HCalSrc_Token_ = consumes<edm::PCaloHitContainer>(iPSet.getParameter<edm::InputTag>("HCalSrc"));
0050   HBHEDigi_Token_ = consumes<edm::SortedCollection<HBHEDataFrame>>(iPSet.getParameter<edm::InputTag>("HCalDigi"));
0051   HODigi_Token_ = consumes<edm::SortedCollection<HODataFrame>>(iPSet.getParameter<edm::InputTag>("HCalDigi"));
0052   HFDigi_Token_ = consumes<edm::SortedCollection<HFDataFrame>>(iPSet.getParameter<edm::InputTag>("HCalDigi"));
0053   SiStripSrc_Token_ = consumes<edm::DetSetVector<SiStripDigi>>(iPSet.getParameter<edm::InputTag>("SiStripSrc"));
0054   SiPxlSrc_Token_ = consumes<edm::DetSetVector<PixelDigi>>(iPSet.getParameter<edm::InputTag>("SiPxlSrc"));
0055   MuDTSrc_Token_ = consumes<DTDigiCollection>(iPSet.getParameter<edm::InputTag>("MuDTSrc"));
0056   MuCSCStripSrc_Token_ = consumes<CSCStripDigiCollection>(iPSet.getParameter<edm::InputTag>("MuCSCStripSrc"));
0057   MuCSCWireSrc_Token_ = consumes<CSCWireDigiCollection>(iPSet.getParameter<edm::InputTag>("MuCSCWireSrc"));
0058   //
0059   const std::string barrelHitsName("EcalHitsEB");
0060   const std::string endcapHitsName("EcalHitsEE");
0061   const std::string preshowerHitsName("EcalHitsES");
0062   EBHits_Token_ = consumes<CrossingFrame<PCaloHit>>(edm::InputTag(std::string("mix"), std::string("barrelHitsName")));
0063   EEHits_Token_ = consumes<CrossingFrame<PCaloHit>>(edm::InputTag(std::string("mix"), std::string("endcapHitsName")));
0064   ESHits_Token_ =
0065       consumes<CrossingFrame<PCaloHit>>(edm::InputTag(std::string("mix"), std::string("preshowerHitsName")));
0066 
0067   ecalADCtoGevToken_ = esConsumes();
0068   tTopoToken_ = esConsumes();
0069   hcaldbToken_ = esConsumes();
0070   // use value of first digit to determine default output level (inclusive)
0071   // 0 is none, 1 is basic, 2 is fill output, 3 is gather output
0072   verbosity %= 10;
0073 
0074   // create persistent object
0075   produces<PGlobalDigi>(label);
0076 
0077   // print out Parameter Set information being used
0078   if (verbosity >= 0) {
0079     edm::LogInfo(MsgLoggerCat) << "\n===============================\n"
0080                                << "Initialized as EDProducer with parameter values:\n"
0081                                << "    Name          = " << fName << "\n"
0082                                << "    Verbosity     = " << verbosity << "\n"
0083                                << "    Frequency     = " << frequency << "\n"
0084                                << "    Label         = " << label << "\n"
0085                                << "    GetProv       = " << getAllProvenances << "\n"
0086                                << "    PrintProv     = " << printProvenanceInfo << "\n"
0087                                << "    ECalEBSrc     = " << ECalEBSrc_.label() << ":" << ECalEBSrc_.instance() << "\n"
0088                                << "    ECalEESrc     = " << ECalEESrc_.label() << ":" << ECalEESrc_.instance() << "\n"
0089                                << "    ECalESSrc     = " << ECalESSrc_.label() << ":" << ECalESSrc_.instance() << "\n"
0090                                << "    HCalSrc       = " << HCalSrc_.label() << ":" << HCalSrc_.instance() << "\n"
0091                                << "    HCalDigi       = " << HCalDigi_.label() << ":" << HCalDigi_.instance() << "\n"
0092                                << "    SiStripSrc    = " << SiStripSrc_.label() << ":" << SiStripSrc_.instance() << "\n"
0093                                << "    SiPixelSrc    = " << SiPxlSrc_.label() << ":" << SiPxlSrc_.instance() << "\n"
0094                                << "    MuDTSrc       = " << MuDTSrc_.label() << ":" << MuDTSrc_.instance() << "\n"
0095                                << "    MuCSCStripSrc = " << MuCSCStripSrc_.label() << ":" << MuCSCStripSrc_.instance()
0096                                << "\n"
0097                                << "    MuCSCWireSrc  = " << MuCSCWireSrc_.label() << ":" << MuCSCWireSrc_.instance()
0098                                << "\n"
0099                                << "===============================\n";
0100   }
0101 
0102   // set default constants
0103   // ECal
0104   ECalgainConv_[0] = 0.;
0105   ECalgainConv_[1] = 1.;
0106   ECalgainConv_[2] = 2.;
0107   ECalgainConv_[3] = 12.;
0108   ECalbarrelADCtoGeV_ = 0.035;
0109   ECalendcapADCtoGeV_ = 0.06;
0110 }
0111 
0112 GlobalDigisProducer::~GlobalDigisProducer() {}
0113 
0114 void GlobalDigisProducer::beginJob(void) {
0115   std::string MsgLoggerCat = "GlobalDigisProducer_beginJob";
0116 
0117   EcalMGPAGainRatio *defaultRatios = new EcalMGPAGainRatio();
0118 
0119   ECalgainConv_[0] = 0.;
0120   ECalgainConv_[1] = 1.;
0121   ECalgainConv_[2] = defaultRatios->gain12Over6();
0122   ECalgainConv_[3] = ECalgainConv_[2] * (defaultRatios->gain6Over1());
0123 
0124   delete defaultRatios;
0125 
0126   if (verbosity >= 0) {
0127     edm::LogInfo(MsgLoggerCat) << "Modified Calorimeter gain constants: g0 = " << ECalgainConv_[0]
0128                                << ", g1 = " << ECalgainConv_[1] << ", g2 = " << ECalgainConv_[2]
0129                                << ", g3 = " << ECalgainConv_[3];
0130     //     edm::LogInfo(MsgLoggerCat)
0131     //       << "Modified Calorimeter ADCtoGeV constants: barrel = "
0132     //       << ECalbarrelADCtoGeV_ << ", endcap = " << ECalendcapADCtoGeV_;
0133   }
0134 
0135   // clear storage vectors
0136   clear();
0137   return;
0138 }
0139 
0140 void GlobalDigisProducer::endJob() {
0141   std::string MsgLoggerCat = "GlobalDigisProducer_endJob";
0142   if (verbosity >= 0)
0143     edm::LogInfo(MsgLoggerCat) << "Terminating having processed " << count << " events.";
0144   return;
0145 }
0146 
0147 void GlobalDigisProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0148   std::string MsgLoggerCat = "GlobalDigisProducer_produce";
0149 
0150   // keep track of number of events processed
0151   ++count;
0152 
0153   // THIS BLOCK MIGRATED HERE FROM beginJob:
0154   // setup calorimeter constants from service
0155   const EcalADCToGeVConstant *agc = &iSetup.getData(ecalADCtoGevToken_);
0156   ECalbarrelADCtoGeV_ = agc->getEBValue();
0157   ECalendcapADCtoGeV_ = agc->getEEValue();
0158   if (verbosity >= 0) {
0159     edm::LogInfo(MsgLoggerCat) << "Modified Calorimeter ADCtoGeV constants: barrel = " << ECalbarrelADCtoGeV_
0160                                << ", endcap = " << ECalendcapADCtoGeV_;
0161   }
0162 
0163   // get event id information
0164   edm::RunNumber_t nrun = iEvent.id().run();
0165   edm::EventNumber_t nevt = iEvent.id().event();
0166 
0167   if (verbosity > 0) {
0168     edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count << " events total)";
0169   } else if (verbosity == 0) {
0170     if (nevt % frequency == 0 || nevt == 1) {
0171       edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count
0172                                  << " events total)";
0173     }
0174   }
0175 
0176   // clear event holders
0177   clear();
0178 
0179   // look at information available in the event
0180   if (getAllProvenances) {
0181     std::vector<const edm::StableProvenance *> AllProv;
0182     iEvent.getAllStableProvenance(AllProv);
0183 
0184     if (verbosity >= 0)
0185       edm::LogInfo(MsgLoggerCat) << "Number of Provenances = " << AllProv.size();
0186 
0187     if (printProvenanceInfo && (verbosity >= 0)) {
0188       TString eventout("\nProvenance info:\n");
0189 
0190       for (unsigned int i = 0; i < AllProv.size(); ++i) {
0191         eventout += "\n       ******************************";
0192         eventout += "\n       Module       : ";
0193         // eventout += (AllProv[i]->product).moduleLabel();
0194         eventout += AllProv[i]->moduleLabel();
0195         eventout += "\n       ProductID    : ";
0196         // eventout += (AllProv[i]->product).productID_.id_;
0197         eventout += AllProv[i]->productID().id();
0198         eventout += "\n       ClassName    : ";
0199         // eventout += (AllProv[i]->product).fullClassName_;
0200         eventout += AllProv[i]->className();
0201         eventout += "\n       InstanceName : ";
0202         // eventout += (AllProv[i]->product).productInstanceName_;
0203         eventout += AllProv[i]->productInstanceName();
0204         eventout += "\n       BranchName   : ";
0205         // eventout += (AllProv[i]->product).branchName_;
0206         eventout += AllProv[i]->branchName();
0207       }
0208       eventout += "\n       ******************************\n";
0209       edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0210       printProvenanceInfo = false;
0211     }
0212     getAllProvenances = false;
0213   }
0214 
0215   // call fill functions
0216   // gather Ecal information from event
0217   fillECal(iEvent, iSetup);
0218   // gather Hcal information from event
0219   fillHCal(iEvent, iSetup);
0220   // gather Track information from event
0221   fillTrk(iEvent, iSetup);
0222   // gather Muon information from event
0223   fillMuon(iEvent, iSetup);
0224 
0225   if (verbosity > 0)
0226     edm::LogInfo(MsgLoggerCat) << "Done gathering data from event.";
0227 
0228   // produce object to put into event
0229   std::unique_ptr<PGlobalDigi> pOut(new PGlobalDigi);
0230 
0231   if (verbosity > 2)
0232     edm::LogInfo(MsgLoggerCat) << "Saving event contents:";
0233 
0234   // call store functions
0235   // store ECal information in produce
0236   storeECal(*pOut);
0237   // store HCal information in produce
0238   storeHCal(*pOut);
0239   // store Track information in produce
0240   storeTrk(*pOut);
0241   // store Muon information in produce
0242   storeMuon(*pOut);
0243 
0244   // store information in event
0245   iEvent.put(std::move(pOut), label);
0246 
0247   return;
0248 }
0249 
0250 void GlobalDigisProducer::fillECal(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0251   std::string MsgLoggerCat = "GlobalDigisProducer_fillECal";
0252 
0253   TString eventout;
0254   if (verbosity > 0)
0255     eventout = "\nGathering info:";
0256 
0257   // extract crossing frame from event
0258   // edm::Handle<CrossingFrame> crossingFrame;
0259   edm::Handle<CrossingFrame<PCaloHit>> crossingFrame;
0260   // iEvent.getByType(crossingFrame);
0261   // if (!crossingFrame.isValid()) {
0262   //  edm::LogWarning(MsgLoggerCat)
0263   //    << "Unable to crossingFrame in event!";
0264   //  return;
0265   //}
0266 
0267   ////////////////////////
0268   // extract EB information
0269   ////////////////////////
0270   bool isBarrel = true;
0271   edm::Handle<EBDigiCollection> EcalDigiEB;
0272   iEvent.getByToken(ECalEBSrc_Token_, EcalDigiEB);
0273   if (!EcalDigiEB.isValid()) {
0274     edm::LogWarning(MsgLoggerCat) << "Unable to find EcalDigiEB in event!";
0275     return;
0276   }
0277   if (EcalDigiEB->empty())
0278     isBarrel = false;
0279 
0280   if (isBarrel) {
0281     // loop over simhits
0282     iEvent.getByToken(EBHits_Token_, crossingFrame);
0283     if (!crossingFrame.isValid()) {
0284       edm::LogWarning(MsgLoggerCat) << "Unable to find cal barrel crossingFrame in event!";
0285       return;
0286     }
0287     // std::unique_ptr<MixCollection<PCaloHit> >
0288     // barrelHits(new MixCollection<PCaloHit>
0289     //       (crossingFrame.product(), barrelHitsName));
0290     std::unique_ptr<MixCollection<PCaloHit>> barrelHits(new MixCollection<PCaloHit>(crossingFrame.product()));
0291 
0292     // keep track of sum of simhit energy in each crystal
0293     MapType ebSimMap;
0294     for (MixCollection<PCaloHit>::MixItr hitItr = barrelHits->begin(); hitItr != barrelHits->end(); ++hitItr) {
0295       EBDetId ebid = EBDetId(hitItr->id());
0296 
0297       uint32_t crystid = ebid.rawId();
0298       ebSimMap[crystid] += hitItr->energy();
0299     }
0300 
0301     // loop over digis
0302     const EBDigiCollection *barrelDigi = EcalDigiEB.product();
0303 
0304     std::vector<double> ebAnalogSignal;
0305     std::vector<double> ebADCCounts;
0306     std::vector<double> ebADCGains;
0307     ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES);
0308     ebADCCounts.reserve(EBDataFrame::MAXSAMPLES);
0309     ebADCGains.reserve(EBDataFrame::MAXSAMPLES);
0310 
0311     int i = 0;
0312     for (unsigned int digis = 0; digis < EcalDigiEB->size(); ++digis) {
0313       // for (std::vector<EBDataFrame>::const_iterator digis =
0314       //   barrelDigi->begin();
0315       // digis != barrelDigi->end();
0316       // ++digis) {
0317 
0318       ++i;
0319 
0320       EBDataFrame ebdf = (*barrelDigi)[digis];
0321       int nrSamples = ebdf.size();
0322 
0323       EBDetId ebid = ebdf.id();
0324       // EBDetId ebid = digis->id();
0325 
0326       double Emax = 0;
0327       int Pmax = 0;
0328       double pedestalPreSampleAnalog = 0.;
0329 
0330       for (int sample = 0; sample < nrSamples; ++sample) {
0331         // for (int sample = 0; sample < digis->size(); ++sample) {
0332         ebAnalogSignal[sample] = 0.;
0333         ebADCCounts[sample] = 0.;
0334         ebADCGains[sample] = -1.;
0335       }
0336 
0337       // calculate maximum energy and pedestal
0338       for (int sample = 0; sample < nrSamples; ++sample) {
0339         // for (int sample = 0; sample < digis->size(); ++sample) {
0340 
0341         EcalMGPASample thisSample = ebdf[sample];
0342         ebADCCounts[sample] = (thisSample.adc());
0343         ebADCGains[sample] = (thisSample.gainId());
0344         ebAnalogSignal[sample] = (ebADCCounts[sample] * ECalgainConv_[(int)ebADCGains[sample]] * ECalbarrelADCtoGeV_);
0345         if (Emax < ebAnalogSignal[sample]) {
0346           Emax = ebAnalogSignal[sample];
0347           Pmax = sample;
0348         }
0349         if (sample < 3) {
0350           pedestalPreSampleAnalog += ebADCCounts[sample] * ECalgainConv_[(int)ebADCGains[sample]] * ECalbarrelADCtoGeV_;
0351         }
0352       }
0353       pedestalPreSampleAnalog /= 3.;
0354 
0355       // calculate pedestal subtracted digi energy in the crystal
0356       double Erec = Emax - pedestalPreSampleAnalog * ECalgainConv_[(int)ebADCGains[Pmax]];
0357 
0358       // gather necessary information
0359       EBCalAEE.push_back(Erec);
0360       EBCalSHE.push_back(ebSimMap[ebid.rawId()]);
0361       EBCalmaxPos.push_back(Pmax);
0362     }
0363 
0364     if (verbosity > 1) {
0365       eventout += "\n          Number of EBDigis collected:.............. ";
0366       eventout += i;
0367     }
0368   }
0369 
0370   /////////////////////////
0371   // extract EE information
0372   ////////////////////////
0373   bool isEndCap = true;
0374   edm::Handle<EEDigiCollection> EcalDigiEE;
0375   iEvent.getByToken(ECalEESrc_Token_, EcalDigiEE);
0376   if (!EcalDigiEE.isValid()) {
0377     edm::LogWarning(MsgLoggerCat) << "Unable to find EcalDigiEE in event!";
0378     return;
0379   }
0380   if (EcalDigiEE->empty())
0381     isEndCap = false;
0382 
0383   if (isEndCap) {
0384     // loop over simhits
0385     iEvent.getByToken(EEHits_Token_, crossingFrame);
0386     if (!crossingFrame.isValid()) {
0387       edm::LogWarning(MsgLoggerCat) << "Unable to find cal endcap crossingFrame in event!";
0388       return;
0389     }
0390     // std::unique_ptr<MixCollection<PCaloHit> >
0391     //  endcapHits(new MixCollection<PCaloHit>
0392     //   (crossingFrame.product(), endcapHitsName));
0393     std::unique_ptr<MixCollection<PCaloHit>> endcapHits(new MixCollection<PCaloHit>(crossingFrame.product()));
0394 
0395     // keep track of sum of simhit energy in each crystal
0396     MapType eeSimMap;
0397     for (MixCollection<PCaloHit>::MixItr hitItr = endcapHits->begin(); hitItr != endcapHits->end(); ++hitItr) {
0398       EEDetId eeid = EEDetId(hitItr->id());
0399 
0400       uint32_t crystid = eeid.rawId();
0401       eeSimMap[crystid] += hitItr->energy();
0402     }
0403 
0404     // loop over digis
0405     const EEDigiCollection *endcapDigi = EcalDigiEE.product();
0406 
0407     std::vector<double> eeAnalogSignal;
0408     std::vector<double> eeADCCounts;
0409     std::vector<double> eeADCGains;
0410     eeAnalogSignal.reserve(EEDataFrame::MAXSAMPLES);
0411     eeADCCounts.reserve(EEDataFrame::MAXSAMPLES);
0412     eeADCGains.reserve(EEDataFrame::MAXSAMPLES);
0413 
0414     int i = 0;
0415     // for (std::vector<EEDataFrame>::const_iterator digis =
0416     //   endcapDigi->begin();
0417     // digis != endcapDigi->end();
0418     // ++digis) {
0419     for (unsigned int digis = 0; digis < EcalDigiEE->size(); ++digis) {
0420       ++i;
0421 
0422       EEDataFrame eedf = (*endcapDigi)[digis];
0423       int nrSamples = eedf.size();
0424 
0425       EEDetId eeid = eedf.id();
0426       // EEDetId eeid = digis->id();
0427 
0428       double Emax = 0;
0429       int Pmax = 0;
0430       double pedestalPreSampleAnalog = 0.;
0431 
0432       for (int sample = 0; sample < nrSamples; ++sample) {
0433         // for (int sample = 0; sample < digis->size(); ++sample) {
0434         eeAnalogSignal[sample] = 0.;
0435         eeADCCounts[sample] = 0.;
0436         eeADCGains[sample] = -1.;
0437       }
0438 
0439       // calculate maximum enery and pedestal
0440       for (int sample = 0; sample < nrSamples; ++sample) {
0441         // for (int sample = 0; sample < digis->size(); ++sample) {
0442 
0443         EcalMGPASample thisSample = eedf[sample];
0444 
0445         eeADCCounts[sample] = (thisSample.adc());
0446         eeADCGains[sample] = (thisSample.gainId());
0447         eeAnalogSignal[sample] = (eeADCCounts[sample] * ECalgainConv_[(int)eeADCGains[sample]] * ECalbarrelADCtoGeV_);
0448         if (Emax < eeAnalogSignal[sample]) {
0449           Emax = eeAnalogSignal[sample];
0450           Pmax = sample;
0451         }
0452         if (sample < 3) {
0453           pedestalPreSampleAnalog += eeADCCounts[sample] * ECalgainConv_[(int)eeADCGains[sample]] * ECalbarrelADCtoGeV_;
0454         }
0455       }
0456       pedestalPreSampleAnalog /= 3.;
0457 
0458       // calculate pedestal subtracted digi energy in the crystal
0459       double Erec = Emax - pedestalPreSampleAnalog * ECalgainConv_[(int)eeADCGains[Pmax]];
0460 
0461       // gather necessary information
0462       EECalAEE.push_back(Erec);
0463       EECalSHE.push_back(eeSimMap[eeid.rawId()]);
0464       EECalmaxPos.push_back(Pmax);
0465     }
0466 
0467     if (verbosity > 1) {
0468       eventout += "\n          Number of EEDigis collected:.............. ";
0469       eventout += i;
0470     }
0471   }
0472 
0473   /////////////////////////
0474   // extract ES information
0475   ////////////////////////
0476   bool isPreshower = true;
0477   edm::Handle<ESDigiCollection> EcalDigiES;
0478   iEvent.getByToken(ECalESSrc_Token_, EcalDigiES);
0479   if (!EcalDigiES.isValid()) {
0480     edm::LogWarning(MsgLoggerCat) << "Unable to find EcalDigiES in event!";
0481     return;
0482   }
0483   if (EcalDigiES->empty())
0484     isPreshower = false;
0485 
0486   if (isPreshower) {
0487     // loop over simhits
0488     iEvent.getByToken(ESHits_Token_, crossingFrame);
0489     if (!crossingFrame.isValid()) {
0490       edm::LogWarning(MsgLoggerCat) << "Unable to find cal preshower crossingFrame in event!";
0491       return;
0492     }
0493     // std::unique_ptr<MixCollection<PCaloHit> >
0494     //  preshowerHits(new MixCollection<PCaloHit>
0495     //       (crossingFrame.product(), preshowerHitsName));
0496     std::unique_ptr<MixCollection<PCaloHit>> preshowerHits(new MixCollection<PCaloHit>(crossingFrame.product()));
0497 
0498     // keep track of sum of simhit energy in each crystal
0499     MapType esSimMap;
0500     for (MixCollection<PCaloHit>::MixItr hitItr = preshowerHits->begin(); hitItr != preshowerHits->end(); ++hitItr) {
0501       ESDetId esid = ESDetId(hitItr->id());
0502 
0503       uint32_t crystid = esid.rawId();
0504       esSimMap[crystid] += hitItr->energy();
0505     }
0506 
0507     // loop over digis
0508     const ESDigiCollection *preshowerDigi = EcalDigiES.product();
0509 
0510     std::vector<double> esADCCounts;
0511     esADCCounts.reserve(ESDataFrame::MAXSAMPLES);
0512 
0513     int i = 0;
0514     for (unsigned int digis = 0; digis < EcalDigiES->size(); ++digis) {
0515       // for (std::vector<ESDataFrame>::const_iterator digis =
0516       //   preshowerDigi->begin();
0517       // digis != preshowerDigi->end();
0518       // ++digis) {
0519 
0520       ++i;
0521 
0522       ESDataFrame esdf = (*preshowerDigi)[digis];
0523       int nrSamples = esdf.size();
0524 
0525       ESDetId esid = esdf.id();
0526       // ESDetId esid = digis->id();
0527 
0528       for (int sample = 0; sample < nrSamples; ++sample) {
0529         // for (int sample = 0; sample < digis->size(); ++sample) {
0530         esADCCounts[sample] = 0.;
0531       }
0532 
0533       // gether ADC counts
0534       for (int sample = 0; sample < nrSamples; ++sample) {
0535         ESSample thisSample = esdf[sample];
0536         // for (int sample = 0; sample < digis->size(); ++sample) {
0537         esADCCounts[sample] = (thisSample.adc());
0538       }
0539 
0540       ESCalADC0.push_back(esADCCounts[0]);
0541       ESCalADC1.push_back(esADCCounts[1]);
0542       ESCalADC2.push_back(esADCCounts[2]);
0543       ESCalSHE.push_back(esSimMap[esid.rawId()]);
0544     }
0545 
0546     if (verbosity > 1) {
0547       eventout += "\n          Number of ESDigis collected:.............. ";
0548       eventout += i;
0549     }
0550   }
0551 
0552   if (verbosity > 0)
0553     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0554 
0555   return;
0556 }
0557 
0558 void GlobalDigisProducer::storeECal(PGlobalDigi &product) {
0559   std::string MsgLoggerCat = "GlobalDigisProducer_storeECal";
0560 
0561   if (verbosity > 2) {
0562     TString eventout("\n         nEBDigis     = ");
0563     eventout += EBCalmaxPos.size();
0564     for (unsigned int i = 0; i < EBCalmaxPos.size(); ++i) {
0565       eventout += "\n      (maxPos, AEE, SHE) = (";
0566       eventout += EBCalmaxPos[i];
0567       eventout += ", ";
0568       eventout += EBCalAEE[i];
0569       eventout += ", ";
0570       eventout += EBCalSHE[i];
0571       eventout += ")";
0572     }
0573     eventout += "\n         nEEDigis     = ";
0574     eventout += EECalmaxPos.size();
0575     for (unsigned int i = 0; i < EECalmaxPos.size(); ++i) {
0576       eventout += "\n      (maxPos, AEE, SHE) = (";
0577       eventout += EECalmaxPos[i];
0578       eventout += ", ";
0579       eventout += EECalAEE[i];
0580       eventout += ", ";
0581       eventout += EECalSHE[i];
0582       eventout += ")";
0583     }
0584     eventout += "\n         nESDigis          = ";
0585     eventout += ESCalADC0.size();
0586     for (unsigned int i = 0; i < ESCalADC0.size(); ++i) {
0587       eventout += "\n      (ADC0, ADC1, ADC2, SHE) = (";
0588       eventout += ESCalADC0[i];
0589       eventout += ", ";
0590       eventout += ESCalADC1[i];
0591       eventout += ", ";
0592       eventout += ESCalADC2[i];
0593       eventout += ", ";
0594       eventout += ESCalSHE[i];
0595       eventout += ")";
0596     }
0597     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0598   }
0599 
0600   product.putEBCalDigis(EBCalmaxPos, EBCalAEE, EBCalSHE);
0601   product.putEECalDigis(EECalmaxPos, EECalAEE, EECalSHE);
0602   product.putESCalDigis(ESCalADC0, ESCalADC1, ESCalADC2, ESCalSHE);
0603 
0604   return;
0605 }
0606 
0607 void GlobalDigisProducer::fillHCal(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0608   std::string MsgLoggerCat = "GlobalDigisProducer_fillHCal";
0609 
0610   TString eventout;
0611   if (verbosity > 0)
0612     eventout = "\nGathering info:";
0613 
0614   // get calibration info
0615   const auto &HCalconditions = iSetup.getHandle(hcaldbToken_);
0616   if (!HCalconditions.isValid()) {
0617     edm::LogWarning(MsgLoggerCat) << "Unable to find HCalconditions in event!";
0618     return;
0619   }
0620   // HcalCalibrations calibrations;
0621   CaloSamples tool;
0622 
0623   ///////////////////////
0624   // extract simhit info
0625   //////////////////////
0626   edm::Handle<edm::PCaloHitContainer> hcalHits;
0627   iEvent.getByToken(HCalSrc_Token_, hcalHits);
0628   if (!hcalHits.isValid()) {
0629     edm::LogWarning(MsgLoggerCat) << "Unable to find hcalHits in event!";
0630     return;
0631   }
0632   const edm::PCaloHitContainer *simhitResult = hcalHits.product();
0633 
0634   MapType fHBEnergySimHits;
0635   MapType fHEEnergySimHits;
0636   MapType fHOEnergySimHits;
0637   MapType fHFEnergySimHits;
0638   for (std::vector<PCaloHit>::const_iterator simhits = simhitResult->begin(); simhits != simhitResult->end();
0639        ++simhits) {
0640     HcalDetId detId(simhits->id());
0641     uint32_t cellid = detId.rawId();
0642 
0643     if (detId.subdet() == sdHcalBrl) {
0644       fHBEnergySimHits[cellid] += simhits->energy();
0645     }
0646     if (detId.subdet() == sdHcalEC) {
0647       fHEEnergySimHits[cellid] += simhits->energy();
0648     }
0649     if (detId.subdet() == sdHcalOut) {
0650       fHOEnergySimHits[cellid] += simhits->energy();
0651     }
0652     if (detId.subdet() == sdHcalFwd) {
0653       fHFEnergySimHits[cellid] += simhits->energy();
0654     }
0655   }
0656 
0657   ////////////////////////
0658   // get HBHE information
0659   ///////////////////////
0660   edm::Handle<edm::SortedCollection<HBHEDataFrame>> hbhe;
0661   iEvent.getByToken(HBHEDigi_Token_, hbhe);
0662   if (!hbhe.isValid()) {
0663     edm::LogWarning(MsgLoggerCat) << "Unable to find HBHEDataFrame in event!";
0664     return;
0665   }
0666   edm::SortedCollection<HBHEDataFrame>::const_iterator ihbhe;
0667 
0668   int iHB = 0;
0669   int iHE = 0;
0670   for (ihbhe = hbhe->begin(); ihbhe != hbhe->end(); ++ihbhe) {
0671     HcalDetId cell(ihbhe->id());
0672 
0673     if ((cell.subdet() == sdHcalBrl) || (cell.subdet() == sdHcalEC)) {
0674       // HCalconditions->makeHcalCalibration(cell, &calibrations);
0675       const HcalCalibrations &calibrations = HCalconditions->getHcalCalibrations(cell);
0676       const HcalQIECoder *channelCoder = HCalconditions->getHcalCoder(cell);
0677       const HcalQIEShape *shape = HCalconditions->getHcalShape(channelCoder);
0678 
0679       HcalCoderDb coder(*channelCoder, *shape);
0680       coder.adc2fC(*ihbhe, tool);
0681 
0682       // get HB info
0683       if (cell.subdet() == sdHcalBrl) {
0684         ++iHB;
0685         float fDigiSum = 0.0;
0686         for (int ii = 0; ii < tool.size(); ++ii) {
0687           // default ped is 4.5
0688           int capid = (*ihbhe)[ii].capid();
0689           fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0690         }
0691 
0692         HBCalAEE.push_back(fDigiSum);
0693         HBCalSHE.push_back(fHBEnergySimHits[cell.rawId()]);
0694       }
0695 
0696       // get HE info
0697       if (cell.subdet() == sdHcalEC) {
0698         ++iHE;
0699         float fDigiSum = 0.0;
0700         for (int ii = 0; ii < tool.size(); ++ii) {
0701           int capid = (*ihbhe)[ii].capid();
0702           fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0703         }
0704 
0705         HECalAEE.push_back(fDigiSum);
0706         HECalSHE.push_back(fHEEnergySimHits[cell.rawId()]);
0707       }
0708     }
0709   }
0710 
0711   if (verbosity > 1) {
0712     eventout += "\n          Number of HBDigis collected:.............. ";
0713     eventout += iHB;
0714   }
0715 
0716   if (verbosity > 1) {
0717     eventout += "\n          Number of HEDigis collected:.............. ";
0718     eventout += iHE;
0719   }
0720 
0721   ////////////////////////
0722   // get HO information
0723   ///////////////////////
0724   edm::Handle<edm::SortedCollection<HODataFrame>> ho;
0725   iEvent.getByToken(HODigi_Token_, ho);
0726   if (!ho.isValid()) {
0727     edm::LogWarning(MsgLoggerCat) << "Unable to find HODataFrame in event!";
0728     return;
0729   }
0730   edm::SortedCollection<HODataFrame>::const_iterator iho;
0731 
0732   int iHO = 0;
0733   for (iho = ho->begin(); iho != ho->end(); ++iho) {
0734     HcalDetId cell(iho->id());
0735 
0736     if (cell.subdet() == sdHcalOut) {
0737       // HCalconditions->makeHcalCalibration(cell, &calibrations);
0738       const HcalCalibrations &calibrations = HCalconditions->getHcalCalibrations(cell);
0739       const HcalQIECoder *channelCoder = HCalconditions->getHcalCoder(cell);
0740       const HcalQIEShape *shape = HCalconditions->getHcalShape(channelCoder);
0741 
0742       HcalCoderDb coder(*channelCoder, *shape);
0743       coder.adc2fC(*iho, tool);
0744 
0745       ++iHO;
0746       float fDigiSum = 0.0;
0747       for (int ii = 0; ii < tool.size(); ++ii) {
0748         // default ped is 4.5
0749         int capid = (*iho)[ii].capid();
0750         fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0751       }
0752 
0753       HOCalAEE.push_back(fDigiSum);
0754       HOCalSHE.push_back(fHOEnergySimHits[cell.rawId()]);
0755     }
0756   }
0757 
0758   if (verbosity > 1) {
0759     eventout += "\n          Number of HODigis collected:.............. ";
0760     eventout += iHO;
0761   }
0762 
0763   ////////////////////////
0764   // get HF information
0765   ///////////////////////
0766   edm::Handle<edm::SortedCollection<HFDataFrame>> hf;
0767   iEvent.getByToken(HFDigi_Token_, hf);
0768   if (!hf.isValid()) {
0769     edm::LogWarning(MsgLoggerCat) << "Unable to find HFDataFrame in event!";
0770     return;
0771   }
0772   edm::SortedCollection<HFDataFrame>::const_iterator ihf;
0773 
0774   int iHF = 0;
0775   for (ihf = hf->begin(); ihf != hf->end(); ++ihf) {
0776     HcalDetId cell(ihf->id());
0777 
0778     if (cell.subdet() == sdHcalFwd) {
0779       // HCalconditions->makeHcalCalibration(cell, &calibrations);
0780       const HcalCalibrations &calibrations = HCalconditions->getHcalCalibrations(cell);
0781       const HcalQIECoder *channelCoder = HCalconditions->getHcalCoder(cell);
0782       const HcalQIEShape *shape = HCalconditions->getHcalShape(channelCoder);
0783 
0784       HcalCoderDb coder(*channelCoder, *shape);
0785       coder.adc2fC(*ihf, tool);
0786 
0787       ++iHF;
0788       float fDigiSum = 0.0;
0789       for (int ii = 0; ii < tool.size(); ++ii) {
0790         // default ped is 1.73077
0791         int capid = (*ihf)[ii].capid();
0792         fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0793       }
0794 
0795       HFCalAEE.push_back(fDigiSum);
0796       HFCalSHE.push_back(fHFEnergySimHits[cell.rawId()]);
0797     }
0798   }
0799 
0800   if (verbosity > 1) {
0801     eventout += "\n          Number of HFDigis collected:.............. ";
0802     eventout += iHF;
0803   }
0804 
0805   if (verbosity > 0)
0806     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0807 
0808   return;
0809 }
0810 
0811 void GlobalDigisProducer::storeHCal(PGlobalDigi &product) {
0812   std::string MsgLoggerCat = "GlobalDigisProducer_storeHCal";
0813 
0814   if (verbosity > 2) {
0815     TString eventout("\n         nHBDigis     = ");
0816     eventout += HBCalAEE.size();
0817     for (unsigned int i = 0; i < HBCalAEE.size(); ++i) {
0818       eventout += "\n      (AEE, SHE) = (";
0819       eventout += HBCalAEE[i];
0820       eventout += ", ";
0821       eventout += HBCalSHE[i];
0822       eventout += ")";
0823     }
0824     eventout += "\n         nHEDigis     = ";
0825     eventout += HECalAEE.size();
0826     for (unsigned int i = 0; i < HECalAEE.size(); ++i) {
0827       eventout += "\n      (AEE, SHE) = (";
0828       eventout += HECalAEE[i];
0829       eventout += ", ";
0830       eventout += HECalSHE[i];
0831       eventout += ")";
0832     }
0833     eventout += "\n         nHODigis     = ";
0834     eventout += HOCalAEE.size();
0835     for (unsigned int i = 0; i < HOCalAEE.size(); ++i) {
0836       eventout += "\n      (AEE, SHE) = (";
0837       eventout += HOCalAEE[i];
0838       eventout += ", ";
0839       eventout += HOCalSHE[i];
0840       eventout += ")";
0841     }
0842     eventout += "\n         nHFDigis     = ";
0843     eventout += HFCalAEE.size();
0844     for (unsigned int i = 0; i < HFCalAEE.size(); ++i) {
0845       eventout += "\n      (AEE, SHE) = (";
0846       eventout += HFCalAEE[i];
0847       eventout += ", ";
0848       eventout += HFCalSHE[i];
0849       eventout += ")";
0850     }
0851 
0852     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0853   }
0854 
0855   product.putHBCalDigis(HBCalAEE, HBCalSHE);
0856   product.putHECalDigis(HECalAEE, HECalSHE);
0857   product.putHOCalDigis(HOCalAEE, HOCalSHE);
0858   product.putHFCalDigis(HFCalAEE, HFCalSHE);
0859 
0860   return;
0861 }
0862 
0863 void GlobalDigisProducer::fillTrk(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0864   // Retrieve tracker topology from geometry
0865   const TrackerTopology *const tTopo = &iSetup.getData(tTopoToken_);
0866 
0867   std::string MsgLoggerCat = "GlobalDigisProducer_fillTrk";
0868 
0869   TString eventout;
0870   if (verbosity > 0)
0871     eventout = "\nGathering info:";
0872 
0873   // get strip information
0874   edm::Handle<edm::DetSetVector<SiStripDigi>> stripDigis;
0875   iEvent.getByToken(SiStripSrc_Token_, stripDigis);
0876   if (!stripDigis.isValid()) {
0877     edm::LogWarning(MsgLoggerCat) << "Unable to find stripDigis in event!";
0878     return;
0879   }
0880 
0881   int nStripBrl = 0, nStripFwd = 0;
0882   edm::DetSetVector<SiStripDigi>::const_iterator DSViter;
0883   for (DSViter = stripDigis->begin(); DSViter != stripDigis->end(); ++DSViter) {
0884     unsigned int id = DSViter->id;
0885     DetId detId(id);
0886     edm::DetSet<SiStripDigi>::const_iterator begin = DSViter->data.begin();
0887     edm::DetSet<SiStripDigi>::const_iterator end = DSViter->data.end();
0888     edm::DetSet<SiStripDigi>::const_iterator iter;
0889 
0890     // get TIB
0891     if (detId.subdetId() == sdSiTIB) {
0892       for (iter = begin; iter != end; ++iter) {
0893         ++nStripBrl;
0894         if (tTopo->tibLayer(id) == 1) {
0895           TIBL1ADC.push_back((*iter).adc());
0896           TIBL1Strip.push_back((*iter).strip());
0897         }
0898         if (tTopo->tibLayer(id) == 2) {
0899           TIBL2ADC.push_back((*iter).adc());
0900           TIBL2Strip.push_back((*iter).strip());
0901         }
0902         if (tTopo->tibLayer(id) == 3) {
0903           TIBL3ADC.push_back((*iter).adc());
0904           TIBL3Strip.push_back((*iter).strip());
0905         }
0906         if (tTopo->tibLayer(id) == 4) {
0907           TIBL4ADC.push_back((*iter).adc());
0908           TIBL4Strip.push_back((*iter).strip());
0909         }
0910       }
0911     }
0912 
0913     // get TOB
0914     if (detId.subdetId() == sdSiTOB) {
0915       for (iter = begin; iter != end; ++iter) {
0916         ++nStripBrl;
0917         if (tTopo->tobLayer(id) == 1) {
0918           TOBL1ADC.push_back((*iter).adc());
0919           TOBL1Strip.push_back((*iter).strip());
0920         }
0921         if (tTopo->tobLayer(id) == 2) {
0922           TOBL2ADC.push_back((*iter).adc());
0923           TOBL2Strip.push_back((*iter).strip());
0924         }
0925         if (tTopo->tobLayer(id) == 3) {
0926           TOBL3ADC.push_back((*iter).adc());
0927           TOBL3Strip.push_back((*iter).strip());
0928         }
0929         if (tTopo->tobLayer(id) == 4) {
0930           TOBL4ADC.push_back((*iter).adc());
0931           TOBL4Strip.push_back((*iter).strip());
0932         }
0933       }
0934     }
0935 
0936     // get TID
0937     if (detId.subdetId() == sdSiTID) {
0938       for (iter = begin; iter != end; ++iter) {
0939         ++nStripFwd;
0940         if (tTopo->tidWheel(id) == 1) {
0941           TIDW1ADC.push_back((*iter).adc());
0942           TIDW1Strip.push_back((*iter).strip());
0943         }
0944         if (tTopo->tidWheel(id) == 2) {
0945           TIDW2ADC.push_back((*iter).adc());
0946           TIDW2Strip.push_back((*iter).strip());
0947         }
0948         if (tTopo->tidWheel(id) == 3) {
0949           TIDW3ADC.push_back((*iter).adc());
0950           TIDW3Strip.push_back((*iter).strip());
0951         }
0952       }
0953     }
0954 
0955     // get TEC
0956     if (detId.subdetId() == sdSiTEC) {
0957       for (iter = begin; iter != end; ++iter) {
0958         ++nStripFwd;
0959         if (tTopo->tecWheel(id) == 1) {
0960           TECW1ADC.push_back((*iter).adc());
0961           TECW1Strip.push_back((*iter).strip());
0962         }
0963         if (tTopo->tecWheel(id) == 2) {
0964           TECW2ADC.push_back((*iter).adc());
0965           TECW2Strip.push_back((*iter).strip());
0966         }
0967         if (tTopo->tecWheel(id) == 3) {
0968           TECW3ADC.push_back((*iter).adc());
0969           TECW3Strip.push_back((*iter).strip());
0970         }
0971         if (tTopo->tecWheel(id) == 4) {
0972           TECW4ADC.push_back((*iter).adc());
0973           TECW4Strip.push_back((*iter).strip());
0974         }
0975         if (tTopo->tecWheel(id) == 5) {
0976           TECW5ADC.push_back((*iter).adc());
0977           TECW5Strip.push_back((*iter).strip());
0978         }
0979         if (tTopo->tecWheel(id) == 6) {
0980           TECW6ADC.push_back((*iter).adc());
0981           TECW6Strip.push_back((*iter).strip());
0982         }
0983         if (tTopo->tecWheel(id) == 7) {
0984           TECW7ADC.push_back((*iter).adc());
0985           TECW7Strip.push_back((*iter).strip());
0986         }
0987         if (tTopo->tecWheel(id) == 8) {
0988           TECW8ADC.push_back((*iter).adc());
0989           TECW8Strip.push_back((*iter).strip());
0990         }
0991       }
0992     }
0993   }  // end loop over DataSetVector
0994 
0995   if (verbosity > 1) {
0996     eventout += "\n          Number of BrlStripDigis collected:........ ";
0997     eventout += nStripBrl;
0998   }
0999 
1000   if (verbosity > 1) {
1001     eventout += "\n          Number of FrwdStripDigis collected:....... ";
1002     eventout += nStripFwd;
1003   }
1004 
1005   // get pixel information
1006   edm::Handle<edm::DetSetVector<PixelDigi>> pixelDigis;
1007   iEvent.getByToken(SiPxlSrc_Token_, pixelDigis);
1008   if (!pixelDigis.isValid()) {
1009     edm::LogWarning(MsgLoggerCat) << "Unable to find pixelDigis in event!";
1010     return;
1011   }
1012 
1013   int nPxlBrl = 0, nPxlFwd = 0;
1014   edm::DetSetVector<PixelDigi>::const_iterator DPViter;
1015   for (DPViter = pixelDigis->begin(); DPViter != pixelDigis->end(); ++DPViter) {
1016     unsigned int id = DPViter->id;
1017     DetId detId(id);
1018     edm::DetSet<PixelDigi>::const_iterator begin = DPViter->data.begin();
1019     edm::DetSet<PixelDigi>::const_iterator end = DPViter->data.end();
1020     edm::DetSet<PixelDigi>::const_iterator iter;
1021 
1022     // get Barrel pixels
1023     if (detId.subdetId() == sdPxlBrl) {
1024       for (iter = begin; iter != end; ++iter) {
1025         ++nPxlBrl;
1026         if (tTopo->pxbLayer(id) == 1) {
1027           BRL1ADC.push_back((*iter).adc());
1028           BRL1Row.push_back((*iter).row());
1029           BRL1Col.push_back((*iter).column());
1030         }
1031         if (tTopo->pxbLayer(id) == 2) {
1032           BRL2ADC.push_back((*iter).adc());
1033           BRL2Row.push_back((*iter).row());
1034           BRL2Col.push_back((*iter).column());
1035         }
1036         if (tTopo->pxbLayer(id) == 3) {
1037           BRL3ADC.push_back((*iter).adc());
1038           BRL3Row.push_back((*iter).row());
1039           BRL3Col.push_back((*iter).column());
1040         }
1041       }
1042     }
1043 
1044     // get Forward pixels
1045     if (detId.subdetId() == sdPxlFwd) {
1046       for (iter = begin; iter != end; ++iter) {
1047         ++nPxlFwd;
1048         if (tTopo->pxfDisk(id) == 1) {
1049           if (tTopo->pxfSide(id) == 1) {
1050             FWD1nADC.push_back((*iter).adc());
1051             FWD1nRow.push_back((*iter).row());
1052             FWD1nCol.push_back((*iter).column());
1053           }
1054           if (tTopo->pxfSide(id) == 2) {
1055             FWD1pADC.push_back((*iter).adc());
1056             FWD1pRow.push_back((*iter).row());
1057             FWD1pCol.push_back((*iter).column());
1058           }
1059         }
1060         if (tTopo->pxfDisk(id) == 2) {
1061           if (tTopo->pxfSide(id) == 1) {
1062             FWD2nADC.push_back((*iter).adc());
1063             FWD2nRow.push_back((*iter).row());
1064             FWD2nCol.push_back((*iter).column());
1065           }
1066           if (tTopo->pxfSide(id) == 2) {
1067             FWD2pADC.push_back((*iter).adc());
1068             FWD2pRow.push_back((*iter).row());
1069             FWD2pCol.push_back((*iter).column());
1070           }
1071         }
1072       }
1073     }
1074   }
1075 
1076   if (verbosity > 1) {
1077     eventout += "\n          Number of BrlPixelDigis collected:........ ";
1078     eventout += nPxlBrl;
1079   }
1080 
1081   if (verbosity > 1) {
1082     eventout += "\n          Number of FrwdPixelDigis collected:....... ";
1083     eventout += nPxlFwd;
1084   }
1085 
1086   if (verbosity > 0)
1087     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1088 
1089   return;
1090 }
1091 
1092 void GlobalDigisProducer::storeTrk(PGlobalDigi &product) {
1093   std::string MsgLoggerCat = "GlobalDigisProducer_storeTrk";
1094 
1095   if (verbosity > 2) {
1096     // strip output
1097     TString eventout("\n         nTIBL1     = ");
1098     eventout += TIBL1ADC.size();
1099     for (unsigned int i = 0; i < TIBL1ADC.size(); ++i) {
1100       eventout += "\n      (ADC, strip) = (";
1101       eventout += TIBL1ADC[i];
1102       eventout += ", ";
1103       eventout += TIBL1Strip[i];
1104       eventout += ")";
1105     }
1106     eventout += "\n         nTIBL2     = ";
1107     eventout += TIBL2ADC.size();
1108     for (unsigned int i = 0; i < TIBL2ADC.size(); ++i) {
1109       eventout += "\n      (ADC, strip) = (";
1110       eventout += TIBL2ADC[i];
1111       eventout += ", ";
1112       eventout += TIBL2Strip[i];
1113       eventout += ")";
1114     }
1115     eventout += "\n         nTIBL3     = ";
1116     eventout += TIBL3ADC.size();
1117     for (unsigned int i = 0; i < TIBL3ADC.size(); ++i) {
1118       eventout += "\n      (ADC, strip) = (";
1119       eventout += TIBL3ADC[i];
1120       eventout += ", ";
1121       eventout += TIBL3Strip[i];
1122       eventout += ")";
1123     }
1124     eventout += "\n         nTIBL4     = ";
1125     eventout += TIBL4ADC.size();
1126     for (unsigned int i = 0; i < TIBL4ADC.size(); ++i) {
1127       eventout += "\n      (ADC, strip) = (";
1128       eventout += TIBL4ADC[i];
1129       eventout += ", ";
1130       eventout += TIBL4Strip[i];
1131       eventout += ")";
1132     }
1133     eventout += "\n         nTOBL1     = ";
1134     eventout += TOBL1ADC.size();
1135     for (unsigned int i = 0; i < TOBL1ADC.size(); ++i) {
1136       eventout += "\n      (ADC, strip) = (";
1137       eventout += TOBL1ADC[i];
1138       eventout += ", ";
1139       eventout += TOBL1Strip[i];
1140       eventout += ")";
1141     }
1142     eventout += "\n         nTOBL2     = ";
1143     eventout += TOBL2ADC.size();
1144     for (unsigned int i = 0; i < TOBL2ADC.size(); ++i) {
1145       eventout += "\n      (ADC, strip) = (";
1146       eventout += TOBL2ADC[i];
1147       eventout += ", ";
1148       eventout += TOBL2Strip[i];
1149       eventout += ")";
1150     }
1151     eventout += "\n         nTOBL3     = ";
1152     eventout += TOBL3ADC.size();
1153     for (unsigned int i = 0; i < TOBL3ADC.size(); ++i) {
1154       eventout += "\n      (ADC, strip) = (";
1155       eventout += TOBL3ADC[i];
1156       eventout += ", ";
1157       eventout += TOBL3Strip[i];
1158       eventout += ")";
1159     }
1160     eventout += "\n         nTOBL4     = ";
1161     eventout += TOBL4ADC.size();
1162     for (unsigned int i = 0; i < TOBL4ADC.size(); ++i) {
1163       eventout += "\n      (ADC, strip) = (";
1164       eventout += TOBL4ADC[i];
1165       eventout += ", ";
1166       eventout += TOBL4Strip[i];
1167       eventout += ")";
1168     }
1169     eventout += "\n         nTIDW1     = ";
1170     eventout += TIDW1ADC.size();
1171     for (unsigned int i = 0; i < TIDW1ADC.size(); ++i) {
1172       eventout += "\n      (ADC, strip) = (";
1173       eventout += TIDW1ADC[i];
1174       eventout += ", ";
1175       eventout += TIDW1Strip[i];
1176       eventout += ")";
1177     }
1178     eventout += "\n         nTIDW2     = ";
1179     eventout += TIDW2ADC.size();
1180     for (unsigned int i = 0; i < TIDW2ADC.size(); ++i) {
1181       eventout += "\n      (ADC, strip) = (";
1182       eventout += TIDW2ADC[i];
1183       eventout += ", ";
1184       eventout += TIDW2Strip[i];
1185       eventout += ")";
1186     }
1187     eventout += "\n         nTIDW3     = ";
1188     eventout += TIDW3ADC.size();
1189     for (unsigned int i = 0; i < TIDW3ADC.size(); ++i) {
1190       eventout += "\n      (ADC, strip) = (";
1191       eventout += TIDW3ADC[i];
1192       eventout += ", ";
1193       eventout += TIDW3Strip[i];
1194       eventout += ")";
1195     }
1196     eventout += "\n         nTECW1     = ";
1197     eventout += TECW1ADC.size();
1198     for (unsigned int i = 0; i < TECW1ADC.size(); ++i) {
1199       eventout += "\n      (ADC, strip) = (";
1200       eventout += TECW1ADC[i];
1201       eventout += ", ";
1202       eventout += TECW1Strip[i];
1203       eventout += ")";
1204     }
1205     eventout += "\n         nTECW2     = ";
1206     eventout += TECW2ADC.size();
1207     for (unsigned int i = 0; i < TECW2ADC.size(); ++i) {
1208       eventout += "\n      (ADC, strip) = (";
1209       eventout += TECW2ADC[i];
1210       eventout += ", ";
1211       eventout += TECW2Strip[i];
1212       eventout += ")";
1213     }
1214     eventout += "\n         nTECW3     = ";
1215     eventout += TECW3ADC.size();
1216     for (unsigned int i = 0; i < TECW3ADC.size(); ++i) {
1217       eventout += "\n      (ADC, strip) = (";
1218       eventout += TECW3ADC[i];
1219       eventout += ", ";
1220       eventout += TECW3Strip[i];
1221       eventout += ")";
1222     }
1223     eventout += "\n         nTECW4     = ";
1224     eventout += TECW4ADC.size();
1225     for (unsigned int i = 0; i < TECW4ADC.size(); ++i) {
1226       eventout += "\n      (ADC, strip) = (";
1227       eventout += TECW4ADC[i];
1228       eventout += ", ";
1229       eventout += TECW4Strip[i];
1230       eventout += ")";
1231     }
1232     eventout += "\n         nTECW5     = ";
1233     eventout += TECW5ADC.size();
1234     for (unsigned int i = 0; i < TECW5ADC.size(); ++i) {
1235       eventout += "\n      (ADC, strip) = (";
1236       eventout += TECW5ADC[i];
1237       eventout += ", ";
1238       eventout += TECW5Strip[i];
1239       eventout += ")";
1240     }
1241     eventout += "\n         nTECW6     = ";
1242     eventout += TECW6ADC.size();
1243     for (unsigned int i = 0; i < TECW6ADC.size(); ++i) {
1244       eventout += "\n      (ADC, strip) = (";
1245       eventout += TECW6ADC[i];
1246       eventout += ", ";
1247       eventout += TECW6Strip[i];
1248       eventout += ")";
1249     }
1250     eventout += "\n         nTECW7     = ";
1251     eventout += TECW7ADC.size();
1252     for (unsigned int i = 0; i < TECW7ADC.size(); ++i) {
1253       eventout += "\n      (ADC, strip) = (";
1254       eventout += TECW7ADC[i];
1255       eventout += ", ";
1256       eventout += TECW7Strip[i];
1257       eventout += ")";
1258     }
1259     eventout += "\n         nTECW8     = ";
1260     eventout += TECW8ADC.size();
1261     for (unsigned int i = 0; i < TECW8ADC.size(); ++i) {
1262       eventout += "\n      (ADC, strip) = (";
1263       eventout += TECW8ADC[i];
1264       eventout += ", ";
1265       eventout += TECW8Strip[i];
1266       eventout += ")";
1267     }
1268 
1269     // pixel output
1270     eventout += "\n         nBRL1     = ";
1271     eventout += BRL1ADC.size();
1272     for (unsigned int i = 0; i < BRL1ADC.size(); ++i) {
1273       eventout += "\n      (ADC, row, column) = (";
1274       eventout += BRL1ADC[i];
1275       eventout += ", ";
1276       eventout += BRL1Row[i];
1277       eventout += ", ";
1278       eventout += BRL1Col[i];
1279       eventout += ")";
1280     }
1281     eventout += "\n         nBRL2     = ";
1282     eventout += BRL2ADC.size();
1283     for (unsigned int i = 0; i < BRL2ADC.size(); ++i) {
1284       eventout += "\n      (ADC, row, column) = (";
1285       eventout += BRL2ADC[i];
1286       eventout += ", ";
1287       eventout += BRL2Row[i];
1288       eventout += ", ";
1289       eventout += BRL2Col[i];
1290       eventout += ")";
1291     }
1292     eventout += "\n         nBRL3     = ";
1293     eventout += BRL3ADC.size();
1294     for (unsigned int i = 0; i < BRL3ADC.size(); ++i) {
1295       eventout += "\n      (ADC, row, column) = (";
1296       eventout += BRL3ADC[i];
1297       eventout += ", ";
1298       eventout += BRL3Row[i];
1299       eventout += ", ";
1300       eventout += BRL3Col[i];
1301       eventout += ")";
1302     }
1303     eventout += "\n         nFWD1p     = ";
1304     eventout += FWD1pADC.size();
1305     for (unsigned int i = 0; i < FWD1pADC.size(); ++i) {
1306       eventout += "\n      (ADC, row, column) = (";
1307       eventout += FWD1pADC[i];
1308       eventout += ", ";
1309       eventout += FWD1pRow[i];
1310       eventout += ", ";
1311       eventout += FWD1pCol[i];
1312       eventout += ")";
1313     }
1314     eventout += "\n         nFWD1p     = ";
1315     eventout += FWD1nADC.size();
1316     for (unsigned int i = 0; i < FWD1nADC.size(); ++i) {
1317       eventout += "\n      (ADC, row, column) = (";
1318       eventout += FWD1nADC[i];
1319       eventout += ", ";
1320       eventout += FWD1nRow[i];
1321       eventout += ", ";
1322       eventout += FWD1nCol[i];
1323       eventout += ")";
1324     }
1325     eventout += "\n         nFWD1p     = ";
1326     eventout += FWD2pADC.size();
1327     for (unsigned int i = 0; i < FWD2pADC.size(); ++i) {
1328       eventout += "\n      (ADC, row, column) = (";
1329       eventout += FWD2pADC[i];
1330       eventout += ", ";
1331       eventout += FWD2pRow[i];
1332       eventout += ", ";
1333       eventout += FWD2pCol[i];
1334       eventout += ")";
1335     }
1336     eventout += "\n         nFWD2p     = ";
1337     eventout += FWD2nADC.size();
1338     for (unsigned int i = 0; i < FWD2nADC.size(); ++i) {
1339       eventout += "\n      (ADC, row, column) = (";
1340       eventout += FWD2nADC[i];
1341       eventout += ", ";
1342       eventout += FWD2nRow[i];
1343       eventout += ", ";
1344       eventout += FWD2nCol[i];
1345       eventout += ")";
1346     }
1347 
1348     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1349   }
1350 
1351   // strip output
1352   product.putTIBL1Digis(TIBL1ADC, TIBL1Strip);
1353   product.putTIBL2Digis(TIBL2ADC, TIBL2Strip);
1354   product.putTIBL3Digis(TIBL3ADC, TIBL3Strip);
1355   product.putTIBL4Digis(TIBL4ADC, TIBL4Strip);
1356   product.putTOBL1Digis(TOBL1ADC, TOBL1Strip);
1357   product.putTOBL2Digis(TOBL2ADC, TOBL2Strip);
1358   product.putTOBL3Digis(TOBL3ADC, TOBL3Strip);
1359   product.putTOBL4Digis(TOBL4ADC, TOBL4Strip);
1360   product.putTIDW1Digis(TIDW1ADC, TIDW1Strip);
1361   product.putTIDW2Digis(TIDW2ADC, TIDW2Strip);
1362   product.putTIDW3Digis(TIDW3ADC, TIDW3Strip);
1363   product.putTECW1Digis(TECW1ADC, TECW1Strip);
1364   product.putTECW2Digis(TECW2ADC, TECW2Strip);
1365   product.putTECW3Digis(TECW3ADC, TECW3Strip);
1366   product.putTECW4Digis(TECW4ADC, TECW4Strip);
1367   product.putTECW5Digis(TECW5ADC, TECW5Strip);
1368   product.putTECW6Digis(TECW6ADC, TECW6Strip);
1369   product.putTECW7Digis(TECW7ADC, TECW7Strip);
1370   product.putTECW8Digis(TECW8ADC, TECW8Strip);
1371 
1372   // pixel output
1373   product.putBRL1Digis(BRL1ADC, BRL1Row, BRL1Col);
1374   product.putBRL2Digis(BRL2ADC, BRL2Row, BRL2Col);
1375   product.putBRL3Digis(BRL3ADC, BRL3Row, BRL3Col);
1376   product.putFWD1pDigis(FWD1pADC, FWD1pRow, FWD1pCol);
1377   product.putFWD1nDigis(FWD1nADC, FWD1nRow, FWD1nCol);
1378   product.putFWD2pDigis(FWD2pADC, FWD2pRow, FWD2pCol);
1379   product.putFWD2nDigis(FWD2nADC, FWD2nRow, FWD2nCol);
1380 
1381   return;
1382 }
1383 
1384 void GlobalDigisProducer::fillMuon(edm::Event &iEvent, const edm::EventSetup &iSetup) {
1385   std::string MsgLoggerCat = "GlobalDigisProducer_fillMuon";
1386 
1387   TString eventout;
1388   if (verbosity > 0)
1389     eventout = "\nGathering info:";
1390 
1391   // get DT information
1392   edm::Handle<DTDigiCollection> dtDigis;
1393   iEvent.getByToken(MuDTSrc_Token_, dtDigis);
1394   if (!dtDigis.isValid()) {
1395     edm::LogWarning(MsgLoggerCat) << "Unable to find dtDigis in event!";
1396     return;
1397   }
1398 
1399   int nDt = 0;
1400   DTDigiCollection::DigiRangeIterator detUnitIt;
1401   for (detUnitIt = dtDigis->begin(); detUnitIt != dtDigis->end(); ++detUnitIt) {
1402     const DTLayerId &id = (*detUnitIt).first;
1403     const DTDigiCollection::Range &range = (*detUnitIt).second;
1404 
1405     for (DTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1406       ++nDt;
1407 
1408       DTWireId wireId(id, (*digiIt).wire());
1409       if (wireId.station() == 1) {
1410         MB1SLayer.push_back(id.superlayer());
1411         MB1Time.push_back((*digiIt).time());
1412         MB1Layer.push_back(id.layer());
1413       }
1414       if (wireId.station() == 2) {
1415         MB2SLayer.push_back(id.superlayer());
1416         MB2Time.push_back((*digiIt).time());
1417         MB2Layer.push_back(id.layer());
1418       }
1419       if (wireId.station() == 3) {
1420         MB3SLayer.push_back(id.superlayer());
1421         MB3Time.push_back((*digiIt).time());
1422         MB3Layer.push_back(id.layer());
1423       }
1424       if (wireId.station() == 4) {
1425         MB4SLayer.push_back(id.superlayer());
1426         MB4Time.push_back((*digiIt).time());
1427         MB4Layer.push_back(id.layer());
1428       }
1429     }
1430   }
1431 
1432   if (verbosity > 1) {
1433     eventout += "\n          Number of DtMuonDigis collected:.......... ";
1434     eventout += nDt;
1435   }
1436 
1437   // get CSC Strip information
1438   edm::Handle<CSCStripDigiCollection> strips;
1439   iEvent.getByToken(MuCSCStripSrc_Token_, strips);
1440   if (!strips.isValid()) {
1441     edm::LogWarning(MsgLoggerCat) << "Unable to find muon strips in event!";
1442     return;
1443   }
1444 
1445   int nStrips = 0;
1446   for (CSCStripDigiCollection::DigiRangeIterator j = strips->begin(); j != strips->end(); ++j) {
1447     std::vector<CSCStripDigi>::const_iterator digiItr = (*j).second.first;
1448     std::vector<CSCStripDigi>::const_iterator last = (*j).second.second;
1449 
1450     for (; digiItr != last; ++digiItr) {
1451       ++nStrips;
1452 
1453       // average pedestals
1454       std::vector<int> adcCounts = digiItr->getADCCounts();
1455       theCSCStripPedestalSum += adcCounts[0];
1456       theCSCStripPedestalSum += adcCounts[1];
1457       theCSCStripPedestalCount += 2;
1458 
1459       // if there are enough pedestal statistics
1460       if (theCSCStripPedestalCount > 100) {
1461         float pedestal = theCSCStripPedestalSum / theCSCStripPedestalCount;
1462         if (adcCounts[5] > (pedestal + 100))
1463           CSCStripADC.push_back(adcCounts[4] - pedestal);
1464       }
1465     }
1466   }
1467 
1468   if (verbosity > 1) {
1469     eventout += "\n          Number of CSCStripDigis collected:........ ";
1470     eventout += nStrips;
1471   }
1472 
1473   // get CSC Wire information
1474   edm::Handle<CSCWireDigiCollection> wires;
1475   iEvent.getByToken(MuCSCWireSrc_Token_, wires);
1476   if (!wires.isValid()) {
1477     edm::LogWarning(MsgLoggerCat) << "Unable to find muon wires in event!";
1478     return;
1479   }
1480 
1481   int nWires = 0;
1482   for (CSCWireDigiCollection::DigiRangeIterator j = wires->begin(); j != wires->end(); ++j) {
1483     std::vector<CSCWireDigi>::const_iterator digiItr = (*j).second.first;
1484     std::vector<CSCWireDigi>::const_iterator endDigi = (*j).second.second;
1485 
1486     for (; digiItr != endDigi; ++digiItr) {
1487       ++nWires;
1488 
1489       CSCWireTime.push_back(digiItr->getTimeBin());
1490     }
1491   }
1492 
1493   if (verbosity > 1) {
1494     eventout += "\n          Number of CSCWireDigis collected:......... ";
1495     eventout += nWires;
1496   }
1497 
1498   if (verbosity > 0)
1499     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1500 
1501   return;
1502 }
1503 
1504 void GlobalDigisProducer::storeMuon(PGlobalDigi &product) {
1505   std::string MsgLoggerCat = "GlobalDigisProducer_storeMuon";
1506 
1507   if (verbosity > 2) {
1508     // dt output
1509     TString eventout("\n         nMB1     = ");
1510     eventout += MB1SLayer.size();
1511     for (unsigned int i = 0; i < MB1SLayer.size(); ++i) {
1512       eventout += "\n      (slayer, time, layer) = (";
1513       eventout += MB1SLayer[i];
1514       eventout += ", ";
1515       eventout += MB1Time[i];
1516       eventout += ", ";
1517       eventout += MB1Layer[i];
1518       eventout += ")";
1519     }
1520     eventout += "\n         nMB2     = ";
1521     eventout += MB2SLayer.size();
1522     for (unsigned int i = 0; i < MB2SLayer.size(); ++i) {
1523       eventout += "\n      (slayer, time, layer) = (";
1524       eventout += MB2SLayer[i];
1525       eventout += ", ";
1526       eventout += MB2Time[i];
1527       eventout += ", ";
1528       eventout += MB2Layer[i];
1529       eventout += ")";
1530     }
1531     eventout += "\n         nMB3     = ";
1532     eventout += MB3SLayer.size();
1533     for (unsigned int i = 0; i < MB3SLayer.size(); ++i) {
1534       eventout += "\n      (slayer, time, layer) = (";
1535       eventout += MB3SLayer[i];
1536       eventout += ", ";
1537       eventout += MB3Time[i];
1538       eventout += ", ";
1539       eventout += MB3Layer[i];
1540       eventout += ")";
1541     }
1542     eventout += "\n         nMB2     = ";
1543     eventout += MB4SLayer.size();
1544     for (unsigned int i = 0; i < MB4SLayer.size(); ++i) {
1545       eventout += "\n      (slayer, time, layer) = (";
1546       eventout += MB4SLayer[i];
1547       eventout += ", ";
1548       eventout += MB4Time[i];
1549       eventout += ", ";
1550       eventout += MB4Layer[i];
1551       eventout += ")";
1552     }
1553 
1554     // CSC Strip
1555     eventout += "\n         nCSCStrip     = ";
1556     eventout += CSCStripADC.size();
1557     for (unsigned int i = 0; i < CSCStripADC.size(); ++i) {
1558       eventout += "\n      (adc) = (";
1559       eventout += CSCStripADC[i];
1560       eventout += ")";
1561     }
1562 
1563     // CSC Wire
1564     eventout += "\n         nCSCWire     = ";
1565     eventout += CSCWireTime.size();
1566     for (unsigned int i = 0; i < CSCWireTime.size(); ++i) {
1567       eventout += "\n      (time) = (";
1568       eventout += CSCWireTime[i];
1569       eventout += ")";
1570     }
1571 
1572     edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1573   }
1574 
1575   product.putMB1Digis(MB1SLayer, MB1Time, MB1Layer);
1576   product.putMB2Digis(MB2SLayer, MB2Time, MB2Layer);
1577   product.putMB3Digis(MB3SLayer, MB3Time, MB3Layer);
1578   product.putMB4Digis(MB4SLayer, MB4Time, MB4Layer);
1579 
1580   product.putCSCstripDigis(CSCStripADC);
1581 
1582   product.putCSCwireDigis(CSCWireTime);
1583 
1584   return;
1585 }
1586 
1587 void GlobalDigisProducer::clear() {
1588   std::string MsgLoggerCat = "GlobalDigisProducer_clear";
1589 
1590   if (verbosity > 0)
1591     edm::LogInfo(MsgLoggerCat) << "Clearing event holders";
1592 
1593   // reset electromagnetic info
1594   // EE info
1595   EECalmaxPos.clear();
1596   EECalAEE.clear();
1597   EECalSHE.clear();
1598   // EB info
1599   EBCalmaxPos.clear();
1600   EBCalAEE.clear();
1601   EBCalSHE.clear();
1602   // ES info
1603   ESCalADC0.clear();
1604   ESCalADC1.clear();
1605   ESCalADC2.clear();
1606   ESCalSHE.clear();
1607 
1608   // reset HCal Info
1609   HBCalAEE.clear();
1610   HBCalSHE.clear();
1611   HECalAEE.clear();
1612   HECalSHE.clear();
1613   HOCalAEE.clear();
1614   HOCalSHE.clear();
1615   HFCalAEE.clear();
1616   HFCalSHE.clear();
1617 
1618   // reset Track Info
1619   TIBL1ADC.clear();
1620   TIBL2ADC.clear();
1621   TIBL3ADC.clear();
1622   TIBL4ADC.clear();
1623   TIBL1Strip.clear();
1624   TIBL2Strip.clear();
1625   TIBL3Strip.clear();
1626   TIBL4Strip.clear();
1627 
1628   TOBL1ADC.clear();
1629   TOBL2ADC.clear();
1630   TOBL3ADC.clear();
1631   TOBL4ADC.clear();
1632   TOBL1Strip.clear();
1633   TOBL2Strip.clear();
1634   TOBL3Strip.clear();
1635   TOBL4Strip.clear();
1636 
1637   TIDW1ADC.clear();
1638   TIDW2ADC.clear();
1639   TIDW3ADC.clear();
1640   TIDW1Strip.clear();
1641   TIDW2Strip.clear();
1642   TIDW3Strip.clear();
1643 
1644   TECW1ADC.clear();
1645   TECW2ADC.clear();
1646   TECW3ADC.clear();
1647   TECW4ADC.clear();
1648   TECW5ADC.clear();
1649   TECW6ADC.clear();
1650   TECW7ADC.clear();
1651   TECW8ADC.clear();
1652   TECW1Strip.clear();
1653   TECW2Strip.clear();
1654   TECW3Strip.clear();
1655   TECW4Strip.clear();
1656   TECW5Strip.clear();
1657   TECW6Strip.clear();
1658   TECW7Strip.clear();
1659   TECW8Strip.clear();
1660 
1661   BRL1ADC.clear();
1662   BRL1Row.clear();
1663   BRL1Col.clear();
1664   BRL2ADC.clear();
1665   BRL2Row.clear();
1666   BRL2Col.clear();
1667   BRL3ADC.clear();
1668   BRL3Row.clear();
1669   BRL3Col.clear();
1670 
1671   FWD1pADC.clear();
1672   FWD1pRow.clear();
1673   FWD1pCol.clear();
1674   FWD1nADC.clear();
1675   FWD1nRow.clear();
1676   FWD1nCol.clear();
1677   FWD2pADC.clear();
1678   FWD2pRow.clear();
1679   FWD2pCol.clear();
1680   FWD2nADC.clear();
1681   FWD2nRow.clear();
1682   FWD2nCol.clear();
1683 
1684   // muon clear
1685   MB1SLayer.clear();
1686   MB1Time.clear();
1687   MB1Layer.clear();
1688   MB2SLayer.clear();
1689   MB2Time.clear();
1690   MB2Layer.clear();
1691   MB3SLayer.clear();
1692   MB3Time.clear();
1693   MB3Layer.clear();
1694   MB4SLayer.clear();
1695   MB4Time.clear();
1696   MB4Layer.clear();
1697 
1698   CSCStripADC.clear();
1699 
1700   CSCWireTime.clear();
1701 
1702   return;
1703 }
1704 
1705 // define this as a plug-in
1706 // DEFINE_FWK_MODULE(GlobalDigisProducer);
[ 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!