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
	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

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_
bool	ge21Off_
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<>
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 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.

References get.

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

  // Turns off GE2/1 demonstrator reconstruction in Run3
  ge21Off_ = config.getParameter<bool>("ge21Off");
  // 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>();
    }
  }
}

~GEMRecHitProducer()

GEMRecHitProducer::~GEMRecHitProducer ( )

overridedefault

Destructor.

Member Function Documentation

beginRun()

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

override

Definition at line 92 of file GEMRecHitProducer.cc.

References applyMasking_, triggerObjects_cff::bit, deadSource_, deadStripsToken_, GEMGeometry::etaPartitions(), EventSetup, ge21Off_, gemGeom_, gemGeomToken_, gemMask_, gpuClustering::pixelStatus::mask, maskedStripsToken_, maskSource_, edm::ESHandle< T >::product(), DetId::rawId(), singleTopDQM_cfi::setup, GEMDetId::station(), theGEMDeadStripsObj, and theGEMMaskedStripsObj.

                                                                            {
  // 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();
      if (ge21Off_ && gemId.station() == 2) {
        continue;
      }
      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);
      }
    }
  }
}

fillDescriptions()

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

static

Definition at line 79 of file GEMRecHitProducer.cc.

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

                                                                                   {
  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.add<bool>("ge21Off", false);
  desc.addOptional<edm::FileInPath>("maskFile");
  desc.addOptional<edm::FileInPath>("deadFile");
  descriptions.add("gemRecHitsDef", desc);
}

produce()

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

override

The method which produces the rechits.

Definition at line 136 of file GEMRecHitProducer.cc.

References applyMasking_, GEMGeometry::etaPartition(), ge21Off_, gemGeom_, gemMask_, gpuClustering::pixelStatus::mask, eostools::move(), FastTimerService_cff::range, FastTrackerRecHitMaskProducer_cfi::recHits, singleTopDQM_cfi::setup, GEMDetId::station(), theAlgo, and theGEMDigiToken.

                                                                     {
  // 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;
    if (ge21Off_ && gemId.station() == 2) {
      continue;
    }

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

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().

ge21Off_

bool GEMRecHitProducer::ge21Off_

private

Definition at line 68 of file GEMRecHitProducer.h.

Referenced by beginRun(), and produce().

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().