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
edm::ESGetToken< RPCDeadStrips, RPCDeadStripsRcd >	theReadoutDeadStripsToken
edm::ESGetToken< RPCMaskedStrips, RPCMaskedStripsRcd >	theReadoutMaskedStripsToken
std::unique_ptr< RPCDeadStrips >	theRPCDeadStripsObj
const edm::EDGetTokenT< RPCDigiCollection >	theRPCDigiLabel
const edm::ESGetToken< RPCGeometry, MuonGeometryRecord >	theRPCGeomToken
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 23 of file RPCRecHitProducer.h.

Member Enumeration Documentation

MaskSource

enum RPCRecHitProducer::MaskSource

strongprivate

Enumerator
File
EventSetup

Definition at line 54 of file RPCRecHitProducer.h.

{ File, EventSetup } maskSource_, deadSource_;

Constructor & Destructor Documentation

RPCRecHitProducer()

RPCRecHitProducer::RPCRecHitProducer

(

const edm::ParameterSet &

config

)

Constructor.

Definition at line 23 of file RPCRecHitProducer.cc.

References get.

    : theRPCDigiLabel(consumes<RPCDigiCollection>(config.getParameter<InputTag>("rpcDigiLabel"))),
      theRPCGeomToken(esConsumes()),
      // 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();
  } else {
    theReadoutMaskedStripsToken = esConsumes();
  }

  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();
  } else {
    theReadoutDeadStripsToken = esConsumes();
  }
}

~RPCRecHitProducer()

RPCRecHitProducer::~RPCRecHitProducer ( )

inlineoverride

Destructor.

Definition at line 29 of file RPCRecHitProducer.h.

{};

Member Function Documentation

beginRun()

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

override

Definition at line 79 of file RPCRecHitProducer.cc.

References deadSource_, DeadVec, EventSetup, File, maskSource_, MaskVec, RPCMaskedStrips::MaskItem::rawId, RPCDeadStrips::DeadItem::rawId, singleTopDQM_cfi::setup, RPCMaskedStrips::MaskItem::strip, RPCDeadStrips::DeadItem::strip, theReadoutDeadStripsToken, theReadoutMaskedStripsToken, theRPCDeadStripsObj, and theRPCMaskedStripsObj.

                                                                            {
  // Getting the masked-strip information
  if (maskSource_ == MaskSource::EventSetup) {
    theRPCMaskedStripsObj->MaskVec = setup.getData(theReadoutMaskedStripsToken).MaskVec;
  } 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) {
    theRPCDeadStripsObj->DeadVec = setup.getData(theReadoutDeadStripsToken).DeadVec;
  } 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);
    }
  }
}

produce()

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

override

The method which produces the rechits.

Definition at line 107 of file RPCRecHitProducer.cc.

References triggerObjects_cff::bit, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, eostools::move(), FastTimerService_cff::range, nano_mu_digi_cff::rawId, DetId::rawId(), FastTrackerRecHitMaskProducer_cfi::recHits, nano_mu_digi_cff::roll, singleTopDQM_cfi::setup, theAlgo, theRPCDeadStripsObj, theRPCDigiLabel, theRPCGeomToken, and theRPCMaskedStripsObj.

                                                                     {
  // Get the RPC Geometry
  auto const& rpcGeom = setup.getData(theRPCGeomToken);

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

Member Data Documentation

deadSource_

enum RPCRecHitProducer::MaskSource RPCRecHitProducer::deadSource_

private

Referenced by beginRun().

DeadVec

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

private

Definition at line 57 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 56 of file RPCRecHitProducer.h.

Referenced by beginRun().

theAlgo

std::unique_ptr<RPCRecHitBaseAlgo> RPCRecHitProducer::theAlgo

private

Definition at line 46 of file RPCRecHitProducer.h.

Referenced by produce().

theReadoutDeadStripsToken

edm::ESGetToken<RPCDeadStrips, RPCDeadStripsRcd> RPCRecHitProducer::theReadoutDeadStripsToken

private

Definition at line 42 of file RPCRecHitProducer.h.

Referenced by beginRun().

theReadoutMaskedStripsToken

edm::ESGetToken<RPCMaskedStrips, RPCMaskedStripsRcd> RPCRecHitProducer::theReadoutMaskedStripsToken

private

Definition at line 41 of file RPCRecHitProducer.h.

Referenced by beginRun().

theRPCDeadStripsObj

std::unique_ptr<RPCDeadStrips> RPCRecHitProducer::theRPCDeadStripsObj

private

Definition at line 51 of file RPCRecHitProducer.h.

Referenced by beginRun(), and produce().

theRPCDigiLabel

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

private

Definition at line 39 of file RPCRecHitProducer.h.

Referenced by produce().

theRPCGeomToken

const edm::ESGetToken<RPCGeometry, MuonGeometryRecord> RPCRecHitProducer::theRPCGeomToken

private

Definition at line 43 of file RPCRecHitProducer.h.

Referenced by produce().

theRPCMaskedStripsObj

std::unique_ptr<RPCMaskedStrips> RPCRecHitProducer::theRPCMaskedStripsObj

private

Definition at line 48 of file RPCRecHitProducer.h.

Referenced by beginRun(), and produce().