SiStripSpyUnpackerModule.cc

Go to the documentation of this file.

/*\ \file SiStripSpyUnpackerModule.cc
 * \brief Source code for the spy unpacking plugin module.
 */

// CMSSW includes
#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/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/MakerMacros.h"

// Needed for the FED cabling
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
#include "CondFormats/SiStripObjects/interface/FedChannelConnection.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"

// Needed for the FED raw data collection
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"

// For the digi stuff.
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/SiStripDigi/interface/SiStripRawDigi.h"

// For the unpacking object.
#include "DQM/SiStripMonitorHardware/interface/SiStripSpyUnpacker.h"
#include "DQM/SiStripMonitorHardware/interface/SiStripSpyUtilities.h"

// Standard includes
#include <memory>
#include <utility>
#include <string>
#include "boost/cstdint.hpp"

namespace sistrip { class SpyUnpacker; class SpyUtilities; }
class SiStripFedCabling;

using edm::LogError;
using edm::LogInfo;


namespace sistrip {

    class SpyUnpackerModule : public edm::EDProducer
    {
      public:
        SpyUnpackerModule( const edm::ParameterSet& );
        ~SpyUnpackerModule() override;
        void produce( edm::Event&, const edm::EventSetup& ) override;
      private:
        static const char* msgLb_;

        // Data members
        //--------------
        // Configuration
        std::vector<uint32_t> fed_ids_;     
        const edm::InputTag productLabel_;  
      edm::EDGetTokenT<FEDRawDataCollection> productToken_;
        const bool allowIncompleteEvents_;  
        const bool storeCounters_;          
        const bool storeScopeRawDigis_;           

        // Unpacking
        SpyUnpacker* unpacker_;      
    
      //utilities for cabling etc...
      SpyUtilities utility_;

    }; // end of SpyUnpackerModule class.

} // end of namespace sistrip.

namespace sistrip {

  const char* SpyUnpackerModule::msgLb_ = "SiStripSpyUnpackerModule";
    
  SpyUnpackerModule::SpyUnpackerModule( const edm::ParameterSet& pset ) :
    fed_ids_( pset.getParameter< std::vector<uint32_t> >("FEDIDs")),
    productLabel_(pset.getParameter<edm::InputTag>("InputProductLabel")),
    allowIncompleteEvents_(pset.getParameter<bool>("AllowIncompleteEvents")),
    storeCounters_(pset.getParameter<bool>("StoreCounters")),
    storeScopeRawDigis_(pset.getParameter<bool>("StoreScopeRawDigis")),
    unpacker_(nullptr)
  {
    productToken_ = consumes<FEDRawDataCollection>(productLabel_);

    if ((fed_ids_.empty())) {
      LogInfo(msgLb_) << "No FED IDs specified, so will try to unpack all FEDs with data" << std::endl;
      fed_ids_.reserve(FEDNumbering::MAXSiStripFEDID-FEDNumbering::MINSiStripFEDID+1);
      for ( uint32_t ifed = FEDNumbering::MINSiStripFEDID; ifed <= FEDNumbering::MAXSiStripFEDID; ifed++ ) {
    fed_ids_.push_back( ifed );    
      }
    } // end of FED ID specified check.
    
    if ( edm::isDebugEnabled() ) LogTrace(msgLb_) << "["<< __func__ << "]:" << " Constructing object...";
    
    unpacker_ = new sistrip::SpyUnpacker(allowIncompleteEvents_);
    
    if (storeScopeRawDigis_) produces< edm::DetSetVector<SiStripRawDigi> >("ScopeRawDigis");
    
    if (storeCounters_) {
      produces< std::vector<uint32_t> >("L1ACount");
      produces< std::vector<uint32_t> >("TotalEventCount");
    }
    
    produces<uint32_t>("GlobalRunNumber");
    
  } // end of SpyUnpackerModule constructor.

  SpyUnpackerModule::~SpyUnpackerModule() {
    if ( unpacker_ ) { delete unpacker_; }
    if ( edm::isDebugEnabled() ) {
      LogTrace("SiStripSpyUnpacker")
    << "[sistrip::SpyUnpackerModule::" << __func__ << "]"
    << " Destructing object...";
    }
  }

  void SpyUnpackerModule::produce( edm::Event& event, const edm::EventSetup& setup ) {
    

    const SiStripFedCabling* lCabling = utility_.getCabling( setup );

    //retrieve FED raw data (by label, which is "source" by default)
    edm::Handle<FEDRawDataCollection> buffers;
    event.getByToken( productToken_, buffers ); 
    
    //create container for digis
    std::unique_ptr< edm::DetSetVector<SiStripRawDigi> > digis(new edm::DetSetVector<SiStripRawDigi>);
    
    //if necessary, create container for event counters
    std::unique_ptr< std::vector<uint32_t> > pTotalCounts(new std::vector<uint32_t>);
    std::unique_ptr< std::vector<uint32_t> > pL1ACounts(new std::vector<uint32_t>);
    //and for run number
    std::unique_ptr<uint32_t> pGlobalRun(new uint32_t);
    //create digis
    // Using FED IDs...
    unpacker_->createDigis(*lCabling, 
               *buffers, 
               digis.get(), 
               fed_ids_, 
               pTotalCounts.get(), 
               pL1ACounts.get(),
               pGlobalRun.get()
               );
    
    // Add digis to event
    if (storeScopeRawDigis_) event.put(std::move(digis), "ScopeRawDigis" );
    
    //add counters to event
    if (storeCounters_) {
      event.put(std::move(pTotalCounts), "TotalEventCount");
      event.put(std::move(pL1ACounts), "L1ACount");
    }

    //add global run to the event
    event.put(std::move(pGlobalRun), "GlobalRunNumber");

  } // end of SpyUnpackerModule::produce method.


} // end of sistrip namespace

typedef sistrip::SpyUnpackerModule SiStripSpyUnpackerModule;
DEFINE_FWK_MODULE(SiStripSpyUnpackerModule);