GEMRecHitProducer Class Reference

#include <GEMRecHitProducer.h>

Inheritance diagram for GEMRecHitProducer:

Public Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override
	GEMRecHitProducer (const edm::ParameterSet &config)
	Constructor. More...
void	produce (edm::Event &event, const edm::EventSetup &setup) override
	The method which produces the rechits. More...
	~GEMRecHitProducer () override
	Destructor. More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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

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

Private Attributes
bool	applyMasking_
enum GEMRecHitProducer::MaskSource	deadSource_
edm::ESGetToken< GEMDeadStrips, GEMDeadStripsRcd >	deadStripsToken_
edm::ESHandle< GEMGeometry >	gemGeom_
edm::ESGetToken< GEMGeometry, MuonGeometryRecord >	gemGeomToken_
std::map< GEMDetId, EtaPartitionMask >	gemMask_
edm::ESGetToken< GEMMaskedStrips, GEMMaskedStripsRcd >	maskedStripsToken_
enum GEMRecHitProducer::MaskSource	maskSource_
std::unique_ptr< GEMRecHitBaseAlgo >	theAlgo
std::unique_ptr< GEMDeadStrips >	theGEMDeadStripsObj
edm::EDGetTokenT< GEMDigiCollection >	theGEMDigiToken
std::unique_ptr< GEMMaskedStrips >	theGEMMaskedStripsObj

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 GEMRecHit production.

Author

M. Maggim – INFN Bari

Definition at line 27 of file GEMRecHitProducer.h.

Member Enumeration Documentation

MaskSource

enum GEMRecHitProducer::MaskSource

strongprivate

Enumerator
File
EventSetup

Definition at line 56 of file GEMRecHitProducer.h.

{ File, EventSetup } maskSource_, deadSource_;

Constructor & Destructor Documentation

GEMRecHitProducer()

GEMRecHitProducer::GEMRecHitProducer

(

const edm::ParameterSet &

config

)

Constructor.

Definition at line 22 of file GEMRecHitProducer.cc.

    : theGEMDigiToken(consumes<GEMDigiCollection>(config.getParameter<InputTag>("gemDigiLabel"))),
      // Get the concrete reconstruction algo from the factory
      theAlgo{GEMRecHitAlgoFactory::get()->create(config.getParameter<string>("recAlgo"),
                                                  config.getParameter<ParameterSet>("recAlgoConfig"))},
      maskSource_(MaskSource::EventSetup),
      deadSource_(MaskSource::EventSetup),
      gemGeomToken_(esConsumes<GEMGeometry, MuonGeometryRecord, edm::Transition::BeginRun>()) {
  produces<GEMRecHitCollection>();
 
  // Get masked- and dead-strip information from file
  applyMasking_ = config.getParameter<bool>("applyMasking");
  if (applyMasking_) {
    if (config.existsAs<edm::FileInPath>("maskFile")) {
      maskSource_ = MaskSource::File;
      std::ifstream inputFile(config.getParameter<edm::FileInPath>("maskFile").fullPath());
      if (!inputFile) {
        throw cms::Exception("GEMRecHitProducer") << "Masked Strips File cannot not be opened";
      }
      theGEMMaskedStripsObj = std::make_unique<GEMMaskedStrips>();
      while (inputFile.good()) {
        GEMMaskedStrips::MaskItem Item;
        inputFile >> Item.rawId >> Item.strip;
        if (inputFile.good())
          theGEMMaskedStripsObj->fillMaskVec(Item);
      }
      inputFile.close();
    }
 
    if (config.existsAs<edm::FileInPath>("deadFile")) {
      deadSource_ = MaskSource::File;
      std::ifstream inputFile(config.getParameter<edm::FileInPath>("deadFile").fullPath());
      if (!inputFile) {
        throw cms::Exception("GEMRecHitProducer") << "Dead Strips File cannot not be opened";
      }
      theGEMDeadStripsObj = std::make_unique<GEMDeadStrips>();
      while (inputFile.good()) {
        GEMDeadStrips::DeadItem Item;
        inputFile >> Item.rawId >> Item.strip;
        if (inputFile.good())
          theGEMDeadStripsObj->fillDeadVec(Item);
      }
      inputFile.close();
    }
    if (maskSource_ == MaskSource::EventSetup) {
      maskedStripsToken_ = esConsumes<GEMMaskedStrips, GEMMaskedStripsRcd, edm::Transition::BeginRun>();
    }
    if (deadSource_ == MaskSource::EventSetup) {
      deadStripsToken_ = esConsumes<GEMDeadStrips, GEMDeadStripsRcd, edm::Transition::BeginRun>();
    }
  }
}

References get.

~GEMRecHitProducer()

GEMRecHitProducer::~GEMRecHitProducer ( )

overridedefault

Destructor.

Member Function Documentation

beginRun()

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

override

Definition at line 89 of file GEMRecHitProducer.cc.

                                                                            {
  // Get the GEM Geometry
  gemGeom_ = setup.getHandle(gemGeomToken_);
 
  if (applyMasking_) {
    // Getting the masked-strip information
    if (maskSource_ == MaskSource::EventSetup) {
      edm::ESHandle<GEMMaskedStrips> readoutMaskedStrips = setup.getHandle(maskedStripsToken_);
      theGEMMaskedStripsObj = std::make_unique<GEMMaskedStrips>(*readoutMaskedStrips.product());
    }
    // Getting the dead-strip information
    if (deadSource_ == MaskSource::EventSetup) {
      edm::ESHandle<GEMDeadStrips> readoutDeadStrips = setup.getHandle(deadStripsToken_);
      theGEMDeadStripsObj = std::make_unique<GEMDeadStrips>(*readoutDeadStrips.product());
    }
 
    for (auto gems : gemGeom_->etaPartitions()) {
      // Getting the EtaPartitionMask mask, that includes dead strips, for the given GEMDet
      GEMDetId gemId = gems->id();
      EtaPartitionMask mask;
      const int rawId = gemId.rawId();
      for (const auto& tomask : theGEMMaskedStripsObj->getMaskVec()) {
        if (tomask.rawId == rawId) {
          const int bit = tomask.strip;
          mask.set(bit);
        }
      }
      for (const auto& tomask : theGEMDeadStripsObj->getDeadVec()) {
        if (tomask.rawId == rawId) {
          const int bit = tomask.strip;
          mask.set(bit);
        }
      }
      // add to masking map if masking present in etaPartition
      if (mask.any()) {
        gemMask_.emplace(gemId, mask);
      }
    }
  }
}

References applyMasking_, deadSource_, deadStripsToken_, GEMGeometry::etaPartitions(), EventSetup, gemGeom_, gemGeomToken_, gemMask_, maskedStripsToken_, maskSource_, edm::ESHandle< T >::product(), DetId::rawId(), singleTopDQM_cfi::setup, theGEMDeadStripsObj, and theGEMMaskedStripsObj.

fillDescriptions()

void GEMRecHitProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 77 of file GEMRecHitProducer.cc.

                                                                                   {
  edm::ParameterSetDescription desc;
  edm::ParameterSetDescription recAlgoConfigDesc;
  desc.add<edm::ParameterSetDescription>("recAlgoConfig", recAlgoConfigDesc);
  desc.add<std::string>("recAlgo", "GEMRecHitStandardAlgo");
  desc.add<edm::InputTag>("gemDigiLabel", edm::InputTag("muonGEMDigis"));
  desc.add<bool>("applyMasking", false);
  desc.addOptional<edm::FileInPath>("maskFile");
  desc.addOptional<edm::FileInPath>("deadFile");
  descriptions.add("gemRecHitsDef", desc);
}

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

produce()

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

override

The method which produces the rechits.

Definition at line 130 of file GEMRecHitProducer.cc.

                                                                     {
  // Get the digis from the event
  Handle<GEMDigiCollection> digis;
  event.getByToken(theGEMDigiToken, 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<GEMRecHitCollection>();
 
  // Iterate through all digi collections ordered by LayerId
  for (auto gemdgIt = digis->begin(); gemdgIt != digis->end(); ++gemdgIt) {
    // The layerId
    const GEMDetId& gemId = (*gemdgIt).first;
 
    // Get the GeomDet from the setup
    const GEMEtaPartition* roll = gemGeom_->etaPartition(gemId);
    if (roll == nullptr) {
      edm::LogError("BadDigiInput") << "Failed to find GEMEtaPartition for ID " << gemId;
      continue;
    }
 
    // Get the iterators over the digis associated with this LayerId
    const GEMDigiCollection::Range& range = (*gemdgIt).second;
 
    // get mask from map
    EtaPartitionMask mask;
    if (applyMasking_) {
      auto gemmaskIt = gemMask_.find(gemId);
      if (gemmaskIt != gemMask_.end())
        mask = gemmaskIt->second;
    }
 
    // Call the reconstruction algorithm
    OwnVector<GEMRecHit> recHits = theAlgo->reconstruct(*roll, gemId, range, mask);
 
    if (!recHits.empty())  //FIXME: is it really needed?
      recHitCollection->put(gemId, recHits.begin(), recHits.end());
  }
 
  event.put(std::move(recHitCollection));
}

References applyMasking_, GEMGeometry::etaPartition(), gemGeom_, gemMask_, eostools::move(), FastTimerService_cff::range, FastTrackerRecHitMaskProducer_cfi::recHits, singleTopDQM_cfi::setup, theAlgo, and theGEMDigiToken.

Member Data Documentation

applyMasking_

bool GEMRecHitProducer::applyMasking_

private

Definition at line 67 of file GEMRecHitProducer.h.

Referenced by beginRun(), and produce().

deadSource_

enum GEMRecHitProducer::MaskSource GEMRecHitProducer::deadSource_

private

Referenced by beginRun().

deadStripsToken_

edm::ESGetToken<GEMDeadStrips, GEMDeadStripsRcd> GEMRecHitProducer::deadStripsToken_

private

Definition at line 62 of file GEMRecHitProducer.h.

Referenced by beginRun().

gemGeom_

edm::ESHandle<GEMGeometry> GEMRecHitProducer::gemGeom_

private

Definition at line 58 of file GEMRecHitProducer.h.

Referenced by beginRun(), and produce().

gemGeomToken_

edm::ESGetToken<GEMGeometry, MuonGeometryRecord> GEMRecHitProducer::gemGeomToken_

private

Definition at line 60 of file GEMRecHitProducer.h.

Referenced by beginRun().

gemMask_

std::map<GEMDetId, EtaPartitionMask> GEMRecHitProducer::gemMask_

private

Definition at line 65 of file GEMRecHitProducer.h.

Referenced by beginRun(), and produce().

maskedStripsToken_

edm::ESGetToken<GEMMaskedStrips, GEMMaskedStripsRcd> GEMRecHitProducer::maskedStripsToken_

private

Definition at line 61 of file GEMRecHitProducer.h.

Referenced by beginRun().

maskSource_

enum GEMRecHitProducer::MaskSource GEMRecHitProducer::maskSource_

private

Referenced by beginRun().

theAlgo

std::unique_ptr<GEMRecHitBaseAlgo> GEMRecHitProducer::theAlgo

private

Definition at line 48 of file GEMRecHitProducer.h.

Referenced by produce().

theGEMDeadStripsObj

std::unique_ptr<GEMDeadStrips> GEMRecHitProducer::theGEMDeadStripsObj

private

Definition at line 54 of file GEMRecHitProducer.h.

Referenced by beginRun().

theGEMDigiToken

edm::EDGetTokenT<GEMDigiCollection> GEMRecHitProducer::theGEMDigiToken

private

Definition at line 45 of file GEMRecHitProducer.h.

Referenced by produce().

theGEMMaskedStripsObj

std::unique_ptr<GEMMaskedStrips> GEMRecHitProducer::theGEMMaskedStripsObj

private

Definition at line 51 of file GEMRecHitProducer.h.

Referenced by beginRun().