RPCRecHitProducer Class Reference

#include <RPCRecHitProducer.h>

Inheritance diagram for RPCRecHitProducer:

Public Member Functions
virtual void	beginRun (const edm::Run &, const edm::EventSetup &) override
virtual void	produce (edm::Event &event, const edm::EventSetup &setup) override
	The method which produces the rechits. More...
	RPCRecHitProducer (const edm::ParameterSet &config)
	Constructor. More...
virtual	~RPCRecHitProducer ()
	Destructor. More...
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)

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
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
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
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

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 48 of file RPCRecHitProducer.h.

{ File, EventSetup } maskSource_, deadSource_;

Constructor & Destructor Documentation

RPCRecHitProducer::RPCRecHitProducer

(

const edm::ParameterSet &

config

)

Constructor.

Definition at line 29 of file RPCRecHitProducer.cc.

References MessageLogger_cfi::cerr, beamerCreator::create(), rpcRecHits_cfi::deadSource, deadSource_, DeadVec, cmsRelvalreport::exit, File, edm::FileInPath::fullPath(), reco::get(), edm::ParameterSet::getParameter(), recoMuon::in, analyzePatCleaning_cfg::inputFile, rpcRecHits_cfi::maskSource, maskSource_, MaskVec, RPCMaskedStrips::MaskItem::rawId, RPCDeadStrips::DeadItem::rawId, AlCaHLTBitMon_QueryRunRegistry::string, RPCDeadStrips::DeadItem::strip, RPCMaskedStrips::MaskItem::strip, theAlgo, theRPCDeadStripsObj, and theRPCMaskedStripsObj.

                                                              :
  theRPCDigiLabel(consumes<RPCDigiCollection>(config.getParameter<InputTag>("rpcDigiLabel"))),
  maskSource_(MaskSource::EventSetup), deadSource_(MaskSource::EventSetup)
{
  // Set verbose output
  produces<RPCRecHitCollection>();

  // Get the concrete reconstruction algo from the factory
  const string theAlgoName = config.getParameter<string>("recAlgo");
  theAlgo.reset(RPCRecHitAlgoFactory::get()->create(theAlgoName,
                config.getParameter<ParameterSet>("recAlgoConfig")));

  // 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();
  }
}

virtual RPCRecHitProducer::~RPCRecHitProducer ( )

inlinevirtual

Destructor.

Definition at line 26 of file RPCRecHitProducer.h.

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

{};

Member Function Documentation

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

overridevirtual

Definition at line 81 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  )

overridevirtual

The method which produces the rechits.

Definition at line 120 of file RPCRecHitProducer.cc.

References edm::OwnVector< T, P >::begin(), edm::OwnVector< T, P >::end(), edm::EventSetup::get(), RecoTauDiscriminantConfiguration::mask, eostools::move(), DetId::rawId(), RPCGeometry::roll(), edm::OwnVector< T, P >::size(), 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 == 0){
      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.size() > 0) //FIXME: is it really needed?
      recHitCollection->put(rpcId, recHits.begin(), recHits.end());
  }

  event.put(std::move(recHitCollection));

}

Member Data Documentation

enum RPCRecHitProducer::MaskSource RPCRecHitProducer::deadSource_

private

Referenced by beginRun(), and RPCRecHitProducer().

std::vector<RPCDeadStrips::DeadItem> RPCRecHitProducer::DeadVec

private

Definition at line 51 of file RPCRecHitProducer.h.

Referenced by beginRun(), and RPCRecHitProducer().

enum RPCRecHitProducer::MaskSource RPCRecHitProducer::maskSource_

private

Referenced by beginRun(), and RPCRecHitProducer().

std::vector<RPCMaskedStrips::MaskItem> RPCRecHitProducer::MaskVec

private

Definition at line 50 of file RPCRecHitProducer.h.

Referenced by beginRun(), and RPCRecHitProducer().

std::unique_ptr<RPCRecHitBaseAlgo> RPCRecHitProducer::theAlgo

private

Definition at line 40 of file RPCRecHitProducer.h.

Referenced by produce(), and RPCRecHitProducer().

std::unique_ptr<RPCDeadStrips> RPCRecHitProducer::theRPCDeadStripsObj

private

Definition at line 45 of file RPCRecHitProducer.h.

Referenced by beginRun(), produce(), and RPCRecHitProducer().

const edm::EDGetTokenT<RPCDigiCollection> RPCRecHitProducer::theRPCDigiLabel

private

Definition at line 36 of file RPCRecHitProducer.h.

Referenced by produce().

std::unique_ptr<RPCMaskedStrips> RPCRecHitProducer::theRPCMaskedStripsObj

private

Definition at line 42 of file RPCRecHitProducer.h.

Referenced by beginRun(), produce(), and RPCRecHitProducer().