CSCChamberMasker.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    SimMuon/CSCDigitizer
// Class:      CSCChamberMasker
// 
//
// Original Author:  Nick J. Amin
//         Created:  Mon, 27 Feb 2017 15:12:51 GMT
//
//


// system include files
#include <map>
#include <memory>
#include <string>
#include <iostream>
#include <algorithm>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"

#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Run.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"

#include "FWCore/Framework/interface/MakerMacros.h"

#include "Geometry/Records/interface/MuonGeometryRecord.h"
#include "Geometry/CSCGeometry/interface/CSCGeometry.h"

#include "Geometry/CSCGeometry/interface/CSCChamber.h"
#include "Geometry/CSCGeometry/interface/CSCLayer.h"

#include "DataFormats/CSCDigi/interface/CSCStripDigi.h"
#include "DataFormats/CSCDigi/interface/CSCStripDigiCollection.h"
#include "DataFormats/CSCDigi/interface/CSCWireDigi.h"
#include "DataFormats/CSCDigi/interface/CSCWireDigiCollection.h"
#include "DataFormats/CSCDigi/interface/CSCCLCTDigi.h"
#include "DataFormats/CSCDigi/interface/CSCCLCTDigiCollection.h"
#include "DataFormats/CSCDigi/interface/CSCALCTDigi.h"
#include "DataFormats/CSCDigi/interface/CSCALCTDigiCollection.h"
#include "DataFormats/MuonDetId/interface/CSCDetId.h"
#include "DataFormats/MuonDetId/interface/CSCIndexer.h"

#include "CondFormats/RecoMuonObjects/interface/MuonSystemAging.h"
#include "CondFormats/DataRecord/interface/MuonSystemAgingRcd.h"

#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Utilities/interface/RandomNumberGenerator.h"
#include "CLHEP/Random/RandomEngine.h"


//
// class declaration
//

class CSCChamberMasker : public edm::stream::EDProducer<>
{

public:
  explicit CSCChamberMasker(const edm::ParameterSet&);
  ~CSCChamberMasker();

  static void fillDescriptions(edm::ConfigurationDescriptions&);

private:
  virtual void produce(edm::Event&, const edm::EventSetup&) override;
      
  virtual void beginRun(edm::Run const&, edm::EventSetup const&) override;

  void createMaskedChamberCollection(edm::ESHandle<CSCGeometry> &); 

  template<typename T, typename C = MuonDigiCollection<CSCDetId, T> > 
  void ageDigis(edm::Event & event,
        edm::EDGetTokenT<C> & digiToken,
        CLHEP::HepRandomEngine & randGen, 
        std::unique_ptr<C> & filteredDigis);

  template<typename T, typename C = MuonDigiCollection<CSCDetId, T> > 
  void copyDigis(edm::Event & event,
         edm::EDGetTokenT<C> & digiToken,
         std::unique_ptr<C> & filteredDigis);

  // ----------member data ---------------------------

  edm::EDGetTokenT <CSCStripDigiCollection> m_stripDigiToken;
  edm::EDGetTokenT <CSCWireDigiCollection>  m_wireDigiToken;
  edm::EDGetTokenT <CSCCLCTDigiCollection>  m_clctDigiToken;
  edm::EDGetTokenT <CSCALCTDigiCollection>  m_alctDigiToken;
  std::map<CSCDetId, std::pair<unsigned int,float> > m_CSCEffs;  
  
};

//
// constants, enums and typedefs
//


//
// static data member definitions
//

//
// constructors and destructor
//
CSCChamberMasker::CSCChamberMasker(const edm::ParameterSet& iConfig) 
    :
  m_stripDigiToken(consumes<CSCStripDigiCollection>(iConfig.getParameter<edm::InputTag>("stripDigiTag")) )
  ,m_wireDigiToken(consumes<CSCWireDigiCollection>(iConfig.getParameter<edm::InputTag>("wireDigiTag")) )
  ,m_clctDigiToken(consumes<CSCCLCTDigiCollection>(iConfig.getParameter<edm::InputTag>("clctDigiTag")) )
  ,m_alctDigiToken(consumes<CSCALCTDigiCollection>(iConfig.getParameter<edm::InputTag>("alctDigiTag")) )
{

  produces<CSCStripDigiCollection>("MuonCSCStripDigi");
  produces<CSCWireDigiCollection>("MuonCSCWireDigi");
  produces<CSCCLCTDigiCollection>("MuonCSCCLCTDigi");
  produces<CSCALCTDigiCollection>("MuonCSCALCTDigi");

}


CSCChamberMasker::~CSCChamberMasker()
{
 
}


//
// member functions
//

// ------------ method called to produce the data  ------------
void
CSCChamberMasker::produce(edm::Event& event, const edm::EventSetup& conditions)
{
  
  edm::Service<edm::RandomNumberGenerator> randGenService;
  CLHEP::HepRandomEngine& randGen = randGenService->getEngine(event.streamID());
 
  std::unique_ptr<CSCStripDigiCollection> filteredStripDigis(new CSCStripDigiCollection());
  std::unique_ptr<CSCWireDigiCollection> filteredWireDigis(new CSCWireDigiCollection());
  std::unique_ptr<CSCCLCTDigiCollection> filteredCLCTDigis(new CSCCLCTDigiCollection());
  std::unique_ptr<CSCALCTDigiCollection> filteredALCTDigis(new CSCALCTDigiCollection());

  // Handle wire and strip digis
  ageDigis<CSCStripDigi>(event,m_stripDigiToken,randGen,filteredStripDigis);
  ageDigis<CSCWireDigi>(event,m_wireDigiToken,randGen,filteredWireDigis);

  // Don't touch CLCT or ALCT digis
  copyDigis<CSCCLCTDigi>(event,m_clctDigiToken,filteredCLCTDigis);
  copyDigis<CSCALCTDigi>(event,m_alctDigiToken,filteredALCTDigis);

  event.put(std::move(filteredStripDigis), "MuonCSCStripDigi");
  event.put(std::move(filteredWireDigis), "MuonCSCWireDigi");
  event.put(std::move(filteredCLCTDigis), "MuonCSCCLCTDigi");
  event.put(std::move(filteredALCTDigis), "MuonCSCALCTDigi");

}

// ------------ method called to copy digis into aged collection  ------------
template<typename T, typename C> 
void
CSCChamberMasker::copyDigis(edm::Event & event,
                edm::EDGetTokenT<C> & digiToken,
                std::unique_ptr<C> & filteredDigis)
{

  if (!digiToken.isUninitialized())
    {
      edm::Handle<C> digis;
      event.getByToken(digiToken, digis);
      for ( const auto & j : (*digis) ) 
    {
          auto digiItr = j.second.first;
          auto last    = j.second.second;

          CSCDetId const cscDetId = j.first;

          for( ; digiItr != last; ++digiItr) 
        {
              filteredDigis->insertDigi(cscDetId,*digiItr);
        }
    }
    }

}

// ------------ method aging digis------------
template<typename T, typename C> 
void
CSCChamberMasker::ageDigis(edm::Event & event,
               edm::EDGetTokenT<C> & digiToken,
               CLHEP::HepRandomEngine & randGen,
               std::unique_ptr<C> & filteredDigis)
{
    
  if(!digiToken.isUninitialized())
    {
      edm::Handle<C> digis;
      event.getByToken(digiToken, digis);
      
      for ( const auto & j : (*digis) ) 
    {
          auto digiItr = j.second.first;
          auto last    = j.second.second;
      
          CSCDetId const cscDetId = j.first;
      
          // Since lookups are chamber-centric, make new DetId with layer=0
          CSCDetId chId = CSCDetId(cscDetId.endcap(), cscDetId.station(), cscDetId.ring(), cscDetId.chamber(), 0);
      
          for( ; digiItr != last; ++digiItr) {
        
        auto chEffIt = m_CSCEffs.find(chId);
        
        if (chEffIt != m_CSCEffs.end()) 
          {

        std::pair<unsigned int, float> typeEff = chEffIt->second;
        int type = typeEff.first % 10; // second digit gives type of inefficiency
        int layer = typeEff.first/10; // first digit gives layer (0 = chamber level)

        bool doRandomize = false;
        if (((std::is_same<T,CSCStripDigi>::value && type == EFF_WIRES)  || 
             (std::is_same<T,CSCWireDigi>::value && type  == EFF_STRIPS) || 
             type == EFF_CHAMBER) && (layer == 0 || cscDetId.layer() == layer)) doRandomize = true;

                  if (!doRandomize  || (randGen.flat() <= typeEff.second)) {
                      filteredDigis->insertDigi(cscDetId,*digiItr);
          }
              } 

          }
      }
  }
}


// ------------ method called when starting to processes a run  ------------
void
CSCChamberMasker::beginRun(edm::Run const& run, edm::EventSetup const& iSetup)
{

  m_CSCEffs.clear();

  edm::ESHandle<CSCGeometry> cscGeom;
  iSetup.get<MuonGeometryRecord>().get(cscGeom);

  edm::ESHandle<MuonSystemAging> agingObj;
  iSetup.get<MuonSystemAgingRcd>().get(agingObj);

  const auto chambers = cscGeom->chambers();

  for ( const auto * ch : chambers)
  {

      CSCDetId  chId    = ch->id();
      unsigned int rawId = chId.rawIdMaker(chId.endcap(), chId.station(), chId.ring(), chId.chamber(), 0);
      float eff = 1.;
      int type = 0;
      for ( auto & agingPair : agingObj->m_CSCChambEffs)
      {
          if ( agingPair.first != rawId) continue;

          type = agingPair.second.first;
          eff = agingPair.second.second;
          m_CSCEffs[chId] = std::make_pair(type, eff);   
          break;
      }

  }

}

  
// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void
CSCChamberMasker::fillDescriptions(edm::ConfigurationDescriptions& descriptions) 
{

  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("stripDigiTag",      edm::InputTag("simMuonCSCDigis:MuonCSCStripDigi"));
  desc.add<edm::InputTag>("wireDigiTag",       edm::InputTag("simMuonCSCDigis:MuonCSCWireDigi"));
  desc.add<edm::InputTag>("comparatorDigiTag", edm::InputTag("simMuonCSCDigis:MuonCSCComparatorDigi"));
  desc.add<edm::InputTag>("rpcDigiTag",        edm::InputTag("simMuonCSCDigis:MuonCSCRPCDigi"));
  desc.add<edm::InputTag>("alctDigiTag",       edm::InputTag("simMuonCSCDigis:MuonCSCALCTDigi"));
  desc.add<edm::InputTag>("clctDigiTag",       edm::InputTag("simMuonCSCDigis:MuonCSCCLCTDigi"));
  descriptions.add("cscChamberMasker",desc);

}

//define this as a plug-in
DEFINE_FWK_MODULE(CSCChamberMasker);