SiStripFEDEmulatorModule.cc

Go to the documentation of this file.

// Original Author:  Anne-Marie Magnan
//         Created:  2010/01/21
//
 
#include <sstream>
#include <memory>
#include <list>
#include <algorithm>
#include <cassert>
#include <vector>
 
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESWatcher.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Utilities/interface/Exception.h"
 
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/FEDRawData/interface/FEDRawData.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
#include "DataFormats/SiStripCommon/interface/SiStripFedKey.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/SiStripDigi/interface/SiStripRawDigi.h"
#include "DataFormats/SiStripDigi/interface/SiStripProcessedRawDigi.h"
#include "DataFormats/SiStripDigi/interface/SiStripDigi.h"
#include "DataFormats/SiStripCommon/interface/ConstantsForHardwareSystems.h"
 
#include "CondFormats/SiStripObjects/interface/SiStripPedestals.h"
#include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
 
#include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBuffer.h"
 
//for the zero suppression algorithm(s)
#include "RecoLocalTracker/SiStripZeroSuppression/interface/SiStripRawProcessingFactory.h"
#include "RecoLocalTracker/SiStripZeroSuppression/interface/SiStripRawProcessingAlgorithms.h"
 
#include "DQM/SiStripMonitorHardware/interface/SiStripFEDEmulator.h"
#include "DQM/SiStripMonitorHardware/interface/SiStripSpyUtilities.h"
 
using edm::LogError;
using edm::LogInfo;
using edm::LogWarning;
 
namespace sistrip {
 
  //
  // Class declaration
  //
 
  class FEDEmulatorModule : public edm::EDProducer {
  public:
    explicit FEDEmulatorModule(const edm::ParameterSet&);
    ~FEDEmulatorModule() override;
 
  private:
    void produce(edm::Event&, const edm::EventSetup&) override;
    //virtual void endJob();
 
    //tag of spydata collection
    edm::InputTag spyReorderedDigisTag_;
    edm::InputTag spyVirginRawDigisTag_;
    edm::EDGetTokenT<edm::DetSetVector<SiStripRawDigi> > spyReorderedDigisToken_;
    edm::EDGetTokenT<edm::DetSetVector<SiStripRawDigi> > spyVirginRawDigisToken_;
 
    //by fedIndex or module detid
    bool byModule_;
 
    sistrip::FEDEmulator fedEmulator_;
 
    static const char* messageLabel_;
 
    std::unique_ptr<SiStripRawProcessingAlgorithms> algorithms_;  
 
    edm::ESGetToken<SiStripFedCabling, SiStripFedCablingRcd> fedCablingToken_;
    edm::ESGetToken<SiStripPedestals, SiStripPedestalsRcd> pedestalsToken_;
    edm::ESGetToken<SiStripNoises, SiStripNoisesRcd> noisesToken_;
    const SiStripFedCabling* fedCabling_;
    const SiStripPedestals* pedestals_;
    const SiStripNoises* noises_;
 
    edm::ESWatcher<SiStripFedCablingRcd> cablingWatcher_;
    edm::ESWatcher<SiStripPedestalsRcd> pedestalsWatcher_;
    edm::ESWatcher<SiStripNoisesRcd> noisesWatcher_;
    void updateFedCabling(const SiStripFedCablingRcd& rcd);
    void updatePedestals(const SiStripPedestalsRcd& rcd);
    void updateNoises(const SiStripNoisesRcd& rcd);
  };
 
}  // namespace sistrip
 
namespace sistrip {
 
  //
  // Constructors and destructor
  //
  const char* FEDEmulatorModule::messageLabel_ = "SiStripFEDEmulatorModule";
 
  FEDEmulatorModule::FEDEmulatorModule(const edm::ParameterSet& iConfig)
      : spyReorderedDigisTag_(iConfig.getParameter<edm::InputTag>("SpyReorderedDigisTag")),
        spyVirginRawDigisTag_(iConfig.getParameter<edm::InputTag>("SpyVirginRawDigisTag")),
        byModule_(iConfig.getParameter<bool>("ByModule")),
        algorithms_(SiStripRawProcessingFactory::create(iConfig.getParameter<edm::ParameterSet>("Algorithms"),
                                                        consumesCollector())),
        fedCablingToken_(esConsumes<>()),
        pedestalsToken_(esConsumes<>()),
        noisesToken_(esConsumes<>()),
        cablingWatcher_(this, &sistrip::FEDEmulatorModule::updateFedCabling),
        pedestalsWatcher_(this, &sistrip::FEDEmulatorModule::updatePedestals),
        noisesWatcher_(this, &sistrip::FEDEmulatorModule::updateNoises) {
    spyReorderedDigisToken_ = consumes<edm::DetSetVector<SiStripRawDigi> >(spyReorderedDigisTag_);
    spyVirginRawDigisToken_ = consumes<edm::DetSetVector<SiStripRawDigi> >(spyVirginRawDigisTag_);
 
    fedEmulator_.initialise(byModule_);
 
    if (!byModule_) {  //if not by module
      //the medians will be produced by fed id/channel
      produces<std::map<uint32_t, std::vector<uint32_t> > >("Medians");
      produces<edm::DetSetVector<SiStripRawDigi> >("PedestalsOrdered");
      produces<edm::DetSetVector<SiStripProcessedRawDigi> >("NoisesOrdered");
      produces<edm::DetSetVector<SiStripRawDigi> >("PedSubtrDigisOrdered");
      produces<edm::DetSetVector<SiStripRawDigi> >("CMSubtrDigisOrdered");
    } else {  //by module
      produces<edm::DetSetVector<SiStripRawDigi> >("ModulePedestals");
      produces<edm::DetSetVector<SiStripProcessedRawDigi> >("ModuleNoises");
      produces<edm::DetSetVector<SiStripRawDigi> >("PedSubtrModuleDigis");
      produces<std::map<uint32_t, std::vector<uint32_t> > >("ModuleMedians");
      produces<edm::DetSetVector<SiStripRawDigi> >("CMSubtrModuleDigis");
      produces<edm::DetSetVector<SiStripDigi> >("ZSModuleDigis");
    }  //end of by module check
 
  }  //end of FEDEmulatorModule constructor
 
  FEDEmulatorModule::~FEDEmulatorModule() {}
 
  void FEDEmulatorModule::updateFedCabling(const SiStripFedCablingRcd& rcd) {
    fedCabling_ = &rcd.get(fedCablingToken_);
  }
  void FEDEmulatorModule::updatePedestals(const SiStripPedestalsRcd& rcd) { pedestals_ = &rcd.get(pedestalsToken_); }
  void FEDEmulatorModule::updateNoises(const SiStripNoisesRcd& rcd) { noises_ = &rcd.get(noisesToken_); }
 
  // ------------ method called to for each event  ------------
  void FEDEmulatorModule::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
    cablingWatcher_.check(iSetup);
    pedestalsWatcher_.check(iSetup);
    noisesWatcher_.check(iSetup);
 
    //initialise the algorithms object for the zero suppression
    algorithms_->initialize(iSetup);
 
    //retrieve the digis
    edm::Handle<edm::DetSetVector<SiStripRawDigi> > lDigisHandle;
    try {  //to get the digis from the event
      if (!byModule_) {
        iEvent.getByToken(spyReorderedDigisToken_, lDigisHandle);
      } else {  //digis supplied by module
        iEvent.getByToken(spyVirginRawDigisToken_, lDigisHandle);
      }  //end of by module check
    } catch (const cms::Exception& e) {
      std::cout << e.what();
      return;
    }  //end of get digis try
 
    const edm::DetSetVector<SiStripRawDigi>* lInputDigis = lDigisHandle.product();
 
    unsigned int lNDigis = lInputDigis->size();
 
    //define output containers
    //reserve space, will push_back elements
    std::vector<edm::DetSetVector<SiStripRawDigi>::detset> pedsData;
    pedsData.reserve(lNDigis);
    std::vector<edm::DetSetVector<SiStripProcessedRawDigi>::detset> noiseData;
    noiseData.reserve(lNDigis);
    std::vector<edm::DetSetVector<SiStripRawDigi>::detset> pedSubtrData;
    pedSubtrData.reserve(lNDigis);
    std::vector<edm::DetSetVector<SiStripRawDigi>::detset> cmSubtrData;
    cmSubtrData.reserve(lNDigis);
    //zero suppressed contained - no fixed size (could be empty) so no need to reserve elements.
    std::vector<edm::DetSet<SiStripDigi> > zsData;
 
    //this is a map: no reserve/resize
    std::map<uint32_t, std::vector<uint32_t> > medsData;
 
    edm::DetSetVector<SiStripRawDigi>::const_iterator inputChannel = lInputDigis->begin();
 
    for (; inputChannel != lInputDigis->end(); ++inputChannel) {  //loop on input channels
      uint32_t lDetId = inputChannel->detId();                    //either fedIndex or detId
 
      pedsData.push_back(edm::DetSetVector<SiStripRawDigi>::detset(lDetId));
      noiseData.push_back(edm::DetSetVector<SiStripProcessedRawDigi>::detset(lDetId));
      pedSubtrData.push_back(edm::DetSetVector<SiStripRawDigi>::detset(lDetId));
      cmSubtrData.push_back(edm::DetSetVector<SiStripRawDigi>::detset(lDetId));
 
      unsigned int lNStrips = inputChannel->size();
 
      //define output digi containers
      std::vector<SiStripRawDigi>& pedsDetSetData = pedsData.back().data;
      pedsDetSetData.reserve(lNStrips);
      std::vector<SiStripProcessedRawDigi>& noiseDetSetData = noiseData.back().data;
      noiseDetSetData.reserve(lNStrips);
      std::vector<SiStripRawDigi>& pedSubtrDetSetData = pedSubtrData.back().data;
      pedSubtrDetSetData.reserve(lNStrips);
      std::vector<SiStripRawDigi>& cmSubtrDetSetData = cmSubtrData.back().data;
      cmSubtrDetSetData.reserve(lNStrips);
      //zero suppressed - slightly different procedure as not fixed size
      edm::DetSet<SiStripDigi> zsDetSetData(lDetId);
 
      //determine the number of APV pairs in the channel
      uint32_t lNPairs = static_cast<uint32_t>(lNStrips * 1. / sistrip::STRIPS_PER_FEDCH);
      uint32_t lPair = 0;
 
      std::vector<uint32_t> medsDetSetData;
      medsDetSetData.reserve(lNPairs * 2);  //2*number of pairs per module. If not by module, lNPairs = 1...
 
      if (!byModule_) {  //the input is not stored by module
        //need to retrieve the proper detId from cabling
        uint16_t lFedId = 0;
        uint16_t lFedChannel = 0;
        sistrip::SpyUtilities::fedIndex(lDetId, lFedId, lFedChannel);
 
        const FedChannelConnection& lConnection = fedCabling_->fedConnection(lFedId, lFedChannel);
        lDetId = lConnection.detId();
        lNPairs = lConnection.nApvPairs();
        lPair = lConnection.apvPairNumber();
      }  //end of by module check
 
      fedEmulator_.initialiseModule(lDetId, lNPairs, lPair);
 
      //get the pedestal values
      //stored by module in the database
      fedEmulator_.retrievePedestals(pedestals_);  // FIXME maybe move into FEDEmulator then?
      fedEmulator_.retrieveNoises(noises_);
 
      //last option: fill medians from these ped subtr data
      //if want something else, need to call a method to fill
      //the data member medians_ of the class fedEmulator.
      fedEmulator_.subtractPedestals(
          inputChannel, pedsDetSetData, noiseDetSetData, pedSubtrDetSetData, medsDetSetData, true);
 
      fedEmulator_.subtractCM(pedSubtrDetSetData, cmSubtrDetSetData);
 
      //fill the median map
      medsData[inputChannel->detId()] = medsDetSetData;
 
      //zero suppress the digis
      fedEmulator_.zeroSuppress(cmSubtrDetSetData, zsDetSetData, algorithms_);
      if (!zsDetSetData.empty())
        zsData.push_back(zsDetSetData);
 
    }  //loop on input channels
 
    std::unique_ptr<edm::DetSetVector<SiStripRawDigi> > lPeds(new edm::DetSetVector<SiStripRawDigi>(pedsData, true));
    std::unique_ptr<edm::DetSetVector<SiStripProcessedRawDigi> > lNoises(
        new edm::DetSetVector<SiStripProcessedRawDigi>(noiseData, true));
 
    std::unique_ptr<edm::DetSetVector<SiStripRawDigi> > lOutputPedSubtr(
        new edm::DetSetVector<SiStripRawDigi>(pedSubtrData, true));
 
    std::unique_ptr<edm::DetSetVector<SiStripRawDigi> > lOutputCMSubtr(
        new edm::DetSetVector<SiStripRawDigi>(cmSubtrData, true));
 
    std::unique_ptr<std::map<uint32_t, std::vector<uint32_t> > > lMedians(
        new std::map<uint32_t, std::vector<uint32_t> >(medsData));
 
    //zero suppressed digis
    std::unique_ptr<edm::DetSetVector<SiStripDigi> > lOutputZS(new edm::DetSetVector<SiStripDigi>(zsData));
 
    if (!byModule_) {
      iEvent.put(std::move(lMedians), "Medians");
      iEvent.put(std::move(lPeds), "PedestalsOrdered");
      iEvent.put(std::move(lNoises), "NoisesOrdered");
      iEvent.put(std::move(lOutputPedSubtr), "PedSubtrDigisOrdered");
      iEvent.put(std::move(lOutputCMSubtr), "CMSubtrDigisOrdered");
    } else {
      iEvent.put(std::move(lPeds), "ModulePedestals");
      iEvent.put(std::move(lNoises), "ModuleNoises");
      iEvent.put(std::move(lOutputPedSubtr), "PedSubtrModuleDigis");
      iEvent.put(std::move(lMedians), "ModuleMedians");
      iEvent.put(std::move(lOutputCMSubtr), "CMSubtrModuleDigis");
      iEvent.put(std::move(lOutputZS), "ZSModuleDigis");
    }
 
  }  //produce method
}  //namespace sistrip
 
//
// Define as a plug-in
//
 
#include "FWCore/Framework/interface/MakerMacros.h"
typedef sistrip::FEDEmulatorModule SiStripFEDEmulatorModule;
DEFINE_FWK_MODULE(SiStripFEDEmulatorModule);