#include <SimMuon/CSCDigitizer/plugins/CSCChamberMasker.cc>

Inheritance diagram for CSCChamberMasker:

Public Member Functions
	CSCChamberMasker (const edm::ParameterSet &)

	~CSCChamberMasker ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
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)

virtual void	beginRun (edm::Run const &, edm::EventSetup const &) override

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

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

virtual void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::EDGetTokenT< CSCALCTDigiCollection >	m_alctDigiToken

edm::EDGetTokenT< CSCCLCTDigiCollection >	m_clctDigiToken

std::map< CSCDetId, std::pair< unsigned int, float > >	m_CSCEffs

edm::EDGetTokenT< CSCStripDigiCollection >	m_stripDigiToken

edm::EDGetTokenT< CSCWireDigiCollection >	m_wireDigiToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: Class to mask CSC digis on a chamber by chamber basis

Definition at line 69 of file CSCChamberMasker.cc.

Constructor & Destructor Documentation

CSCChamberMasker::CSCChamberMasker ( const edm::ParameterSet & iConfig )

explicit

Definition at line 118 of file CSCChamberMasker.cc.

     :
   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 ( )

Definition at line 134 of file CSCChamberMasker.cc.

 {
  
 }

Member Function Documentation

template<typename T , typename C >

void CSCChamberMasker::ageDigis	(	edm::Event &	event,
		edm::EDGetTokenT< C > &	digiToken,
		CLHEP::HepRandomEngine &	randGen,
		std::unique_ptr< C > &	filteredDigis
	)

private

Definition at line 203 of file CSCChamberMasker.cc.

References CSCDetId::chamber(), EFF_CHAMBER, EFF_STRIPS, EFF_WIRES, CSCDetId::endcap(), edm::EDGetTokenT< T >::isUninitialized(), plotBeamSpotDB::last, CSCDetId::layer(), m_CSCEffs, CSCDetId::ring(), CSCDetId::station(), and relativeConstraints::value.

 {
     
   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);
           }
               } 
 
           }
       }
   }
 }

void CSCChamberMasker::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	iSetup
	)

overrideprivatevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 253 of file CSCChamberMasker.cc.

References CSCDetId::chamber(), CSCGeometry::chambers(), chambers, CSCDetId::endcap(), edm::EventSetup::get(), MuonSystemAging::m_CSCChambEffs, m_CSCEffs, CSCDetId::rawIdMaker(), CSCDetId::ring(), and CSCDetId::station().

 {
 
   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;
       }
 
   }
 
 }

template<typename T , typename C >

void CSCChamberMasker::copyDigis	(	edm::Event &	event,
		edm::EDGetTokenT< C > &	digiToken,
		std::unique_ptr< C > &	filteredDigis
	)

private

Definition at line 175 of file CSCChamberMasker.cc.

References edm::EDGetTokenT< T >::isUninitialized(), and plotBeamSpotDB::last.

 {
 
   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);
         }
     }
     }
 
 }

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

private

void CSCChamberMasker::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 290 of file CSCChamberMasker.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and DEFINE_FWK_MODULE.

 {
 
   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);
 
 }

void CSCChamberMasker::produce	(	edm::Event &	event,
		const edm::EventSetup &	conditions
	)

overrideprivatevirtual

Definition at line 146 of file CSCChamberMasker.cc.

References event(), edm::RandomNumberGenerator::getEngine(), m_alctDigiToken, m_clctDigiToken, m_stripDigiToken, m_wireDigiToken, eostools::move(), and edm::Event::streamID().

 {
   
   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");
 
 }