#include <RPCRecHitProducer.h>

Inheritance diagram for RPCRecHitProducer:

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

void	produce (edm::Event &event, const edm::EventSetup &setup) override
	The method which produces the rechits. More...

	RPCRecHitProducer (const edm::ParameterSet &config)
	Constructor. More...

	~RPCRecHitProducer () override
	Destructor. More...

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

Private Types
enum	MaskSource { MaskSource::File, MaskSource::EventSetup }

Private Attributes
enum RPCRecHitProducer::MaskSource	deadSource_

std::vector< RPCDeadStrips::DeadItem >	DeadVec

enum RPCRecHitProducer::MaskSource	maskSource_

std::vector< RPCMaskedStrips::MaskItem >	MaskVec

std::unique_ptr< RPCRecHitBaseAlgo >	theAlgo

std::unique_ptr< RPCDeadStrips >	theRPCDeadStripsObj

const edm::EDGetTokenT< RPCDigiCollection >	theRPCDigiLabel

std::unique_ptr< RPCMaskedStrips >	theRPCMaskedStripsObj

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

Module for RPCRecHit production.

Author: M. Maggim – INFN Bari

Definition at line 19 of file RPCRecHitProducer.h.

Member Enumeration Documentation

enum RPCRecHitProducer::MaskSource

strongprivate

Enumerator
File
EventSetup

Definition at line 47 of file RPCRecHitProducer.h.

47 { File, EventSetup } maskSource_, deadSource_;

RPCRecHitProducer::deadSource_

enum RPCRecHitProducer::MaskSource deadSource_

EventSetup

RPCRecHitProducer::maskSource_

enum RPCRecHitProducer::MaskSource maskSource_

File

Definition: File.h:11

Constructor & Destructor Documentation

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

Constructor.

Definition at line 29 of file RPCRecHitProducer.cc.

References beam_dqm_sourceclient-live_cfg::cerr, HLT_2018_cff::deadSource, deadSource_, DeadVec, EventSetup, beamvalidation::exit(), File, personalPlayback::fp, edm::FileInPath::fullPath(), timingPdfMaker::get, edm::ParameterSet::getParameter(), recoMuon::in, dtResolutionTest_cfi::inputFile, HLT_2018_cff::maskSource, maskSource_, MaskVec, RPCMaskedStrips::MaskItem::rawId, RPCDeadStrips::DeadItem::rawId, AlCaHLTBitMon_QueryRunRegistry::string, RPCDeadStrips::DeadItem::strip, RPCMaskedStrips::MaskItem::strip, theRPCDeadStripsObj, and theRPCMaskedStripsObj.

     : theRPCDigiLabel(consumes<RPCDigiCollection>(config.getParameter<InputTag>("rpcDigiLabel"))),
       // Get the concrete reconstruction algo from the factory
       theAlgo{RPCRecHitAlgoFactory::get()->create(config.getParameter<string>("recAlgo"),
                                                   config.getParameter<ParameterSet>("recAlgoConfig"))},
       maskSource_(MaskSource::EventSetup),
       deadSource_(MaskSource::EventSetup) {
   // Set verbose output
   produces<RPCRecHitCollection>();
 
   // Get masked- and dead-strip information
   theRPCMaskedStripsObj = std::make_unique<RPCMaskedStrips>();
   theRPCDeadStripsObj = std::make_unique<RPCDeadStrips>();
 
   const string maskSource = config.getParameter<std::string>("maskSource");
   if (maskSource == "File") {
     maskSource_ = MaskSource::File;
     edm::FileInPath fp = config.getParameter<edm::FileInPath>("maskvecfile");
     std::ifstream inputFile(fp.fullPath().c_str(), std::ios::in);
     if (!inputFile) {
       std::cerr << "Masked Strips File cannot not be opened" << std::endl;
       exit(1);
     }
     while (inputFile.good()) {
       RPCMaskedStrips::MaskItem Item;
       inputFile >> Item.rawId >> Item.strip;
       if (inputFile.good())
         MaskVec.push_back(Item);
     }
     inputFile.close();
   }
 
   const string deadSource = config.getParameter<std::string>("deadSource");
   if (deadSource == "File") {
     deadSource_ = MaskSource::File;
     edm::FileInPath fp = config.getParameter<edm::FileInPath>("deadvecfile");
     std::ifstream inputFile(fp.fullPath().c_str(), std::ios::in);
     if (!inputFile) {
       std::cerr << "Dead Strips File cannot not be opened" << std::endl;
       exit(1);
     }
     while (inputFile.good()) {
       RPCDeadStrips::DeadItem Item;
       inputFile >> Item.rawId >> Item.strip;
       if (inputFile.good())
         DeadVec.push_back(Item);
     }
     inputFile.close();
   }
 }

RPCRecHitProducer::~RPCRecHitProducer ( )

inlineoverride

Destructor.

Definition at line 25 of file RPCRecHitProducer.h.

References beginRun(), produce(), and singleTopDQM_cfi::setup.

25 {};

Member Function Documentation

void RPCRecHitProducer::beginRun	(	const edm::Run &	r,
		const edm::EventSetup &	setup
	)

override

Definition at line 80 of file RPCRecHitProducer.cc.

References deadSource_, RPCDeadStrips::DeadVec, DeadVec, EventSetup, File, edm::EventSetup::get(), maskSource_, RPCMaskedStrips::MaskVec, MaskVec, edm::ESHandle< T >::product(), RPCMaskedStrips::MaskItem::rawId, RPCDeadStrips::DeadItem::rawId, RPCDeadStrips::DeadItem::strip, RPCMaskedStrips::MaskItem::strip, theRPCDeadStripsObj, and theRPCMaskedStripsObj.

Referenced by ~RPCRecHitProducer().

                                                                             {
   // Getting the masked-strip information
   if (maskSource_ == MaskSource::EventSetup) {
     edm::ESHandle<RPCMaskedStrips> readoutMaskedStrips;
     setup.get<RPCMaskedStripsRcd>().get(readoutMaskedStrips);
     const RPCMaskedStrips* tmp_obj = readoutMaskedStrips.product();
     theRPCMaskedStripsObj->MaskVec = tmp_obj->MaskVec;
     delete tmp_obj;
   } else if (maskSource_ == MaskSource::File) {
     std::vector<RPCMaskedStrips::MaskItem>::iterator posVec;
     for (posVec = MaskVec.begin(); posVec != MaskVec.end(); ++posVec) {
       RPCMaskedStrips::MaskItem Item;
       Item.rawId = (*posVec).rawId;
       Item.strip = (*posVec).strip;
       theRPCMaskedStripsObj->MaskVec.push_back(Item);
     }
   }
 
   // Getting the dead-strip information
   if (deadSource_ == MaskSource::EventSetup) {
     edm::ESHandle<RPCDeadStrips> readoutDeadStrips;
     setup.get<RPCDeadStripsRcd>().get(readoutDeadStrips);
     const RPCDeadStrips* tmp_obj = readoutDeadStrips.product();
     theRPCDeadStripsObj->DeadVec = tmp_obj->DeadVec;
     delete tmp_obj;
   } else if (deadSource_ == MaskSource::File) {
     std::vector<RPCDeadStrips::DeadItem>::iterator posVec;
     for (posVec = DeadVec.begin(); posVec != DeadVec.end(); ++posVec) {
       RPCDeadStrips::DeadItem Item;
       Item.rawId = (*posVec).rawId;
       Item.strip = (*posVec).strip;
       theRPCDeadStripsObj->DeadVec.push_back(Item);
     }
   }
 }

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

override

The method which produces the rechits.

Definition at line 116 of file RPCRecHitProducer.cc.

References edm::OwnVector< T, P >::begin(), edm::OwnVector< T, P >::empty(), edm::OwnVector< T, P >::end(), edm::EventSetup::get(), eostools::move(), FastTimerService_cff::range, DetId::rawId(), FastTrackerRecHitMaskProducer_cfi::recHits, RPCGeometry::roll(), theAlgo, theRPCDeadStripsObj, theRPCDigiLabel, and theRPCMaskedStripsObj.

Referenced by ~RPCRecHitProducer().

                                                                      {
   // Get the RPC Geometry
   ESHandle<RPCGeometry> rpcGeom;
   setup.get<MuonGeometryRecord>().get(rpcGeom);
 
   // Get the digis from the event
   Handle<RPCDigiCollection> digis;
   event.getByToken(theRPCDigiLabel, digis);
 
   // Pass the EventSetup to the algo
   theAlgo->setES(setup);
 
   // Create the pointer to the collection which will store the rechits
   auto recHitCollection = std::make_unique<RPCRecHitCollection>();
 
   // Iterate through all digi collections ordered by LayerId
 
   for (auto rpcdgIt = digis->begin(); rpcdgIt != digis->end(); ++rpcdgIt) {
     // The layerId
     const RPCDetId& rpcId = (*rpcdgIt).first;
 
     // Get the GeomDet from the setup
     const RPCRoll* roll = rpcGeom->roll(rpcId);
     if (roll == nullptr) {
       edm::LogError("BadDigiInput") << "Failed to find RPCRoll for ID " << rpcId;
       continue;
     }
 
     // Get the iterators over the digis associated with this LayerId
     const RPCDigiCollection::Range& range = (*rpcdgIt).second;
 
     // Getting the roll mask, that includes dead strips, for the given RPCDet
     RollMask mask;
     const int rawId = rpcId.rawId();
     for (const auto& tomask : theRPCMaskedStripsObj->MaskVec) {
       if (tomask.rawId == rawId) {
         const int bit = tomask.strip;
         mask.set(bit - 1);
       }
     }
 
     for (const auto& tomask : theRPCDeadStripsObj->DeadVec) {
       if (tomask.rawId == rawId) {
         const int bit = tomask.strip;
         mask.set(bit - 1);
       }
     }
 
     // Call the reconstruction algorithm
     OwnVector<RPCRecHit> recHits = theAlgo->reconstruct(*roll, rpcId, range, mask);
 
     if (!recHits.empty())  //FIXME: is it really needed?
       recHitCollection->put(rpcId, recHits.begin(), recHits.end());
   }
 
   event.put(std::move(recHitCollection));
 }