#include <RPCDigiMerger.h>

Inheritance diagram for RPCDigiMerger:

Public Member Functions
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) override

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

	RPCDigiMerger (edm::ParameterSet const &config)

	~RPCDigiMerger () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Protected Attributes
int	bx_maxCPPF_

int	bx_maxOMTF_

int	bx_maxTwinMux_

int	bx_minCPPF_

int	bx_minOMTF_

int	bx_minTwinMux_

edm::EDGetTokenT< RPCDigiCollection >	cppf_token_

edm::EDGetTokenT< RPCDigiCollection >	omtf_token_

edm::EDGetTokenT< RPCDigiCollection >	simRPC_token_

edm::EDGetTokenT< RPCDigiCollection >	twinMux_token_

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

Detailed Description

Definition at line 24 of file RPCDigiMerger.h.

Constructor & Destructor Documentation

RPCDigiMerger::RPCDigiMerger ( edm::ParameterSet const & config )

Definition at line 20 of file RPCDigiMerger.cc.

References cppf_token_, edm::ParameterSet::getParameter(), edm::InputTag::label(), omtf_token_, simRPC_token_, and twinMux_token_.

     : bx_minTwinMux_(config.getParameter<int>("bxMinTwinMux")),
       bx_maxTwinMux_(config.getParameter<int>("bxMaxTwinMux")),
       bx_minOMTF_(config.getParameter<int>("bxMinOMTF")),
       bx_maxOMTF_(config.getParameter<int>("bxMaxOMTF")),
       bx_minCPPF_(config.getParameter<int>("bxMinCPPF")),
       bx_maxCPPF_(config.getParameter<int>("bxMaxCPPF")) {
   produces<RPCDigiCollection>();
   simRPC_token_ = consumes<RPCDigiCollection>(config.getParameter<edm::InputTag>("inputTagSimRPCDigis"));
   // protection against empty InputTag to allow for Data/MC compatibility
   if (not config.getParameter<edm::InputTag>("inputTagTwinMuxDigis").label().empty()) {
     twinMux_token_ = consumes<RPCDigiCollection>(config.getParameter<edm::InputTag>("inputTagTwinMuxDigis"));
   }
   if (not config.getParameter<edm::InputTag>("inputTagOMTFDigis").label().empty()) {
     omtf_token_ = consumes<RPCDigiCollection>(config.getParameter<edm::InputTag>("inputTagOMTFDigis"));
   }
   if (not config.getParameter<edm::InputTag>("inputTagCPPFDigis").label().empty()) {
     cppf_token_ = consumes<RPCDigiCollection>(config.getParameter<edm::InputTag>("inputTagCPPFDigis"));
   }
 }

RPCDigiMerger::~RPCDigiMerger ( )

override

Definition at line 41 of file RPCDigiMerger.cc.

41 {}

Member Function Documentation

void RPCDigiMerger::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	setup
	)

override

Definition at line 60 of file RPCDigiMerger.cc.

60 {}

void RPCDigiMerger::fillDescriptions ( edm::ConfigurationDescriptions & descs )

static

Definition at line 43 of file RPCDigiMerger.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_2018_cff::InputTag.

                                                                         {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("inputTagSimRPCDigis", edm::InputTag("simMuonRPCDigis", ""));
   desc.add<edm::InputTag>("inputTagTwinMuxDigis", edm::InputTag("", ""));
   desc.add<edm::InputTag>("inputTagOMTFDigis", edm::InputTag("", ""));
   desc.add<edm::InputTag>("inputTagCPPFDigis", edm::InputTag("", ""));
   desc.add<edm::InputTag>("InputLabel", edm::InputTag(" "));
   desc.add<int>("bxMinTwinMux", -2);
   desc.add<int>("bxMaxTwinMux", 2);
   desc.add<int>("bxMinOMTF", -3);
   desc.add<int>("bxMaxOMTF", 4);
   desc.add<int>("bxMinCPPF", -2);
   desc.add<int>("bxMaxCPPF", 2);
 
   descs.add("rpcDigiMerger", desc);
 }

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

override

Definition at line 62 of file RPCDigiMerger.cc.

References RPCDigi::bx(), bx_maxCPPF_, bx_maxOMTF_, bx_maxTwinMux_, bx_minCPPF_, bx_minOMTF_, bx_minTwinMux_, cppf_token_, DEFINE_FWK_MODULE, edm::EDGetTokenT< T >::isUninitialized(), eostools::move(), omtf_token_, FastTimerService_cff::range, RPCDetId::region(), RPCDetId::ring(), simRPC_token_, RPCDetId::station(), and twinMux_token_.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                        {
   // Get the digis
   // new RPCDigiCollection
   std::unique_ptr<RPCDigiCollection> rpc_digi_collection(new RPCDigiCollection());
 
   //Check if its Data
   if (not(cppf_token_.isUninitialized() && omtf_token_.isUninitialized() && twinMux_token_.isUninitialized())) {
     // loop over TwinMux digis
     // protection against empty InputTag to allow for Data/MC compatibility
     if (not twinMux_token_.isUninitialized()) {
       Handle<RPCDigiCollection> TwinMux_digis;
       event.getByToken(twinMux_token_, TwinMux_digis);
       for (const auto&& rpcdgIt : (*TwinMux_digis)) {
         // The layerId
         const RPCDetId& rpcId = rpcdgIt.first;
         // Get the iterators over the digis associated with this LayerId
         const RPCDigiCollection::Range& range = rpcdgIt.second;
         rpc_digi_collection->put(range, rpcId);
       }
     }
     // loop over CPPF digis
     // protection against empty InputTag to allow for Data/MC compatibility
     if (not cppf_token_.isUninitialized()) {
       Handle<RPCDigiCollection> CPPF_digis;
       event.getByToken(cppf_token_, CPPF_digis);
       for (const auto&& rpcdgIt : (*CPPF_digis)) {
         // The layerId
         const RPCDetId& rpcId = rpcdgIt.first;
         // Get the iterators over the digis associated with this LayerId
         const RPCDigiCollection::Range& range = rpcdgIt.second;
         rpc_digi_collection->put(range, rpcId);
       }
     }
     // loop over OMTF digis
     // protection against empty InputTag to allow for Data/MC compatibility
     if (not omtf_token_.isUninitialized()) {
       Handle<RPCDigiCollection> OMTF_digis;
       event.getByToken(omtf_token_, OMTF_digis);
       for (const auto& rpcdgIt : (*OMTF_digis)) {
         // The layerId
         const RPCDetId& rpcId = rpcdgIt.first;
         // Get the iterators over the digis associated with this LayerId
         const RPCDigiCollection::Range& range = rpcdgIt.second;
         // accepts only rings: RE-2_R3 ; RE-1_R3 ; RE+1_R3 ; RE+2_R3 ;
         if (((rpcId.region() == -1 || rpcId.region() == 1) && (rpcId.ring() == 3) &&
              (rpcId.station() == 1 || rpcId.station() == 2))) {
           rpc_digi_collection->put(range, rpcId);
         }
       }
     }
   } else {  //its MC
     // SimRPCDigis collection
     Handle<RPCDigiCollection> SimRPC_digis;
     event.getByToken(simRPC_token_, SimRPC_digis);
 
     RPCDetId rpc_det_id;
     std::vector<RPCDigi> local_rpc_digis;
 
     // loop over SimRPC digis
     for (const auto& rpc_digi : (*SimRPC_digis)) {
       // The layerId
       const RPCDetId& rpcId = rpc_digi.first;
       // Get the iterators over the digis associated with this LayerId
       const RPCDigiCollection::Range& range = rpc_digi.second;
 
       if (rpcId != rpc_det_id) {
         if (!local_rpc_digis.empty()) {
           rpc_digi_collection->put(RPCDigiCollection::Range(local_rpc_digis.begin(), local_rpc_digis.end()),
                                    rpc_det_id);
           local_rpc_digis.clear();
         }
         rpc_det_id = rpcId;
       }
       for (std::vector<RPCDigi>::const_iterator id = range.first; id != range.second; id++) {
         const RPCDigi& dit = (*id);
         //Barrel
         if (rpcId.region() == 0) {
           //TwinMux
           if (dit.bx() >= bx_minTwinMux_ && dit.bx() <= bx_maxTwinMux_) {
             local_rpc_digis.push_back(dit);
           }
         }
         //EndCap
         if (rpcId.region() == -1 || rpcId.region() == 1) {
           //OMTF
           if (rpcId.ring() == 3 && (rpcId.station() == 1 || rpcId.station() == 2) && dit.bx() >= bx_minOMTF_ &&
               dit.bx() <= bx_maxOMTF_) {
             local_rpc_digis.push_back(dit);
           }
           //CPPF
           if (((rpcId.ring() == 2) || (rpcId.ring() == 3 && (rpcId.station() == 3 || rpcId.station() == 4))) &&
               (dit.bx() >= bx_minCPPF_ && dit.bx() <= bx_maxCPPF_)) {
             local_rpc_digis.push_back(dit);
           }
         }
       }
     }
     if (!local_rpc_digis.empty()) {
       rpc_digi_collection->put(RPCDigiCollection::Range(local_rpc_digis.begin(), local_rpc_digis.end()), rpc_det_id);
     }
   }
   // "put" into the event
   event.put(std::move(rpc_digi_collection));
 }