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	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () 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::ESHandle< GEMGeometry >	gemGeom_
std::map< GEMDetId, EtaPartitionMask >	gemMask_
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 23 of file GEMRecHitProducer.h.

Member Enumeration Documentation

enum GEMRecHitProducer::MaskSource

strongprivate

Enumerator
File
EventSetup

Definition at line 54 of file GEMRecHitProducer.h.

{ File, EventSetup } maskSource_, deadSource_;

Constructor & Destructor Documentation

GEMRecHitProducer::GEMRecHitProducer

(

const edm::ParameterSet &

config

)

Constructor.

Definition at line 25 of file GEMRecHitProducer.cc.

References applyMasking_, deadSource_, EventSetup, Exception, File, edm::FileInPath::fullPath(), reco::get(), edm::ParameterSet::getParameter(), analyzePatCleaning_cfg::inputFile, maskSource_, GEMMaskedStrips::MaskItem::rawId, GEMDeadStrips::DeadItem::rawId, GEMDeadStrips::DeadItem::strip, GEMMaskedStrips::MaskItem::strip, theGEMDeadStripsObj, theGEMMaskedStripsObj, and ~GEMRecHitProducer().

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

GEMRecHitProducer::~GEMRecHitProducer ( )

overridedefault

Destructor.

Referenced by GEMRecHitProducer().

Member Function Documentation

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

override

Definition at line 85 of file GEMRecHitProducer.cc.

References applyMasking_, deadSource_, GEMGeometry::etaPartitions(), EventSetup, gemGeom_, gemMask_, edm::EventSetup::get(), RecoTauDiscriminantConfiguration::mask, maskSource_, edm::ESHandle< T >::product(), DetId::rawId(), theGEMDeadStripsObj, and theGEMMaskedStripsObj.

{
  // Get the GEM Geometry
  setup.get<MuonGeometryRecord>().get(gemGeom_);

  if (applyMasking_) {
    // Getting the masked-strip information
    if ( maskSource_ == MaskSource::EventSetup ) {
      edm::ESHandle<GEMMaskedStrips> readoutMaskedStrips;
      setup.get<GEMMaskedStripsRcd>().get(readoutMaskedStrips);
      theGEMMaskedStripsObj = std::make_unique<GEMMaskedStrips>(*readoutMaskedStrips.product());
    }
    // Getting the dead-strip information
    if ( deadSource_ == MaskSource::EventSetup ) {
      edm::ESHandle<GEMDeadStrips> readoutDeadStrips;
      setup.get<GEMDeadStripsRcd>().get(readoutDeadStrips);
      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-1);
        }
      }
      for ( const auto& tomask : theGEMDeadStripsObj->getDeadVec() ) {
        if ( tomask.rawId == rawId ) {
          const int bit = tomask.strip;
          mask.set(bit-1);
        }
      }
      // add to masking map if masking present in etaPartition
      if (mask.any()) {
        gemMask_.emplace(gemId,mask);
      }
    }
  }
}

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

static

Definition at line 72 of file GEMRecHitProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), 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.addOptional<edm::FileInPath>("maskFile");
  desc.addOptional<edm::FileInPath>("deadFile");
  descriptions.add("gemRecHitsDef",desc);
}

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

override

The method which produces the rechits.

Definition at line 129 of file GEMRecHitProducer.cc.

References applyMasking_, edm::OwnVector< T, P >::begin(), edm::OwnVector< T, P >::empty(), edm::OwnVector< T, P >::end(), GEMGeometry::etaPartition(), gemGeom_, gemMask_, RecoTauDiscriminantConfiguration::mask, eostools::move(), 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;

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

bool GEMRecHitProducer::applyMasking_

private

Definition at line 61 of file GEMRecHitProducer.h.

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

enum GEMRecHitProducer::MaskSource GEMRecHitProducer::deadSource_

private

Referenced by beginRun(), and GEMRecHitProducer().

edm::ESHandle<GEMGeometry> GEMRecHitProducer::gemGeom_

private

Definition at line 56 of file GEMRecHitProducer.h.

Referenced by beginRun(), and produce().

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

private

Definition at line 59 of file GEMRecHitProducer.h.

Referenced by beginRun(), and produce().

enum GEMRecHitProducer::MaskSource GEMRecHitProducer::maskSource_

private

Referenced by beginRun(), and GEMRecHitProducer().

std::unique_ptr<GEMRecHitBaseAlgo> GEMRecHitProducer::theAlgo

private

Definition at line 46 of file GEMRecHitProducer.h.

Referenced by produce().

std::unique_ptr<GEMDeadStrips> GEMRecHitProducer::theGEMDeadStripsObj

private

Definition at line 52 of file GEMRecHitProducer.h.

Referenced by beginRun(), and GEMRecHitProducer().

edm::EDGetTokenT<GEMDigiCollection> GEMRecHitProducer::theGEMDigiToken

private

Definition at line 43 of file GEMRecHitProducer.h.

Referenced by produce().

std::unique_ptr<GEMMaskedStrips> GEMRecHitProducer::theGEMMaskedStripsObj

private

Definition at line 49 of file GEMRecHitProducer.h.

Referenced by beginRun(), and GEMRecHitProducer().