RPCRecHitProducer Class Reference

#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
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

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<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Module for RPCRecHit production.

Author

M. Maggim – INFN Bari

Definition at line 19 of file RPCRecHitProducer.h.

Member Enumeration Documentation

MaskSource

enum RPCRecHitProducer::MaskSource

strongprivate

Enumerator
File
EventSetup

Definition at line 47 of file RPCRecHitProducer.h.

{ File, EventSetup } maskSource_, deadSource_;

Constructor & Destructor Documentation

RPCRecHitProducer()

RPCRecHitProducer::RPCRecHitProducer

(

const edm::ParameterSet &

config

)

Constructor.

Definition at line 29 of file RPCRecHitProducer.cc.

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

References get.

~RPCRecHitProducer()

RPCRecHitProducer::~RPCRecHitProducer ( )

inlineoverride

Destructor.

Definition at line 25 of file RPCRecHitProducer.h.

{};

Member Function Documentation

beginRun()

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

override

Definition at line 80 of file RPCRecHitProducer.cc.

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

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

produce()

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.

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

References get, eostools::move(), FastTimerService_cff::range, DetId::rawId(), FastTrackerRecHitMaskProducer_cfi::recHits, RPCGeometry::roll(), singleTopDQM_cfi::setup, theAlgo, theRPCDeadStripsObj, theRPCDigiLabel, and theRPCMaskedStripsObj.

Member Data Documentation

deadSource_

enum RPCRecHitProducer::MaskSource RPCRecHitProducer::deadSource_

private

Referenced by beginRun().

DeadVec

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

private

Definition at line 50 of file RPCRecHitProducer.h.

Referenced by beginRun().

maskSource_

enum RPCRecHitProducer::MaskSource RPCRecHitProducer::maskSource_

private

Referenced by beginRun().

MaskVec

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

private

Definition at line 49 of file RPCRecHitProducer.h.

Referenced by beginRun().

theAlgo

std::unique_ptr<RPCRecHitBaseAlgo> RPCRecHitProducer::theAlgo

private

Definition at line 39 of file RPCRecHitProducer.h.

Referenced by produce().

theRPCDeadStripsObj

std::unique_ptr<RPCDeadStrips> RPCRecHitProducer::theRPCDeadStripsObj

private

Definition at line 44 of file RPCRecHitProducer.h.

Referenced by beginRun(), and produce().

theRPCDigiLabel

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

private

Definition at line 35 of file RPCRecHitProducer.h.

Referenced by produce().

theRPCMaskedStripsObj

std::unique_ptr<RPCMaskedStrips> RPCRecHitProducer::theRPCMaskedStripsObj

private

Definition at line 41 of file RPCRecHitProducer.h.

Referenced by beginRun(), and produce().