Project CMSSW displayed by LXR CMSSW_15_1_X_2025-03-26-2300/​SimGeneral/​DataMixingModule/​plugins/​DataMixingMuonWorker.cc	Source navigation Diff markup Identifier search General search
	Version: CMSSW_15_1_X_2025-03-26-2300 CMSSW_15_1_X_2025-03-25-2300 CMSSW_15_1_X_2025-03-24-2300 CMSSW_15_1_X_2025-03-23-2300 CMSSW_15_1_X_2025-03-21-2300 CMSSW_15_1_X_2025-03-20-2300 Revert   Change

File indexing completed on 2024-09-10 02:59:09

 // File: DataMixingMuonWorker.cc
 // Description:  see DataMixingMuonWorker.h
 // Author:  Mike Hildreth, University of Notre Dame
 //
 //--------------------------------------------
 
 #include "DataFormats/Common/interface/Handle.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include <map>
 #include <memory>
 //
 //
 #include "DataMixingMuonWorker.h"
 
 using namespace std;
 
 namespace edm {
 
   // Virtual constructor
 
   DataMixingMuonWorker::DataMixingMuonWorker() {}
 
   // Constructor
   DataMixingMuonWorker::DataMixingMuonWorker(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
       : label_(ps.getParameter<std::string>("Label"))
 
   {
     // get the subdetector names
     //    this->getSubdetectorNames();  //something like this may be useful to
     //    check what we are supposed to do...
 
     // Declare the products to produce
 
     DTDigiTagSig_ = ps.getParameter<edm::InputTag>("DTDigiTagSig");
     RPCDigiTagSig_ = ps.getParameter<edm::InputTag>("RPCDigiTagSig");
 
     CSCstripdigi_collectionSig_ = ps.getParameter<edm::InputTag>("CSCstripdigiCollectionSig");
     CSCwiredigi_collectionSig_ = ps.getParameter<edm::InputTag>("CSCwiredigiCollectionSig");
     CSCCompdigi_collectionSig_ = ps.getParameter<edm::InputTag>("CSCCompdigiCollectionSig");
 
     DTDigiToken_ = iC.consumes<DTDigiCollection>(DTDigiTagSig_);
     CSCStripDigiToken_ = iC.consumes<CSCStripDigiCollection>(CSCstripdigi_collectionSig_);
     CSCWireDigiToken_ = iC.consumes<CSCWireDigiCollection>(CSCwiredigi_collectionSig_);
     CSCCompDigiToken_ = iC.consumes<CSCComparatorDigiCollection>(CSCCompdigi_collectionSig_);
     RPCDigiToken_ = iC.consumes<RPCDigiCollection>(RPCDigiTagSig_);
 
     DTPileInputTag_ = ps.getParameter<edm::InputTag>("DTPileInputTag");
     RPCPileInputTag_ = ps.getParameter<edm::InputTag>("RPCPileInputTag");
     CSCWirePileInputTag_ = ps.getParameter<edm::InputTag>("CSCWirePileInputTag");
     CSCStripPileInputTag_ = ps.getParameter<edm::InputTag>("CSCStripPileInputTag");
     CSCCompPileInputTag_ = ps.getParameter<edm::InputTag>("CSCCompPileInputTag");
 
     DTDigiPToken_ = iC.consumes<DTDigiCollection>(DTPileInputTag_);
     CSCStripDigiPToken_ = iC.consumes<CSCStripDigiCollection>(CSCStripPileInputTag_);
     CSCWireDigiPToken_ = iC.consumes<CSCWireDigiCollection>(CSCWirePileInputTag_);
     CSCCompDigiPToken_ = iC.consumes<CSCComparatorDigiCollection>(CSCCompPileInputTag_);
     RPCDigiPToken_ = iC.consumes<RPCDigiCollection>(RPCPileInputTag_);
 
     // outputs:
 
     DTDigiCollectionDM_ = ps.getParameter<std::string>("DTDigiCollectionDM");
     RPCDigiCollectionDM_ = ps.getParameter<std::string>("RPCDigiCollectionDM");
     CSCStripDigiCollectionDM_ = ps.getParameter<std::string>("CSCStripDigiCollectionDM");
     CSCWireDigiCollectionDM_ = ps.getParameter<std::string>("CSCWireDigiCollectionDM");
     CSCComparatorDigiCollectionDM_ = ps.getParameter<std::string>("CSCComparatorDigiCollectionDM");
   }
 
   // Virtual destructor needed.
   DataMixingMuonWorker::~DataMixingMuonWorker() {}
 
   void DataMixingMuonWorker::addMuonSignals(const edm::Event &e) {
     // fill in maps of hits
 
     LogDebug("DataMixingMuonWorker") << "===============> adding MC signals for " << e.id();
 
     // DT
     //
 
     OurDTDigis_ = new DTDigiCollection();
     Handle<DTDigiCollection> pDTdigis;
 
     // Get the digis from the event
     if (e.getByToken(DTDigiToken_, pDTdigis)) {
       //    LogInfo("DataMixingMuonWorker") << "total # DT Digis: " <<
       //    DTdigis->size();
 
       // Loop over digis, copying them to our own local storage
       const DTDigiCollection *DTdigis = pDTdigis.product();
       DTDigiCollection::DigiRangeIterator DLayerIt;
       for (DLayerIt = DTdigis->begin(); DLayerIt != DTdigis->end(); ++DLayerIt) {
         // The layerId
         const DTLayerId &layerId = (*DLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const DTDigiCollection::Range &range = (*DLayerIt).second;
 
         OurDTDigis_->put(range, layerId);
       }
     }
     // RPC
     //
 
     OurRPCDigis_ = new RPCDigiCollection();
 
     // Get the digis from the event
     Handle<RPCDigiCollection> pRPCdigis;
 
     if (e.getByToken(RPCDigiToken_, pRPCdigis)) {
       // Loop over digis, copying them to our own local storage
 
       const RPCDigiCollection *RPCdigis = pRPCdigis.product();
       RPCDigiCollection::DigiRangeIterator RLayerIt;
       for (RLayerIt = RPCdigis->begin(); RLayerIt != RPCdigis->end(); ++RLayerIt) {
         // The layerId
         const RPCDetId &layerId = (*RLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const RPCDigiCollection::Range &range = (*RLayerIt).second;
 
         OurRPCDigis_->put(range, layerId);
       }
     }
     // CSCStrip
     //
 
     OurCSCStripDigis_ = new CSCStripDigiCollection();
 
     // Get the digis from the event
     Handle<CSCStripDigiCollection> pCSCStripdigis;
 
     if (e.getByToken(CSCStripDigiToken_, pCSCStripdigis)) {
       // if(pCSCStripdigis.isValid() ) { std::cout << "Signal: have CSCStripDigis"
       // << std::endl;} else { std::cout << "Signal: NO CSCStripDigis" <<
       // std::endl;}
 
       // Loop over digis, copying them to our own local storage
 
       const CSCStripDigiCollection *CSCStripdigis = pCSCStripdigis.product();
       CSCStripDigiCollection::DigiRangeIterator CSLayerIt;
       for (CSLayerIt = CSCStripdigis->begin(); CSLayerIt != CSCStripdigis->end(); ++CSLayerIt) {
         // The layerId
         const CSCDetId &layerId = (*CSLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const CSCStripDigiCollection::Range &range = (*CSLayerIt).second;
 
         // std::cout << " Signal CSC layer " << (*CSLayerIt).first << std::endl;
 
         // for(CSCStripDigiCollection::const_iterator dtdigi=range.first;
         // dtdigi!=range.second; dtdigi++){
         //  std::cout << "Digi " << (*dtdigi) << std::endl;
         //}
 
         OurCSCStripDigis_->put(range, layerId);
       }
     }
     // CSCWire
     //
 
     OurCSCWireDigis_ = new CSCWireDigiCollection();
 
     // Get the digis from the event
     Handle<CSCWireDigiCollection> pCSCWiredigis;
 
     if (e.getByToken(CSCWireDigiToken_, pCSCWiredigis)) {
       // if(pCSCWiredigis.isValid() ) { std::cout << "Signal: have CSCWireDigis"
       // << std::endl;} else { std::cout << "Signal: NO CSCWireDigis" <<
       // std::endl;}
 
       // Loop over digis, copying them to our own local storage
 
       const CSCWireDigiCollection *CSCWiredigis = pCSCWiredigis.product();
       CSCWireDigiCollection::DigiRangeIterator CWLayerIt;
       for (CWLayerIt = CSCWiredigis->begin(); CWLayerIt != CSCWiredigis->end(); ++CWLayerIt) {
         // The layerId
         const CSCDetId &layerId = (*CWLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const CSCWireDigiCollection::Range &range = (*CWLayerIt).second;
 
         OurCSCWireDigis_->put(range, layerId);
       }
     }
 
     // CSCComparators
     //
 
     OurCSCComparatorDigis_ = new CSCComparatorDigiCollection();
 
     // Get the digis from the event
     Handle<CSCComparatorDigiCollection> pCSCComparatordigis;
 
     // std::cout << "CSCComp label: " << CSCDigiTagSig_.label() << " " <<
     // CSCCompdigi_collectionSig_.label() << std::endl;
 
     if (e.getByToken(CSCCompDigiToken_, pCSCComparatordigis)) {
       // if(pCSCComparatordigis.isValid() ) { std::cout << "Signal: have
       // CSCComparatorDigis" << std::endl;} else { std::cout << "Signal: NO
       // CSCComparatorDigis" << std::endl;}
 
       // Loop over digis, copying them to our own local storage
 
       const CSCComparatorDigiCollection *CSCComparatordigis = pCSCComparatordigis.product();
       CSCComparatorDigiCollection::DigiRangeIterator CWLayerIt;
       for (CWLayerIt = CSCComparatordigis->begin(); CWLayerIt != CSCComparatordigis->end(); ++CWLayerIt) {
         // The layerId
         const CSCDetId &layerId = (*CWLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const CSCComparatorDigiCollection::Range &range = (*CWLayerIt).second;
 
         OurCSCComparatorDigis_->put(range, layerId);
       }
     }
 
   }  // end of addMuonSignals
 
   void DataMixingMuonWorker::addMuonPileups(const int bcr,
                                             const EventPrincipal *ep,
                                             unsigned int eventNr,
                                             ModuleCallingContext const *mcc) {
     LogDebug("DataMixingMuonWorker") << "\n===============> adding pileups from event  " << ep->id()
                                      << " for bunchcrossing " << bcr;
 
     // fill in maps of hits; same code as addSignals, except now applied to the
     // pileup events
 
     // DT
     //
     // Get the digis from the event
 
     std::shared_ptr<Wrapper<DTDigiCollection> const> DTDigisPTR =
         getProductByTag<DTDigiCollection>(*ep, DTPileInputTag_, mcc);
 
     if (DTDigisPTR) {
       const DTDigiCollection *DTDigis = const_cast<DTDigiCollection *>(DTDigisPTR->product());
 
       DTDigiCollection::DigiRangeIterator DTLayerIt;
       for (DTLayerIt = DTDigis->begin(); DTLayerIt != DTDigis->end(); ++DTLayerIt) {
         // The layerId
         const DTLayerId &layerId = (*DTLayerIt).first;
 
         // Get the iterators over the Digis associated with this LayerId
         const DTDigiCollection::Range &range = (*DTLayerIt).second;
 
         OurDTDigis_->put(range, layerId);
       }
     }
     // RPC
     //
 
     // Get the digis from the event
 
     std::shared_ptr<Wrapper<RPCDigiCollection> const> RPCDigisPTR =
         getProductByTag<RPCDigiCollection>(*ep, RPCPileInputTag_, mcc);
 
     if (RPCDigisPTR) {
       const RPCDigiCollection *RPCDigis = const_cast<RPCDigiCollection *>(RPCDigisPTR->product());
 
       RPCDigiCollection::DigiRangeIterator RPCLayerIt;
       for (RPCLayerIt = RPCDigis->begin(); RPCLayerIt != RPCDigis->end(); ++RPCLayerIt) {
         // The layerId
         const RPCDetId &layerId = (*RPCLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const RPCDigiCollection::Range &range = (*RPCLayerIt).second;
 
         OurRPCDigis_->put(range, layerId);
       }
     }
 
     // CSCStrip
     //
 
     // Get the digis from the event
 
     std::shared_ptr<Wrapper<CSCStripDigiCollection> const> CSCStripDigisPTR =
         getProductByTag<CSCStripDigiCollection>(*ep, CSCStripPileInputTag_, mcc);
 
     if (CSCStripDigisPTR) {
       const CSCStripDigiCollection *CSCStripDigis = const_cast<CSCStripDigiCollection *>(CSCStripDigisPTR->product());
 
       CSCStripDigiCollection::DigiRangeIterator CSCStripLayerIt;
       for (CSCStripLayerIt = CSCStripDigis->begin(); CSCStripLayerIt != CSCStripDigis->end(); ++CSCStripLayerIt) {
         // The layerId
         const CSCDetId &layerId = (*CSCStripLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const CSCStripDigiCollection::Range &range = (*CSCStripLayerIt).second;
 
         // std::cout << " Pileup CSC layer " << (*CSCStripLayerIt).first <<
         // std::endl;
 
         // for(CSCStripDigiCollection::const_iterator dtdigi=range.first;
         // dtdigi!=range.second; dtdigi++){
         //  std::cout << "Digi " << (*dtdigi) << std::endl;
         //  }
 
         OurCSCStripDigis_->put(range, layerId);
       }
     }
 
     // CSCWire
     //
 
     // Get the digis from the event
 
     std::shared_ptr<Wrapper<CSCWireDigiCollection> const> CSCWireDigisPTR =
         getProductByTag<CSCWireDigiCollection>(*ep, CSCWirePileInputTag_, mcc);
 
     if (CSCWireDigisPTR) {
       const CSCWireDigiCollection *CSCWireDigis = const_cast<CSCWireDigiCollection *>(CSCWireDigisPTR->product());
 
       CSCWireDigiCollection::DigiRangeIterator CSCWireLayerIt;
       for (CSCWireLayerIt = CSCWireDigis->begin(); CSCWireLayerIt != CSCWireDigis->end(); ++CSCWireLayerIt) {
         // The layerId
         const CSCDetId &layerId = (*CSCWireLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const CSCWireDigiCollection::Range &range = (*CSCWireLayerIt).second;
 
         OurCSCWireDigis_->put(range, layerId);
       }
     }
 
     // CSCComparators
     //
 
     // Get the digis from the event
 
     std::shared_ptr<Wrapper<CSCComparatorDigiCollection> const> CSCComparatorDigisPTR =
         getProductByTag<CSCComparatorDigiCollection>(*ep, CSCCompPileInputTag_, mcc);
 
     if (CSCComparatorDigisPTR) {
       const CSCComparatorDigiCollection *CSCComparatorDigis =
           const_cast<CSCComparatorDigiCollection *>(CSCComparatorDigisPTR->product());
 
       CSCComparatorDigiCollection::DigiRangeIterator CSCComparatorLayerIt;
       for (CSCComparatorLayerIt = CSCComparatorDigis->begin(); CSCComparatorLayerIt != CSCComparatorDigis->end();
            ++CSCComparatorLayerIt) {
         // The layerId
         const CSCDetId &layerId = (*CSCComparatorLayerIt).first;
 
         // Get the iterators over the digis associated with this LayerId
         const CSCComparatorDigiCollection::Range &range = (*CSCComparatorLayerIt).second;
 
         OurCSCComparatorDigis_->put(range, layerId);
       }
     }
   }
 
   void DataMixingMuonWorker::putMuon(edm::Event &e) {
     // collections of digis to put in the event
     std::unique_ptr<DTDigiCollection> DTDigiMerge(new DTDigiCollection);
     std::unique_ptr<RPCDigiCollection> RPCDigiMerge(new RPCDigiCollection);
     std::unique_ptr<CSCStripDigiCollection> CSCStripDigiMerge(new CSCStripDigiCollection);
     std::unique_ptr<CSCWireDigiCollection> CSCWireDigiMerge(new CSCWireDigiCollection);
     std::unique_ptr<CSCComparatorDigiCollection> CSCComparatorDigiMerge(new CSCComparatorDigiCollection);
 
     // Loop over DT digis, copying them from our own local storage
 
     DTDigiCollection::DigiRangeIterator DLayerIt;
     for (DLayerIt = OurDTDigis_->begin(); DLayerIt != OurDTDigis_->end(); ++DLayerIt) {
       // The layerId
       const DTLayerId &layerId = (*DLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const DTDigiCollection::Range &range = (*DLayerIt).second;
 
       DTDigiMerge->put(range, layerId);
     }
 
     // Loop over RPC digis, copying them from our own local storage
 
     RPCDigiCollection::DigiRangeIterator RLayerIt;
     for (RLayerIt = OurRPCDigis_->begin(); RLayerIt != OurRPCDigis_->end(); ++RLayerIt) {
       // The layerId
       const RPCDetId &layerId = (*RLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const RPCDigiCollection::Range &range = (*RLayerIt).second;
 
       RPCDigiMerge->put(range, layerId);
     }
     // Loop over CSCStrip digis, copying them from our own local storage
 
     CSCStripDigiCollection::DigiRangeIterator CSLayerIt;
     for (CSLayerIt = OurCSCStripDigis_->begin(); CSLayerIt != OurCSCStripDigis_->end(); ++CSLayerIt) {
       // The layerId
       const CSCDetId &layerId = (*CSLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const CSCStripDigiCollection::Range &range = (*CSLayerIt).second;
 
       std::vector<CSCStripDigi> NewDigiList;
 
       std::vector<int> StripList;
       std::vector<CSCStripDigiCollection::const_iterator> StripPointer;
 
       for (CSCStripDigiCollection::const_iterator dtdigi = range.first; dtdigi != range.second; ++dtdigi) {
         // std::cout << "Digi " << (*dtdigi).getStrip() << std::endl;
         StripList.push_back((*dtdigi).getStrip());
         StripPointer.push_back(dtdigi);
       }
 
       int PrevStrip = -1;
       std::vector<int> DuplicateList;
 
       std::vector<CSCStripDigiCollection::const_iterator>::const_iterator StripPtr = StripPointer.begin();
 
       for (std::vector<int>::const_iterator istrip = StripList.begin(); istrip != StripList.end(); ++istrip) {
         const int CurrentStrip = *(istrip);
 
         if (CurrentStrip > PrevStrip) {
           PrevStrip = CurrentStrip;
 
           int dupl_count;
           dupl_count = std::count(StripList.begin(), StripList.end(), CurrentStrip);
           if (dupl_count > 1) {
             std::vector<int>::const_iterator duplicate = istrip;
             ++duplicate;
             std::vector<CSCStripDigiCollection::const_iterator>::const_iterator DuplPointer = StripPtr;
             ++DuplPointer;
             for (; duplicate != StripList.end(); ++duplicate) {
               if ((*duplicate) == CurrentStrip) {
                 //      std::cout << " Duplicate of current " <<
                 // CurrentStrip << " found at " << (duplicate - StripList.begin())
                 //<< std::endl;
 
                 DuplicateList.push_back(CurrentStrip);
 
                 std::vector<int> pileup_adc = (**DuplPointer).getADCCounts();
                 std::vector<int> signal_adc = (**StripPtr).getADCCounts();
 
                 std::vector<int>::const_iterator minplace;
 
                 minplace = std::min_element(pileup_adc.begin(), pileup_adc.end());
 
                 int minvalue = (*minplace);
 
                 std::vector<int> new_adc;
 
                 std::vector<int>::const_iterator newsig = signal_adc.begin();
 
                 for (std::vector<int>::const_iterator ibin = pileup_adc.begin(); ibin != pileup_adc.end(); ++ibin) {
                   new_adc.push_back((*newsig) + (*ibin) - minvalue);
 
                   ++newsig;
                 }
 
                 CSCStripDigi newDigi(CurrentStrip, new_adc);
                 NewDigiList.push_back(newDigi);
               }
               ++DuplPointer;
             }
           } else {
             NewDigiList.push_back(**StripPtr);
           }
         }  // if strips monotonically increasing...  Haven't hit duplicates yet
         else {               // reached end of signal digis, or there was no overlap
           PrevStrip = 1000;  // now into pileup signals, stop looking forward for
                              // duplicates
 
           // check if this digi was in the duplicate list
           int check;
           check = std::count(DuplicateList.begin(), DuplicateList.end(), CurrentStrip);
           if (check == 0)
             NewDigiList.push_back(**StripPtr);
         }
         ++StripPtr;
       }
 
       CSCStripDigiCollection::Range stripRange(NewDigiList.begin(), NewDigiList.end());
 
       CSCStripDigiMerge->put(stripRange, layerId);
     }
     // Loop over CSCStrip digis, copying them from our own local storage
 
     CSCWireDigiCollection::DigiRangeIterator CWLayerIt;
     for (CWLayerIt = OurCSCWireDigis_->begin(); CWLayerIt != OurCSCWireDigis_->end(); ++CWLayerIt) {
       // The layerId
       const CSCDetId &layerId = (*CWLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const CSCWireDigiCollection::Range &range = (*CWLayerIt).second;
 
       CSCWireDigiMerge->put(range, layerId);
     }
 
     // Loop over CSCComparator digis, copying them from our own local storage
 
     CSCComparatorDigiCollection::DigiRangeIterator CCLayerIt;
     for (CCLayerIt = OurCSCComparatorDigis_->begin(); CCLayerIt != OurCSCComparatorDigis_->end(); ++CCLayerIt) {
       // The layerId
       const CSCDetId &layerId = (*CCLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const CSCComparatorDigiCollection::Range &range = (*CCLayerIt).second;
 
       CSCComparatorDigiMerge->put(range, layerId);
     }
 
     // put the collection of recunstructed hits in the event
     //    LogDebug("DataMixingMuonWorker") << "total # DT Merged Digis: " <<
     //    DTDigiMerge->size() ; LogDebug("DataMixingMuonWorker") << "total # RPC
     //    Merged Digis: " << RPCDigiMerge->size() ;
     //    LogDebug("DataMixingMuonWorker") << "total # CSCStrip Merged Digis: " <<
     //    CSCStripDigiMerge->size() ; LogDebug("DataMixingMuonWorker") << "total #
     //    CSCWire Merged Digis: " << CSCWireDigiMerge->size() ;
 
     e.put(std::move(DTDigiMerge));
     e.put(std::move(RPCDigiMerge));
     e.put(std::move(CSCStripDigiMerge), CSCStripDigiCollectionDM_);
     e.put(std::move(CSCWireDigiMerge), CSCWireDigiCollectionDM_);
     e.put(std::move(CSCComparatorDigiMerge), CSCComparatorDigiCollectionDM_);
 
     // clear local storage for this event
     delete OurDTDigis_;
     delete OurRPCDigis_;
     delete OurCSCStripDigis_;
     delete OurCSCWireDigis_;
     delete OurCSCComparatorDigis_;
   }
 
 }  // namespace edm

This page was automatically generated by the 2.2.1 LXR engine. The LXR team