#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 100 of file PixelInactiveAreaFinder.h.

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

private

Definition at line 101 of file PixelInactiveAreaFinder.h.

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

private

Definition at line 104 of file PixelInactiveAreaFinder.h.

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

private

Definition at line 102 of file PixelInactiveAreaFinder.h.

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

private

Definition at line 103 of file PixelInactiveAreaFinder.h.

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

Definition at line 42 of file PixelInactiveAreaFinder.h.

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

private

Definition at line 93 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 94 of file PixelInactiveAreaFinder.h.

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

private

Definition at line 95 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 105 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 437 of file PixelInactiveAreaFinder.cc.

References badPixelFEDChannelsTokens_, SoftLeptonByDistance_cfi::distance, Exception, spr::find(), runEdmFileComparison::found, mps_fire::i, inactiveLayers_, inactiveLayerSetIndices_, layerSetIndexInactiveToActive_, LogDebug, LogTrace, HiRegitMuonDetachedTripletStep_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 846 of file PixelInactiveAreaFinder.cc.

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

Referenced by reachableDetGroup().

                                                                                                {
   using std::remove_if;
   using std::bind1st;
   using std::mem_fun;
 
   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(),bind1st(
                                                     mem_fun(&PixelInactiveAreaFinder::detWorks),this)),adj.end());
   return adj;
 }

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

private

Definition at line 877 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::tie;
   using std::ignore;
   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 930 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 940 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 796 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, detGroupSpans(), detInfo(), pixelDetsBarrel_, pixelDetsEndcap_, 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 1101 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 684 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::tie;
   using std::setw;
   using std::showpos;
   using std::noshowpos;
   using std::fixed;
   using std::right;
   using std::left;
   using std::setprecision;
   using std::setfill;
   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 837 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 504 of file PixelInactiveAreaFinder.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), and edm::ParameterDescriptionNode::setComment().

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>())->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 638 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, badPixelFEDChannelsTokens_, edm::EventSetup::get(), SiPixelQuality::getBadComponentList(), edm::Event::getByToken(), triggerObjects_cff::id, inactivePixelDetectorTokens_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, 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 958 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 998 of file PixelInactiveAreaFinder.cc.

References counter, geometryDiff::epsilon, runEdmFileComparison::found, PixelInactiveAreaFinder::DetGroupSpan::phiSpan, 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 1071 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 1084 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 1058 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 515 of file PixelInactiveAreaFinder.cc.

References Barrel, createPlottingFiles(), createPlottingFiles_, debug_, detGroupSpans(), SoftLeptonByDistance_cfi::distance, spr::find(), runEdmFileComparison::found, edm::EventSetup::get(), getBadPixelDets(), inactiveLayers_, inactiveLayerSetIndices_, layerSetIndexInactiveToActive_, eostools::move(), NegEndcap, PixelSubdetector::PixelBarrel, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, PosEndcap, edm::ESHandle< T >::product(), 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 753 of file PixelInactiveAreaFinder.cc.

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

                                                {
   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 785 of file PixelInactiveAreaFinder.cc.

References detGroupSpans().

                                                    {
   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 740 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, detInfo(), 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 727 of file PixelInactiveAreaFinder.cc.

References detInfo(), pixelDetsBarrel_, pixelDetsEndcap_, 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 903 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 572 of file PixelInactiveAreaFinder.cc.

References begin, edm::ESWatcher< T >::check(), createPlottingFiles_, TrackerGeometry::detsPXB(), TrackerGeometry::detsPXF(), end, Exception, cmsPerfPublish::fail(), 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());
 }