#include <PixelInactiveAreaFinder.h>

Classes
struct	DetGroupSpan

class	InactiveAreas

Public Types
using	Area = AreaSeededTrackingRegionsBuilder::Area

using	DetGroupSpanContainer = std::vector< DetGroupSpan >

using	LayerSetIndex = SeedingLayerSetsHits::LayerSetIndex

using	SeedingLayerId = SeedingLayerSetsBuilder::SeedingLayerId

Public Member Functions
InactiveAreas	inactiveAreas (const edm::Event &iEvent, const edm::EventSetup &iSetup)

	PixelInactiveAreaFinder (const edm::ParameterSet &iConfig, const std::vector< SeedingLayerId > &seedingLayers, const SeedingLayerSetsLooper &seedingLayerSetsLooper, edm::ConsumesCollector &&iC)

	~PixelInactiveAreaFinder ()=default

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &desc)

Private Types
using	det_t = uint32_t

using	DetContainer = std::vector< uint32_t >

using	DetectorSet = std::set< uint32_t >

using	DetGroup = std::vector< uint32_t >

using	DetGroupContainer = std::vector< DetGroup >

using	DetGroupSpanContainerPair = std::pair< DetGroupSpanContainer, DetGroupSpanContainer >

using	OverlapSpans = std::vector< DetGroupSpan >

using	OverlapSpansContainer = std::vector< OverlapSpans >

using	Stream = std::stringstream

Private Member Functions
DetGroup	badAdjecentDetsBarrel (const det_t &det)

DetGroup	badAdjecentDetsEndcap (const det_t &det)

DetGroupContainer	badDetGroupsBarrel ()

DetGroupContainer	badDetGroupsEndcap ()

void	createPlottingFiles ()

DetGroupSpanContainerPair	detGroupSpans ()

void	detInfo (const det_t &det, Stream &ss)

bool	detWorks (det_t det)

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

void	getPhiSpanBarrel (const DetGroup &detGroup, DetGroupSpan &cspan)

void	getPhiSpanEndcap (const DetGroup &detGroup, DetGroupSpan &cspan)

void	getRSpan (const DetGroup &detGroup, DetGroupSpan &cspan)

void	getSpan (const DetGroup &detGroup, DetGroupSpan &cspan)

void	getZSpan (const DetGroup &detGroup, DetGroupSpan &cspan)

void	printBadDetGroups ()

void	printBadDetGroupSpans ()

void	printBadPixelDets ()

void	printPixelDets ()

DetGroup	reachableDetGroup (const det_t &initDet, DetectorSet &foundDets)

void	updatePixelDets (const edm::EventSetup &iSetup)

Private Attributes
DetContainer	badPixelDetsBarrel_

DetContainer	badPixelDetsEndcap_

std::vector< edm::EDGetTokenT< PixelFEDChannelCollection > >	badPixelFEDChannelsTokens_

const bool	createPlottingFiles_

const bool	debug_

edm::ESWatcher< TrackerDigiGeometryRecord >	geometryWatcher_

const bool	ignoreSingleFPixPanelModules_

std::vector< SeedingLayerId >	inactiveLayers_

std::vector< std::pair< unsigned short, unsigned short > >	inactiveLayerSetIndices_

std::vector< edm::EDGetTokenT< DetIdCollection > >	inactivePixelDetectorTokens_

std::vector< std::vector< LayerSetIndex > >	layerSetIndexInactiveToActive_

std::array< unsigned short, 4 >	nBPixLadders

unsigned short	nModulesPerLadder

DetContainer	pixelDetsBarrel_

DetContainer	pixelDetsEndcap_

const SiPixelQuality *	pixelQuality_ = 0

const TrackerGeometry *	trackerGeometry_ = 0

const TrackerTopology *	trackerTopology_ = 0

Detailed Description

Definition at line 21 of file PixelInactiveAreaFinder.h.

Member Typedef Documentation

using PixelInactiveAreaFinder::Area = AreaSeededTrackingRegionsBuilder::Area

Definition at line 23 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::det_t = uint32_t

private

Definition at line 99 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::DetContainer = std::vector<uint32_t>

private

Definition at line 100 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::DetectorSet = std::set<uint32_t>

private

Definition at line 103 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::DetGroup = std::vector<uint32_t>

private

Definition at line 101 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::DetGroupContainer = std::vector<DetGroup>

private

Definition at line 102 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::DetGroupSpanContainer = std::vector<DetGroupSpan>

Definition at line 36 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::DetGroupSpanContainerPair = std::pair<DetGroupSpanContainer, DetGroupSpanContainer>

private

Definition at line 92 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::LayerSetIndex = SeedingLayerSetsHits::LayerSetIndex

Definition at line 25 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::OverlapSpans = std::vector<DetGroupSpan>

private

Definition at line 93 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::OverlapSpansContainer = std::vector<OverlapSpans>

private

Definition at line 94 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::SeedingLayerId = SeedingLayerSetsBuilder::SeedingLayerId

Definition at line 24 of file PixelInactiveAreaFinder.h.

using PixelInactiveAreaFinder::Stream = std::stringstream

private

Definition at line 104 of file PixelInactiveAreaFinder.h.

Constructor & Destructor Documentation

PixelInactiveAreaFinder::PixelInactiveAreaFinder	(	const edm::ParameterSet &	iConfig,
		const std::vector< SeedingLayerId > &	seedingLayers,
		const SeedingLayerSetsLooper &	seedingLayerSetsLooper,
		edm::ConsumesCollector &&	iC
	)

Definition at line 462 of file PixelInactiveAreaFinder.cc.

References badPixelFEDChannelsTokens_, HLT_2018_cff::distance, Exception, spr::find(), newFWLiteAna::found, mps_fire::i, inactiveLayers_, inactiveLayerSetIndices_, layerSetIndexInactiveToActive_, LogDebug, LogTrace, runTheMatrix::ret, HLT_2018_cff::seedingLayers, GlobalPosition_Frontier_DevDB_cff::tag, and edm::vector_transform().

     : debug_(iConfig.getUntrackedParameter<bool>("debug")),
       createPlottingFiles_(iConfig.getUntrackedParameter<bool>("createPlottingFiles")),
       ignoreSingleFPixPanelModules_(iConfig.getParameter<bool>("ignoreSingleFPixPanelModules")),
       inactivePixelDetectorTokens_(
           edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag>>("inactivePixelDetectorLabels"),
                                 [&](const auto& tag) { return iC.consumes<DetIdCollection>(tag); })),
       badPixelFEDChannelsTokens_(
           edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag>>("badPixelFEDChannelCollectionLabels"),
                                 [&](const auto& tag) { return iC.consumes<PixelFEDChannelCollection>(tag); })) {
 #ifdef EDM_ML_DEBUG
   for (const auto& layer : seedingLayers) {
     LogTrace("PixelInactiveAreaFinder") << "Input layer subdet " << std::get<0>(layer) << " side "
                                         << static_cast<unsigned int>(std::get<1>(layer)) << " layer "
                                         << std::get<2>(layer);
   }
 #endif
 
   auto findOrAdd = [&](SeedingLayerId layer) -> unsigned short {
     auto found = std::find(inactiveLayers_.cbegin(), inactiveLayers_.cend(), layer);
     if (found == inactiveLayers_.cend()) {
       auto ret = inactiveLayers_.size();
       inactiveLayers_.push_back(layer);
       return ret;
     }
     return std::distance(inactiveLayers_.cbegin(), found);
   };
 
   // mapping from active layer pairs to inactive layer pairs
   const auto activeToInactiveMap = createActiveToInactiveMap();
 
   // convert input layer pairs (that are for active layers) to layer
   // pairs to look for inactive areas
   LayerSetIndex i = 0;
   for (const auto& layerSet : seedingLayerSetsLooper.makeRange(seedingLayers)) {
     assert(layerSet.size() == 2);
     auto found = activeToInactiveMap.find(std::make_pair(layerSet[0], layerSet[1]));
     if (found == activeToInactiveMap.end()) {
       throw cms::Exception("Configuration")
           << "Encountered layer pair " << layerSet[0] << "+" << layerSet[1]
           << " not found from the internal 'active layer pairs' to 'inactive layer pairs' mapping; either fix the "
              "input or the mapping (in PixelInactiveAreaFinder.cc)";
     }
 
     LogTrace("PixelInactiveAreaFinder") << "Input layer set " << layerSet[0] << "+" << layerSet[1];
     for (const auto& inactiveLayerSet : found->second) {
       auto innerInd = findOrAdd(inactiveLayerSet.first);
       auto outerInd = findOrAdd(inactiveLayerSet.second);
 
       auto found = std::find(
           inactiveLayerSetIndices_.cbegin(), inactiveLayerSetIndices_.cend(), std::make_pair(innerInd, outerInd));
       if (found == inactiveLayerSetIndices_.end()) {
         inactiveLayerSetIndices_.emplace_back(innerInd, outerInd);
         layerSetIndexInactiveToActive_.push_back(std::vector<LayerSetIndex>{i});
       } else {
         layerSetIndexInactiveToActive_.at(std::distance(inactiveLayerSetIndices_.cbegin(), found))
             .push_back(i);  // TODO: move to operator[] once finished
       }
 
       LogTrace("PixelInactiveAreaFinder")
           << " inactive layer set " << inactiveLayerSet.first << "+" << inactiveLayerSet.second;
     }
 
     ++i;
   }
 
 #ifdef EDM_ML_DEBUG
   LogDebug("PixelInactiveAreaFinder") << "All inactive layer sets";
   for (const auto& idxPair : inactiveLayerSetIndices_) {
     LogTrace("PixelInactiveAreaFinder") << " " << inactiveLayers_[idxPair.first] << "+"
                                         << inactiveLayers_[idxPair.second];
   }
 #endif
 }

PixelInactiveAreaFinder::~PixelInactiveAreaFinder ( )

default

Member Function Documentation

PixelInactiveAreaFinder::DetGroup PixelInactiveAreaFinder::badAdjecentDetsBarrel ( const det_t & det )

private

Definition at line 898 of file PixelInactiveAreaFinder.cc.

References HltBtagPostValidation_cff::c, detWorks(), PVValHelper::ladder, nBPixLadders, nModulesPerLadder, and trackerTopology_.

Referenced by reachableDetGroup().

                                                                                                {
   using std::remove_if;
 
   DetGroup adj;
   auto const tTopo = trackerTopology_;
   auto const& detId = DetId(det);
   unsigned int layer = tTopo->pxbLayer(detId);
   unsigned int ladder = tTopo->pxbLadder(detId);
   unsigned int module = tTopo->pxbModule(detId);
   unsigned int nLads = nBPixLadders[layer];
   //add detectors from next and previous ladder
   adj.push_back(tTopo->pxbDetId(layer, ((ladder - 1) + 1) % nLads + 1, module)());
   adj.push_back(tTopo->pxbDetId(layer, ((ladder - 1) - 1 + nLads) % nLads + 1, module)());
   //add adjecent detectors from same ladder
   if (module == 1) {
     adj.push_back(tTopo->pxbDetId(layer, ladder, module + 1)());
   } else if (module == nModulesPerLadder) {
     adj.push_back(tTopo->pxbDetId(layer, ladder, module - 1)());
   } else {
     adj.push_back(tTopo->pxbDetId(layer, ladder, module + 1)());
     adj.push_back(tTopo->pxbDetId(layer, ladder, module - 1)());
   }
   //remove working detectors from list
   adj.erase(remove_if(adj.begin(), adj.end(), [&](auto c) { return this->detWorks(c); }), adj.end());
   return adj;
 }

PixelInactiveAreaFinder::DetGroup PixelInactiveAreaFinder::badAdjecentDetsEndcap ( const det_t & det )

private

Definition at line 924 of file PixelInactiveAreaFinder.cc.

References badPixelDetsEndcap_, TrackerGeometry::idToDet(), SequenceTypes::ignore(), Surface::phiSpan(), TrackerTopology::pxfDisk(), GeomDet::surface(), trackerGeometry_, trackerTopology_, and z.

Referenced by reachableDetGroup().

                                                                                                {
   // this might be faster if adjecent
   using std::ignore;
   using std::tie;
   DetGroup adj;
   Span_t phiSpan, phiSpanComp;
   float z, zComp;
   unsigned int disk, diskComp;
   auto const& detSurf = trackerGeometry_->idToDet(DetId(det))->surface();
   phiSpan = detSurf.phiSpan();
   tie(z, ignore) = detSurf.zSpan();
   disk = trackerTopology_->pxfDisk(DetId(det));
   // add detectors from same disk whose phi ranges overlap to the adjecent list
   for (auto const& detComp : badPixelDetsEndcap_) {
     auto const& detIdComp = DetId(detComp);
     auto const& detSurfComp = trackerGeometry_->idToDet(detIdComp)->surface();
     diskComp = trackerTopology_->pxfDisk(detIdComp);
     phiSpanComp = detSurfComp.phiSpan();
     tie(zComp, ignore) = detSurfComp.zSpan();
     if (det != detComp && disk == diskComp && z * zComp > 0 && phiRangesOverlap(phiSpan, phiSpanComp)) {
       adj.push_back(detComp);
     }
   }
   return adj;
 }

PixelInactiveAreaFinder::DetGroupContainer PixelInactiveAreaFinder::badDetGroupsBarrel ( )

private

Definition at line 978 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, and reachableDetGroup().

Referenced by detGroupSpans(), and printBadDetGroups().

                                                                                      {
   DetGroupContainer detGroups;
   DetectorSet foundDets;
   for (auto const& badDet : badPixelDetsBarrel_) {
     if (foundDets.find(badDet) == foundDets.end()) {
       detGroups.push_back(this->reachableDetGroup(badDet, foundDets));
     }
   }
   return detGroups;
 }

PixelInactiveAreaFinder::DetGroupContainer PixelInactiveAreaFinder::badDetGroupsEndcap ( )

private

Definition at line 988 of file PixelInactiveAreaFinder.cc.

References badPixelDetsEndcap_, ignoreSingleFPixPanelModules_, and reachableDetGroup().

Referenced by detGroupSpans(), and printBadDetGroups().

                                                                                      {
   DetGroupContainer detGroups;
   DetectorSet foundDets;
   for (auto const& badDet : badPixelDetsEndcap_) {
     if (foundDets.find(badDet) == foundDets.end()) {
       auto adjacentDets = this->reachableDetGroup(badDet, foundDets);
       if (ignoreSingleFPixPanelModules_ && adjacentDets.size() == 1) {
         // size==1 means that only a single panel of a blade was inactive
         // because of the large overlap with the other panel (i.e.
         // redundancy in the detectory) ignoring these may help to decrease fakes
         continue;
       }
       detGroups.push_back(adjacentDets);
     }
   }
   return detGroups;
 }

void PixelInactiveAreaFinder::createPlottingFiles ( )

private

Definition at line 852 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, detGroupSpans(), detInfo(), pixelDetsBarrel_, pixelDetsEndcap_, contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by inactiveAreas().

                                                   {
   // All detectors to file DETECTORS
   Stream ss;
   std::ofstream fsDet("DETECTORS.txt");
   for (auto const& det : pixelDetsBarrel_) {
     detInfo(det, ss);
     ss << std::endl;
   }
   edm::LogPrint("PixelInactiveAreaFinder") << "Endcap detectors;";
   for (auto const& det : pixelDetsEndcap_) {
     detInfo(det, ss);
     ss << std::endl;
   }
   fsDet << ss.rdbuf();
   ss.str(std::string());
   // Bad detectors
   std::ofstream fsBadDet("BADDETECTORS.txt");
   for (auto const& det : badPixelDetsBarrel_) {
     detInfo(det, ss);
     ss << std::endl;
   }
   for (auto const& det : badPixelDetsEndcap_) {
     detInfo(det, ss);
     ss << std::endl;
   }
   fsBadDet << ss.rdbuf();
   ss.str(std::string());
   // detgroupspans
   std::ofstream fsSpans("DETGROUPSPANS.txt");
   DetGroupSpanContainerPair cspans = detGroupSpans();
   for (auto const& cspan : cspans.first) {
     detGroupSpanInfo(cspan, ss);
     ss << std::endl;
   }
   for (auto const& cspan : cspans.second) {
     detGroupSpanInfo(cspan, ss);
     ss << std::endl;
   }
   fsSpans << ss.rdbuf();
   ss.str(std::string());
 }

PixelInactiveAreaFinder::DetGroupSpanContainerPair PixelInactiveAreaFinder::detGroupSpans ( )

private

Definition at line 1141 of file PixelInactiveAreaFinder.cc.

References badDetGroupsBarrel(), badDetGroupsEndcap(), and getSpan().

Referenced by createPlottingFiles(), inactiveAreas(), and printBadDetGroupSpans().

                                                                                         {
   DetGroupSpanContainer cspansBarrel;
   DetGroupSpanContainer cspansEndcap;
   DetGroupContainer badDetGroupsBar = badDetGroupsBarrel();
   DetGroupContainer badDetGroupsEnd = badDetGroupsEndcap();
   for (auto const& detGroup : badDetGroupsBar) {
     DetGroupSpan cspan;
     getSpan(detGroup, cspan);
     cspansBarrel.push_back(cspan);
   }
   for (auto const& detGroup : badDetGroupsEnd) {
     DetGroupSpan cspan;
     getSpan(detGroup, cspan);
     cspansEndcap.push_back(cspan);
   }
   return DetGroupSpanContainerPair(cspansBarrel, cspansEndcap);
 }

void PixelInactiveAreaFinder::detInfo	(	const det_t &	det,
		Stream &	ss
	)

private

Definition at line 738 of file PixelInactiveAreaFinder.cc.

References alignBH_cfg::fixed, TrackerGeometry::idToDet(), PVValHelper::ladder, Surface::phiSpan(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), TrackerTopology::pxfBlade(), TrackerTopology::pxfDisk(), TrackerTopology::pxfPanel(), AlCaHLTBitMon_QueryRunRegistry::string, DetId::subdetId(), GeomDet::surface(), trackerGeometry_, and trackerTopology_.

Referenced by createPlottingFiles(), printBadDetGroups(), printBadPixelDets(), and printPixelDets().

                                                                   {
   using std::fixed;
   using std::left;
   using std::noshowpos;
   using std::right;
   using std::setfill;
   using std::setprecision;
   using std::setw;
   using std::showpos;
   using std::tie;
   std::string deli = "; ";
   ss << "id:[" << det << "]" << deli;
   ss << "subdetid:[" << DetId(det).subdetId() << "]" << deli;
   if (DetId(det).subdetId() == PixelSubdetector::PixelBarrel) {
     unsigned int layer = trackerTopology_->pxbLayer(DetId(det));
     unsigned int ladder = trackerTopology_->pxbLadder(DetId(det));
     unsigned int module = trackerTopology_->pxbModule(DetId(det));
     ss << "layer:[" << layer << "]" << deli << "ladder:[" << right << setw(2) << ladder << "]" << deli << "module:["
        << module << "]" << deli;
   } else if (DetId(det).subdetId() == PixelSubdetector::PixelEndcap) {
     unsigned int disk = trackerTopology_->pxfDisk(DetId(det));
     unsigned int blade = trackerTopology_->pxfBlade(DetId(det));
     unsigned int panel = trackerTopology_->pxfPanel(DetId(det));
     ss << left << setw(6) << "disk:"
        << "[" << right << disk << "]" << deli << left << setw(7) << "blade:"
        << "[" << setw(2) << right << blade << "]" << deli << left << setw(7) << "panel:"
        << "[" << right << panel << "]" << deli;
   }
   float phiA, phiB, zA, zB, rA, rB;
   auto detSurface = trackerGeometry_->idToDet(DetId(det))->surface();
   tie(phiA, phiB) = detSurface.phiSpan();
   tie(zA, zB) = detSurface.zSpan();
   tie(rA, rB) = detSurface.rSpan();
   ss << setprecision(16) << fixed << showpos << setfill(' ') << "phi:[" << right << setw(12) << phiA << "," << left
      << setw(12) << phiB << "]" << deli << "z:[" << right << setw(7) << zA << "," << left << setw(7) << zB << "]"
      << deli << noshowpos << "r:[" << right << setw(10) << rA << "," << left << setw(10) << rB << "]" << deli;
 }

bool PixelInactiveAreaFinder::detWorks ( det_t det )

private

Definition at line 894 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, and spr::find().

Referenced by badAdjecentDetsBarrel().

                                                 {
   return std::find(badPixelDetsBarrel_.begin(), badPixelDetsBarrel_.end(), det) == badPixelDetsBarrel_.end() &&
          std::find(badPixelDetsEndcap_.begin(), badPixelDetsEndcap_.end(), det) == badPixelDetsEndcap_.end();
 }

void PixelInactiveAreaFinder::fillDescriptions ( edm::ParameterSetDescription & desc )

static

Definition at line 541 of file PixelInactiveAreaFinder.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), and HLT_2018_cff::InputTag.

Referenced by PixelInactiveAreaTrackingRegionsSeedingLayersProducer::fillDescriptions().

                                                                                {
   desc.add<std::vector<edm::InputTag>>("inactivePixelDetectorLabels",
                                        std::vector<edm::InputTag>{{edm::InputTag("siPixelDigis")}})
       ->setComment("One or more DetIdCollections of modules to mask on the fly for a given event");
   desc.add<std::vector<edm::InputTag>>("badPixelFEDChannelCollectionLabels",
                                        std::vector<edm::InputTag>{{edm::InputTag("siPixelDigis")}})
       ->setComment("One or more PixelFEDChannelCollections of modules+ROCs to mask on the fly for a given event");
   desc.add<bool>("ignoreSingleFPixPanelModules", false);
 
   desc.addUntracked<bool>("debug", false);
   desc.addUntracked<bool>("createPlottingFiles", false);
 }

void PixelInactiveAreaFinder::getBadPixelDets	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 691 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, badPixelFEDChannelsTokens_, edm::EventSetup::get(), SiPixelQuality::getBadComponentList(), edm::Event::getByToken(), triggerObjects_cff::id, inactivePixelDetectorTokens_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, unpackBuffers-CaloStage2::token, and tier0::unique().

Referenced by inactiveAreas().

                                                                                                  {
   auto addDetId = [&](const auto id) {
     const auto detid = DetId(id);
     const auto subdet = detid.subdetId();
     if (subdet == PixelSubdetector::PixelBarrel) {
       badPixelDetsBarrel_.push_back(detid.rawId());
     } else if (subdet == PixelSubdetector::PixelEndcap) {
       badPixelDetsEndcap_.push_back(detid.rawId());
     }
   };
 
   // SiPixelQuality
   edm::ESHandle<SiPixelQuality> pixelQuality;
   iSetup.get<SiPixelQualityRcd>().get(pixelQuality);
 
   for (auto const& disabledModule : pixelQuality->getBadComponentList()) {
     addDetId(disabledModule.DetID);
   }
 
   // dynamic bad modules
   for (const auto& token : inactivePixelDetectorTokens_) {
     edm::Handle<DetIdCollection> detIds;
     iEvent.getByToken(token, detIds);
     for (const auto& id : *detIds) {
       addDetId(id);
     }
   }
 
   // dynamic bad ROCs ("Fed25")
   // TODO: consider moving to finer-grained areas for inactive ROCs
   for (const auto& token : badPixelFEDChannelsTokens_) {
     edm::Handle<PixelFEDChannelCollection> pixelFEDChannelCollectionHandle;
     iEvent.getByToken(token, pixelFEDChannelCollectionHandle);
     for (const auto& disabledChannels : *pixelFEDChannelCollectionHandle) {
       addDetId(disabledChannels.detId());
     }
   }
 
   // remove duplicates
   std::sort(badPixelDetsBarrel_.begin(), badPixelDetsBarrel_.end());
   std::sort(badPixelDetsEndcap_.begin(), badPixelDetsEndcap_.end());
   badPixelDetsBarrel_.erase(std::unique(badPixelDetsBarrel_.begin(), badPixelDetsBarrel_.end()),
                             badPixelDetsBarrel_.end());
   badPixelDetsEndcap_.erase(std::unique(badPixelDetsEndcap_.begin(), badPixelDetsEndcap_.end()),
                             badPixelDetsEndcap_.end());
 }

void PixelInactiveAreaFinder::getPhiSpanBarrel	(	const DetGroup &	detGroup,
		DetGroupSpan &	cspan
	)

private

Definition at line 1006 of file PixelInactiveAreaFinder.cc.

References PixelInactiveAreaFinder::DetGroupSpan::disk, geometryDiff::epsilon, mps_fire::i, TrackerGeometry::idToDet(), createfilelist::int, PixelInactiveAreaFinder::DetGroupSpan::layer, nBPixLadders, PixelInactiveAreaFinder::DetGroupSpan::phiSpan, Surface::phiSpan(), TrackerTopology::pxbDetId(), TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), GeomDet::surface(), trackerGeometry_, trackerTopology_, and parallelization::uint.

Referenced by getSpan(), and printBadDetGroups().

                                                                                             {
   // find phiSpan using ordered vector of unique ladders in detGroup
   if (detGroup.empty()) {
     cspan = DetGroupSpan();
     return;
   } else {
     cspan.layer = trackerTopology_->pxbLayer(DetId(detGroup[0]));
     cspan.disk = 0;
   }
   using uint = unsigned int;
   using LadderSet = std::set<uint>;
   using LadVec = std::vector<uint>;
   LadderSet lads;
   for (auto const& det : detGroup) {
     lads.insert(trackerTopology_->pxbLadder(DetId(det)));
   }
   LadVec ladv(lads.begin(), lads.end());
   uint nLadders = nBPixLadders[cspan.layer];
   // find start ladder of detGroup
   uint i = 0;
   uint currentLadder = ladv[0];
   uint previousLadder = ladv[(ladv.size() + i - 1) % ladv.size()];
   // loop until discontinuity is found from vector
   while ((nLadders + currentLadder - 1) % nLadders == previousLadder) {
     ++i;
     currentLadder = ladv[i % ladv.size()];
     previousLadder = ladv[(ladv.size() + i - 1) % ladv.size()];
     if (i == ladv.size()) {
       cspan.phiSpan.first = std::numeric_limits<float>::epsilon();
       cspan.phiSpan.second = -std::numeric_limits<float>::epsilon();
       return;
     }
   }
   uint startLadder = currentLadder;
   uint endLadder = previousLadder;
   auto detStart = trackerTopology_->pxbDetId(cspan.layer, startLadder, 1);
   auto detEnd = trackerTopology_->pxbDetId(cspan.layer, endLadder, 1);
   cspan.phiSpan.first = trackerGeometry_->idToDet(detStart)->surface().phiSpan().first;
   cspan.phiSpan.second = trackerGeometry_->idToDet(detEnd)->surface().phiSpan().second;
 }

void PixelInactiveAreaFinder::getPhiSpanEndcap	(	const DetGroup &	detGroup,
		DetGroupSpan &	cspan
	)

private

Definition at line 1046 of file PixelInactiveAreaFinder.cc.

References counter, geometryDiff::epsilon, newFWLiteAna::found, PixelInactiveAreaFinder::DetGroupSpan::phiSpan, contentValuesCheck::ss, and trackerGeometry_.

Referenced by getSpan(), and printBadDetGroups().

                                                                                             {
   // this is quite naive/bruteforce method
   // 1) it starts by taking one detector from detGroup and starts to compare it to others
   // 2) when it finds overlapping detector in clockwise direction it starts comparing
   //    found detector to others
   // 3) search stops until no overlapping detectors in clockwise detector or all detectors
   //    have been work detector
   Stream ss;
   bool found = false;
   auto const tGeom = trackerGeometry_;
   DetGroup::const_iterator startDetIter = detGroup.begin();
   Span_t phiSpan, phiSpanComp;
   unsigned int counter = 0;
   while (!found) {
     phiSpan = tGeom->idToDet(DetId(*startDetIter))->surface().phiSpan();
     for (DetGroup::const_iterator compDetIter = detGroup.begin(); compDetIter != detGroup.end(); ++compDetIter) {
       phiSpanComp = tGeom->idToDet(DetId(*compDetIter))->surface().phiSpan();
       if (phiRangesOverlap(phiSpan, phiSpanComp) && phiMoreClockwise(phiSpanComp.first, phiSpan.first) &&
           startDetIter != compDetIter) {
         ++counter;
         if (counter > detGroup.size()) {
           cspan.phiSpan.first = std::numeric_limits<float>::epsilon();
           cspan.phiSpan.second = -std::numeric_limits<float>::epsilon();
           return;
         }
         startDetIter = compDetIter;
         break;
       } else if (compDetIter == detGroup.end() - 1) {
         found = true;
       }
     }
   }
   cspan.phiSpan.first = phiSpan.first;
   // second with same method}
   found = false;
   DetGroup::const_iterator endDetIter = detGroup.begin();
   counter = 0;
   while (!found) {
     phiSpan = tGeom->idToDet(DetId(*endDetIter))->surface().phiSpan();
     for (DetGroup::const_iterator compDetIter = detGroup.begin(); compDetIter != detGroup.end(); ++compDetIter) {
       phiSpanComp = tGeom->idToDet(DetId(*compDetIter))->surface().phiSpan();
       if (phiRangesOverlap(phiSpan, phiSpanComp) && phiMoreCounterclockwise(phiSpanComp.second, phiSpan.second) &&
           endDetIter != compDetIter) {
         ++counter;
         if (counter > detGroup.size()) {
           cspan.phiSpan.first = std::numeric_limits<float>::epsilon();
           cspan.phiSpan.second = -std::numeric_limits<float>::epsilon();
           return;
         }
         endDetIter = compDetIter;
         break;
       } else if (compDetIter == detGroup.end() - 1) {
         found = true;
       }
     }
   }
   cspan.phiSpan.second = phiSpan.second;
 }

void PixelInactiveAreaFinder::getRSpan	(	const DetGroup &	detGroup,
		DetGroupSpan &	cspan
	)

private

Definition at line 1114 of file PixelInactiveAreaFinder.cc.

References TrackerGeometry::idToDet(), PixelInactiveAreaFinder::DetGroupSpan::rSpan, Surface::rSpan(), GeomDet::surface(), and trackerGeometry_.

Referenced by getSpan(), and printBadDetGroups().

                                                                                     {
   auto cmpFun = [this](det_t detA, det_t detB) {
     return trackerGeometry_->idToDet(DetId(detA))->surface().rSpan().first <
            trackerGeometry_->idToDet(DetId(detB))->surface().rSpan().first;
   };
 
   auto minmaxIters = std::minmax_element(detGroup.begin(), detGroup.end(), cmpFun);
   cspan.rSpan.first = trackerGeometry_->idToDet(DetId(*(minmaxIters.first)))->surface().rSpan().first;
   cspan.rSpan.second = trackerGeometry_->idToDet(DetId(*(minmaxIters.second)))->surface().rSpan().second;
 }

void PixelInactiveAreaFinder::getSpan	(	const DetGroup &	detGroup,
		DetGroupSpan &	cspan
	)

private

Definition at line 1124 of file PixelInactiveAreaFinder.cc.

References PixelInactiveAreaFinder::DetGroupSpan::disk, getPhiSpanBarrel(), getPhiSpanEndcap(), getRSpan(), getZSpan(), PixelInactiveAreaFinder::DetGroupSpan::layer, TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), PixelInactiveAreaFinder::DetGroupSpan::subdetId, DetId::subdetId(), and trackerTopology_.

Referenced by detGroupSpans().

                                                                                    {
   auto firstDetIt = detGroup.begin();
   if (firstDetIt != detGroup.end()) {
     cspan.subdetId = DetId(*firstDetIt).subdetId();
     if (cspan.subdetId == 1) {
       cspan.layer = trackerTopology_->pxbLayer(DetId(*firstDetIt));
       cspan.disk = 0;
       getPhiSpanBarrel(detGroup, cspan);
     } else if (cspan.subdetId == 2) {
       cspan.disk = trackerTopology_->pxfDisk(DetId(*firstDetIt));
       cspan.layer = 0;
       getPhiSpanEndcap(detGroup, cspan);
     }
     getZSpan(detGroup, cspan);
     getRSpan(detGroup, cspan);
   }
 }

void PixelInactiveAreaFinder::getZSpan	(	const DetGroup &	detGroup,
		DetGroupSpan &	cspan
	)

private

Definition at line 1104 of file PixelInactiveAreaFinder.cc.

References TrackerGeometry::idToDet(), GeomDet::surface(), trackerGeometry_, PixelInactiveAreaFinder::DetGroupSpan::zSpan, and Surface::zSpan().

Referenced by getSpan(), and printBadDetGroups().

                                                                                     {
   auto cmpFun = [this](det_t detA, det_t detB) {
     return trackerGeometry_->idToDet(DetId(detA))->surface().zSpan().first <
            trackerGeometry_->idToDet(DetId(detB))->surface().zSpan().first;
   };
 
   auto minmaxIters = std::minmax_element(detGroup.begin(), detGroup.end(), cmpFun);
   cspan.zSpan.first = trackerGeometry_->idToDet(DetId(*(minmaxIters.first)))->surface().zSpan().first;
   cspan.zSpan.second = trackerGeometry_->idToDet(DetId(*(minmaxIters.second)))->surface().zSpan().second;
 }

PixelInactiveAreaFinder::InactiveAreas PixelInactiveAreaFinder::inactiveAreas	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

Definition at line 554 of file PixelInactiveAreaFinder.cc.

References Barrel, createPlottingFiles(), createPlottingFiles_, debug_, detGroupSpans(), HLT_2018_cff::distance, spr::find(), newFWLiteAna::found, edm::EventSetup::get(), getBadPixelDets(), inactiveLayers_, inactiveLayerSetIndices_, layerSetIndexInactiveToActive_, eostools::move(), NegEndcap, PixelSubdetector::PixelBarrel, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, PosEndcap, edm::ESHandle< T >::product(), runTheMatrix::ret, trackerGeometry_, trackerTopology_, and updatePixelDets().

Referenced by PixelInactiveAreaTrackingRegionsSeedingLayersProducer::produce().

                                                                                                            {
   // Set data to handles
   {
     edm::ESHandle<TrackerGeometry> trackerGeometry;
     iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
     trackerGeometry_ = trackerGeometry.product();
 
     edm::ESHandle<TrackerTopology> trackerTopology;
     iSetup.get<TrackerTopologyRcd>().get(trackerTopology);
     trackerTopology_ = trackerTopology.product();
   }
 
   // assign data to instance variables
   updatePixelDets(iSetup);
   getBadPixelDets(iEvent, iSetup);
 
   //write files for plotting
   if (createPlottingFiles_) {
     createPlottingFiles();
   }
 
   // find detGroupSpans ie phi,r,z limits for detector detGroups that are not working
   // returns pair where first is barrel spans and second endcap spans
   DetGroupSpanContainerPair cspans = detGroupSpans();
 
   // map spans to a vector with consistent indexing with inactiveLayers_ and inactiveLayerSetIndices_
   // TODO: try to move the inner logic towards this direction as well
   std::vector<DetGroupSpanContainer> spans(inactiveLayers_.size());
 
   auto doWork = [&](const DetGroupSpanContainer& container) {
     for (const auto& span : container) {
       const auto subdet = span.subdetId == PixelSubdetector::PixelBarrel ? GeomDetEnumerators::PixelBarrel
                                                                          : GeomDetEnumerators::PixelEndcap;
       const auto side = (subdet == GeomDetEnumerators::PixelBarrel
                              ? TrackerDetSide::Barrel
                              : (span.zSpan.first < 0 ? TrackerDetSide::NegEndcap : TrackerDetSide::PosEndcap));
       const auto layer = subdet == GeomDetEnumerators::PixelBarrel ? span.layer : span.disk;
       auto found = std::find(inactiveLayers_.begin(), inactiveLayers_.end(), SeedingLayerId(subdet, side, layer));
       if (found != inactiveLayers_.end()) {  // it is possible that this layer is ignored by the configuration
         spans[std::distance(inactiveLayers_.begin(), found)].push_back(span);
       }
     }
   };
   doWork(cspans.first);
   doWork(cspans.second);
 
   auto ret =
       InactiveAreas(&inactiveLayers_, std::move(spans), &inactiveLayerSetIndices_, &layerSetIndexInactiveToActive_);
 
   if (debug_) {
     printOverlapSpans(ret);
   }
 
   return ret;
 }

void PixelInactiveAreaFinder::printBadDetGroups ( )

private

Definition at line 805 of file PixelInactiveAreaFinder.cc.

References badDetGroupsBarrel(), badDetGroupsEndcap(), detInfo(), getPhiSpanBarrel(), getPhiSpanEndcap(), getRSpan(), getZSpan(), and contentValuesCheck::ss.

                                                 {
   DetGroupContainer badDetGroupsBar = badDetGroupsBarrel();
   DetGroupContainer badDetGroupsEnd = badDetGroupsEndcap();
   Stream ss;
   for (auto const& detGroup : badDetGroupsBar) {
     ss << std::setfill(' ') << std::left << std::setw(16) << "DetGroup:";
     DetGroupSpan cspan;
     getPhiSpanBarrel(detGroup, cspan);
     getZSpan(detGroup, cspan);
     getRSpan(detGroup, cspan);
     detGroupSpanInfo(cspan, ss);
     ss << std::endl;
     for (auto const& det : detGroup) {
       detInfo(det, ss);
       ss << std::endl;
     }
     ss << std::endl;
   }
   for (auto const& detGroup : badDetGroupsEnd) {
     ss << std::setfill(' ') << std::left << std::setw(16) << "DetGroup:";
     DetGroupSpan cspan;
     getPhiSpanEndcap(detGroup, cspan);
     getZSpan(detGroup, cspan);
     getRSpan(detGroup, cspan);
     detGroupSpanInfo(cspan, ss);
     ss << std::endl;
     for (auto const& det : detGroup) {
       detInfo(det, ss);
       ss << std::endl;
     }
     ss << std::endl;
   }
   edm::LogPrint("PixelInactiveAreaFinder") << ss.str();
 }

void PixelInactiveAreaFinder::printBadDetGroupSpans ( )

private

Definition at line 839 of file PixelInactiveAreaFinder.cc.

References detGroupSpans(), and contentValuesCheck::ss.

                                                     {
   DetGroupSpanContainerPair cspans = detGroupSpans();
   Stream ss;
   for (auto const& cspan : cspans.first) {
     detGroupSpanInfo(cspan, ss);
     ss << std::endl;
   }
   for (auto const& cspan : cspans.second) {
     detGroupSpanInfo(cspan, ss);
     ss << std::endl;
   }
   edm::LogPrint("PixelInactiveAreaFinder") << ss.str();
 }

void PixelInactiveAreaFinder::printBadPixelDets ( )

private

Definition at line 790 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, detInfo(), contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                 {
   edm::LogPrint("PixelInactiveAreaFinder") << "Bad barrel detectors:";
   Stream ss;
   for (auto const& det : badPixelDetsBarrel_) {
     detInfo(det, ss);
     edm::LogPrint("PixelInactiveAreaFinder") << ss.str();
     ss.str(std::string());
   }
   edm::LogPrint("PixelInactiveAreaFinder") << "Endcap detectors;";
   for (auto const& det : badPixelDetsEndcap_) {
     detInfo(det, ss);
     edm::LogPrint("PixelInactiveAreaFinder") << ss.str();
     ss.str(std::string());
   }
 }

void PixelInactiveAreaFinder::printPixelDets ( )

private

Definition at line 775 of file PixelInactiveAreaFinder.cc.

References detInfo(), pixelDetsBarrel_, pixelDetsEndcap_, contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

                                              {
   edm::LogPrint("PixelInactiveAreaFinder") << "Barrel detectors:";
   Stream ss;
   for (auto const& det : pixelDetsBarrel_) {
     detInfo(det, ss);
     edm::LogPrint("PixelInactiveAreaFinder") << ss.str();
     ss.str(std::string());
   }
   edm::LogPrint("PixelInactiveAreaFinder") << "Endcap detectors;";
   for (auto const& det : pixelDetsEndcap_) {
     detInfo(det, ss);
     edm::LogPrint("PixelInactiveAreaFinder") << ss.str();
     ss.str(std::string());
   }
 }

PixelInactiveAreaFinder::DetGroup PixelInactiveAreaFinder::reachableDetGroup	(	const det_t &	initDet,
		DetectorSet &	foundDets
	)

private

Definition at line 949 of file PixelInactiveAreaFinder.cc.

References badAdjecentDetsBarrel(), badAdjecentDetsEndcap(), PixelSubdetector::PixelBarrel, and PixelSubdetector::PixelEndcap.

Referenced by badDetGroupsBarrel(), and badDetGroupsEndcap().

                                                                                                      {
   DetGroup reachableDetGroup;
   std::queue<det_t> workQueue;
   det_t workDet;
   DetGroup badAdjDets;
   foundDets.insert(initDet);
   workQueue.push(initDet);
   reachableDetGroup.push_back(initDet);
   while (!workQueue.empty()) {
     workDet = workQueue.front();
     workQueue.pop();
     if (DetId(workDet).subdetId() == PixelSubdetector::PixelBarrel) {
       badAdjDets = this->badAdjecentDetsBarrel(workDet);
     } else if (DetId(workDet).subdetId() == PixelSubdetector::PixelEndcap) {
       badAdjDets = this->badAdjecentDetsEndcap(workDet);
     } else {
       badAdjDets = {};
     }
     for (auto const& badDet : badAdjDets) {
       if (foundDets.find(badDet) == foundDets.end()) {
         reachableDetGroup.push_back(badDet);
         foundDets.insert(badDet);
         workQueue.push(badDet);
       }
     }
   }
   return reachableDetGroup;
 }

void PixelInactiveAreaFinder::updatePixelDets ( const edm::EventSetup & iSetup )

private

Definition at line 612 of file PixelInactiveAreaFinder.cc.

References begin, edm::ESWatcher< T >::check(), dqmiodumpmetadata::counts, createPlottingFiles_, TrackerGeometry::detsPXB(), TrackerGeometry::detsPXF(), end, Exception, geometryWatcher_, PVValHelper::ladder, TrackerTopology::layer(), LogDebug, LogTrace, nBPixLadders, nModulesPerLadder, TrackerGeometry::numberOfLayers(), PixelSubdetector::PixelBarrel, pixelDetsBarrel_, pixelDetsEndcap_, PixelSubdetector::PixelEndcap, TrackerTopology::pxbLadder(), trackerGeometry_, trackerTopology_, and heppy_batch::val.

Referenced by inactiveAreas().

                                                                          {
   if (!geometryWatcher_.check(iSetup))
     return;
 
   // deduce the number of ladders per layer and the number of modules per ladder
   {
     // sanity checks
     if (trackerGeometry_->numberOfLayers(PixelSubdetector::PixelBarrel) != 4) {
       throw cms::Exception("NotImplemented")
           << "This module supports only a detector with 4 pixel barrel layers, the current geometry has "
           << trackerGeometry_->numberOfLayers(PixelSubdetector::PixelBarrel);
     }
     if (trackerGeometry_->numberOfLayers(PixelSubdetector::PixelEndcap) != 3) {
       throw cms::Exception("NotImplemented")
           << "This module supports only a detector with 3 pixel forward disks, the current geometry has "
           << trackerGeometry_->numberOfLayers(PixelSubdetector::PixelEndcap);
     }
 
     std::array<std::array<unsigned short, 100>, 4> counts = {};  // assume at most 100 ladders per layer
     for (const auto& det : trackerGeometry_->detsPXB()) {
       const auto layer = trackerTopology_->layer(det->geographicalId());
       const auto ladder = trackerTopology_->pxbLadder(det->geographicalId());
       if (ladder >= 100) {
         throw cms::Exception("LogicError")
             << "Got a ladder with number " << ladder
             << " while the expected maximum was 100; either something is wrong or the maximum has to be increased.";
       }
       counts[layer - 1][ladder - 1] += 1;  // numbering of layer and ladder starts at 1
     }
 
     // take number of modules per ladder from the first ladder of the first layer (such better exist)
     // other ladders better have the same number
     nModulesPerLadder = counts[0][0];
     if (nModulesPerLadder == 0) {
       throw cms::Exception("LogicError") << "Ladder 1 of layer 1 has 0 modules, something fishy is going on.";
     }
 
     LogDebug("PixelInactiveAreaFinder") << "Number of modules per ladder " << nModulesPerLadder
                                         << "; below are number of ladders per layer";
 
     // number of ladders
     for (unsigned layer = 0; layer < 4; ++layer) {
       nBPixLadders[layer] =
           std::count_if(counts[layer].begin(), counts[layer].end(), [](unsigned short val) { return val > 0; });
       LogTrace("PixelInactiveAreaFinder")
           << "BPix layer " << (layer + 1) << " has " << nBPixLadders[layer] << " ladders";
 
       auto fail = std::count_if(counts[layer].begin(), counts[layer].end(), [&](unsigned short val) {
         return val != nModulesPerLadder && val > 0;
       });
       if (fail != 0) {
         throw cms::Exception("LogicError")
             << "Layer " << (layer + 1) << " had " << fail
             << " ladders whose number of modules/ladder differed from the ladder 1 of layer 1 (" << nModulesPerLadder
             << "). Something fishy is going on.";
       }
     }
   }
 
   // don't bother with the rest if not needed
   if (!createPlottingFiles_)
     return;
 
   pixelDetsBarrel_.clear();
   pixelDetsEndcap_.clear();
 
   for (auto const& geomDetPtr : trackerGeometry_->detsPXB()) {
     if (geomDetPtr->geographicalId().subdetId() == PixelSubdetector::PixelBarrel) {
       pixelDetsBarrel_.push_back(geomDetPtr->geographicalId().rawId());
     }
   }
   for (auto const& geomDetPtr : trackerGeometry_->detsPXF()) {
     if (geomDetPtr->geographicalId().subdetId() == PixelSubdetector::PixelEndcap) {
       pixelDetsEndcap_.push_back(geomDetPtr->geographicalId().rawId());
     }
   }
   std::sort(pixelDetsBarrel_.begin(), pixelDetsBarrel_.end());
   std::sort(pixelDetsEndcap_.begin(), pixelDetsEndcap_.end());
 }