Inheritance diagram for PFBadHcalPseudoClusterProducer:

Public Member Functions
	PFBadHcalPseudoClusterProducer (const edm::ParameterSet &)

	~PFBadHcalPseudoClusterProducer () override

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 Member Functions
virtual void	init (const EventSetup &c)

void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< reco::PFCluster >	badAreasC_

std::vector< reco::PFRecHit >	badAreasRH_

unsigned long long	cacheId_geom_

unsigned long long	cacheId_quality_

bool	debug_

bool	enabled_

edm::ESHandle< CaloGeometry >	hGeom_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	hGeomToken_

edm::ESHandle< HcalChannelQuality >	hQuality_

edm::ESGetToken< HcalChannelQuality, HcalChannelQualityRcd >	hQualityToken_

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

Definition at line 41 of file PFBadHcalPseudoClusterProducer.cc.

Constructor & Destructor Documentation

◆ PFBadHcalPseudoClusterProducer()

PFBadHcalPseudoClusterProducer::PFBadHcalPseudoClusterProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 65 of file PFBadHcalPseudoClusterProducer.cc.

     : enabled_(ps.getParameter<bool>("enable")),
       debug_(ps.getUntrackedParameter<bool>("debug", false)),
       cacheId_quality_(0),
       cacheId_geom_(0),
       hQualityToken_(esConsumes(edm::ESInputTag("", "withTopo"))),
       hGeomToken_(esConsumes()) {
   produces<std::vector<reco::PFCluster>>();
   produces<std::vector<reco::PFRecHit>>("hits");
 }

◆ ~PFBadHcalPseudoClusterProducer()

PFBadHcalPseudoClusterProducer::~PFBadHcalPseudoClusterProducer ( )

override

Definition at line 76 of file PFBadHcalPseudoClusterProducer.cc.

76 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 168 of file PFBadHcalPseudoClusterProducer.cc.

                                                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<bool>("enable", true)
       ->setComment("activate the module (if false, it doesn't check the DB and produces an empty collection)");
   desc.addUntracked<bool>("debug", false);
   descriptions.add("particleFlowBadHcalPseudoCluster", desc);
 }

References edm::ConfigurationDescriptions::add(), and submitPVResolutionJobs::desc.

◆ init()

void PFBadHcalPseudoClusterProducer::init ( const EventSetup & c )

privatevirtual

Definition at line 78 of file PFBadHcalPseudoClusterProducer.cc.

                                                                   {
   badAreasC_.clear();
   badAreasRH_.clear();
  
   hQuality_ = iSetup.getHandle(hQualityToken_);
   const HcalChannelQuality& chanquality = *hQuality_;
  
   hGeom_ = iSetup.getHandle(hGeomToken_);
   const CaloGeometry& caloGeom = *hGeom_;
   const CaloSubdetectorGeometry* hbGeom = caloGeom.getSubdetectorGeometry(DetId::Hcal, HcalBarrel);
   const CaloSubdetectorGeometry* heGeom = caloGeom.getSubdetectorGeometry(DetId::Hcal, HcalEndcap);
  
   int statusMask = ((1 << HcalChannelStatus::HcalCellOff) | (1 << HcalChannelStatus::HcalCellMask) |
                     (1 << HcalChannelStatus::HcalCellDead));
   // histogram the number of bad depths at each ieta, iphi
   std::map<std::pair<int, int>, int> good, bads;
   std::map<std::pair<int, int>, std::pair<int, HcalSubdetector>> minDepths;
   for (const DetId& i : chanquality.getAllChannels()) {
     if (i.det() != DetId::Hcal)
       continue;  // not an hcal cell
     HcalDetId id = HcalDetId(i);
     if (id.subdet() != HcalBarrel && id.subdet() != HcalEndcap)
       continue;  // we don't deal with HO and HF here
     int status = chanquality.getValues(id)->getValue();
     auto tower = std::make_pair(id.ieta(), id.iphi());
     if (status & statusMask) {
       bads[tower]++;
       if (debug_)
         std::cout << "Channel " << i() << " (subdet " << id.subdet() << ", zside " << id.zside() << ", ieta "
                   << id.ieta() << ", iphi " << id.iphi() << " depth " << id.depth() << " has status " << status
                   << "  masked " << (status & statusMask) << std::endl;
     } else {
       good[tower]++;
     }
     auto& minD = minDepths[tower];
     if (minD.second == HcalEmpty || minD.first > id.depth()) {
       minD.first = id.depth();
       minD.second = id.subdet();
     }
   }
  
   const float dummyEnergy = 1e-5;  // non-zero, but small (even if it shouldn't ever be used)
   for (const auto& rec : bads) {
     int ieta = rec.first.first, iphi = rec.first.second, nbad = rec.second, ngood = good[rec.first];
     auto minDepth = minDepths[rec.first];
     bool barrel = minDepth.second == HcalBarrel;
     HcalDetId id(minDepth.second, ieta, iphi, minDepth.first);
     bool isBad = (nbad > 0 && nbad >= ngood);
     if (debug_)
       std::cout << "At ieta " << id.ieta() << ", iphi " << id.iphi() << " I have " << nbad << " bad depths, " << ngood
                 << " good depths. First depth is in " << (barrel ? "HB" : "HE") << " depth " << minDepth.first << "; "
                 << (isBad ? " MARK BAD" : " ignore") << std::endl;
     if (!isBad)
       continue;
     PFLayer::Layer layer = (barrel ? PFLayer::HCAL_BARREL1 : PFLayer::HCAL_ENDCAP);
     // make a PF RecHit
     std::shared_ptr<const CaloCellGeometry> thisCell = (barrel ? hbGeom : heGeom)->getGeometry(id);
     const GlobalPoint& pos = thisCell->getPosition();
     badAreasRH_.emplace_back(thisCell, id(), layer, dummyEnergy);
     // make a PF cluster (but can't add the rechit, as for that I need an edm::Ref)
     badAreasC_.emplace_back(layer, dummyEnergy, pos.x(), pos.y(), pos.z());
     badAreasC_.back().setFlags(reco::CaloCluster::badHcalMarker);
   }
  
   cacheId_quality_ = iSetup.get<HcalChannelQualityRcd>().cacheIdentifier();
   cacheId_geom_ = iSetup.get<CaloGeometryRecord>().cacheIdentifier();
 }

References badAreasC_, badAreasRH_, reco::CaloCluster::badHcalMarker, Reference_intrackfit_cff::barrel, cacheId_geom_, cacheId_quality_, gather_cfg::cout, debug_, MillePedeFileConverter_cfg::e, edm::EventSetup::get(), HcalCondObjectContainer< Item >::getAllChannels(), edm::EventSetup::getHandle(), CaloGeometry::getSubdetectorGeometry(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), good, DetId::Hcal, PFLayer::HCAL_BARREL1, PFLayer::HCAL_ENDCAP, HcalBarrel, HcalChannelStatus::HcalCellDead, HcalChannelStatus::HcalCellMask, HcalChannelStatus::HcalCellOff, HcalEmpty, HcalEndcap, hGeom_, hGeomToken_, hQuality_, hQualityToken_, mps_fire::i, triggerObjects_cff::id, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, phase1PixelTopology::layer, mps_update::status, and hgcalTowerProducer_cfi::tower.

Referenced by produce().

◆ produce()

void PFBadHcalPseudoClusterProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 147 of file PFBadHcalPseudoClusterProducer.cc.

                                                                                           {
   if (enabled_) {
     if (cacheId_quality_ != iSetup.get<HcalChannelQualityRcd>().cacheIdentifier() ||
         cacheId_geom_ != iSetup.get<CaloGeometryRecord>().cacheIdentifier()) {
       init(iSetup);
     }
   }
  
   auto outRH = std::make_unique<std::vector<reco::PFRecHit>>(badAreasRH_);
   auto rhHandle = iEvent.put(std::move(outRH), "hits");
  
   auto outC = std::make_unique<std::vector<reco::PFCluster>>(badAreasC_);
  
   // now we go set references
   for (unsigned int i = 0, n = rhHandle->size(); i < n; ++i) {
     (*outC)[i].addRecHitFraction(reco::PFRecHitFraction(reco::PFRecHitRef(rhHandle, i), 1.0));
   }
  
   iEvent.put(std::move(outC));
 }