PixelInactiveAreaFinder Class Reference

#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_ = nullptr
edm::ESGetToken< SiPixelQuality, SiPixelQualityRcd >	pixelQualityToken_
const TrackerGeometry *	trackerGeometry_ = nullptr
edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryToken_
const TrackerTopology *	trackerTopology_ = nullptr
edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	trackerTopologyToken_

Detailed Description

Definition at line 23 of file PixelInactiveAreaFinder.h.

Member Typedef Documentation

Area

using PixelInactiveAreaFinder::Area = AreaSeededTrackingRegionsBuilder::Area

Definition at line 25 of file PixelInactiveAreaFinder.h.

det_t

using PixelInactiveAreaFinder::det_t = uint32_t

private

Definition at line 104 of file PixelInactiveAreaFinder.h.

DetContainer

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

private

Definition at line 105 of file PixelInactiveAreaFinder.h.

DetectorSet

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

private

Definition at line 108 of file PixelInactiveAreaFinder.h.

DetGroup

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

private

Definition at line 106 of file PixelInactiveAreaFinder.h.

DetGroupContainer

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

private

Definition at line 107 of file PixelInactiveAreaFinder.h.

DetGroupSpanContainer

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

Definition at line 38 of file PixelInactiveAreaFinder.h.

DetGroupSpanContainerPair

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

private

Definition at line 97 of file PixelInactiveAreaFinder.h.

LayerSetIndex

using PixelInactiveAreaFinder::LayerSetIndex = SeedingLayerSetsHits::LayerSetIndex

Definition at line 27 of file PixelInactiveAreaFinder.h.

OverlapSpans

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

private

Definition at line 98 of file PixelInactiveAreaFinder.h.

OverlapSpansContainer

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

private

Definition at line 99 of file PixelInactiveAreaFinder.h.

SeedingLayerId

using PixelInactiveAreaFinder::SeedingLayerId = SeedingLayerSetsBuilder::SeedingLayerId

Definition at line 26 of file PixelInactiveAreaFinder.h.

Stream

using PixelInactiveAreaFinder::Stream = std::stringstream

private

Definition at line 109 of file PixelInactiveAreaFinder.h.

Constructor & Destructor Documentation

PixelInactiveAreaFinder()

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

Definition at line 459 of file PixelInactiveAreaFinder.cc.

References makeGlobalPositionRcd_cfg::tag.

    : 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); })),
      trackerGeometryToken_(iC.esConsumes()),
      trackerTopologyToken_(iC.esConsumes()),
      pixelQualityToken_(iC.esConsumes()) {
#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::~PixelInactiveAreaFinder ( )

default

Member Function Documentation

badAdjecentDetsBarrel()

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

private

Definition at line 894 of file PixelInactiveAreaFinder.cc.

References HltBtagPostValidation_cff::c, hcalRecHitTable_cff::detId, detWorks(), PVValHelper::ladder, nano_mu_digi_cff::layer, 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;
}

badAdjecentDetsEndcap()

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

private

Definition at line 920 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;
}

badDetGroupsBarrel()

PixelInactiveAreaFinder::DetGroupContainer PixelInactiveAreaFinder::badDetGroupsBarrel ( )

private

Definition at line 974 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;
}

badDetGroupsEndcap()

PixelInactiveAreaFinder::DetGroupContainer PixelInactiveAreaFinder::badDetGroupsEndcap ( )

private

Definition at line 984 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;
}

createPlottingFiles()

void PixelInactiveAreaFinder::createPlottingFiles ( )

private

Definition at line 848 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());
}

detGroupSpans()

PixelInactiveAreaFinder::DetGroupSpanContainerPair PixelInactiveAreaFinder::detGroupSpans ( )

private

Definition at line 1137 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);
}

detInfo()

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

private

Definition at line 734 of file PixelInactiveAreaFinder.cc.

References alignBH_cfg::fixed, TrackerGeometry::idToDet(), PVValHelper::ladder, nano_mu_digi_cff::layer, Surface::phiSpan(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), TrackerTopology::pxfBlade(), TrackerTopology::pxfDisk(), TrackerTopology::pxfPanel(), contentValuesCheck::ss, 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;
}

detWorks()

bool PixelInactiveAreaFinder::detWorks ( det_t  det )

private

Definition at line 890 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();
}

fillDescriptions()

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

static

Definition at line 541 of file PixelInactiveAreaFinder.cc.

References submitPVResolutionJobs::desc, and ProducerED_cfi::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);
}

getBadPixelDets()

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

private

Definition at line 688 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, badPixelFEDChannelsTokens_, edm::EventSetup::getData(), l1ctLayer2EG_cff::id, iEvent, inactivePixelDetectorTokens_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, pixelQualityToken_, jetUpdater_cfi::sort, 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
  auto const& pixelQuality = iSetup.getData(pixelQualityToken_);

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

getPhiSpanBarrel()

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

private

Definition at line 1002 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;
}

getPhiSpanEndcap()

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

private

Definition at line 1042 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;
}

getRSpan()

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

private

Definition at line 1110 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;
}

getSpan()

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

private

Definition at line 1120 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);
  }
}

getZSpan()

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

private

Definition at line 1100 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;
}

inactiveAreas()

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

Definition at line 554 of file PixelInactiveAreaFinder.cc.

References badPixelDetsBarrel_, badPixelDetsEndcap_, Barrel, createPlottingFiles(), createPlottingFiles_, debug_, detGroupSpans(), HLT_2023v12_cff::distance, spr::find(), newFWLiteAna::found, getBadPixelDets(), edm::EventSetup::getData(), iEvent, inactiveLayers_, inactiveLayerSetIndices_, nano_mu_digi_cff::layer, layerSetIndexInactiveToActive_, eostools::move(), NegEndcap, GeomDetEnumerators::PixelBarrel, PixelSubdetector::PixelBarrel, GeomDetEnumerators::PixelEndcap, PosEndcap, push_back(), runTheMatrix::ret, trackerGeometry_, trackerGeometryToken_, trackerTopology_, trackerTopologyToken_, and updatePixelDets().

Referenced by PixelInactiveAreaTrackingRegionsSeedingLayersProducer::produce().

                                                                                                           {
  // Set data to handles
  trackerGeometry_ = &iSetup.getData(trackerGeometryToken_);
  trackerTopology_ = &iSetup.getData(trackerTopologyToken_);

  // assign data to instance variables
  updatePixelDets(iSetup);

  // clear the list of bad pixel modules at each event!
  badPixelDetsBarrel_.clear();
  badPixelDetsEndcap_.clear();
  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;
}

printBadDetGroups()

void PixelInactiveAreaFinder::printBadDetGroups ( )

private

Definition at line 801 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();
}

printBadDetGroupSpans()

void PixelInactiveAreaFinder::printBadDetGroupSpans ( )

private

Definition at line 835 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();
}

printBadPixelDets()

void PixelInactiveAreaFinder::printBadPixelDets ( )

private

Definition at line 786 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());
  }
}

printPixelDets()

void PixelInactiveAreaFinder::printPixelDets ( )

private

Definition at line 771 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());
  }
}

reachableDetGroup()

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

private

Definition at line 945 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;
}

updatePixelDets()

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

private

Definition at line 609 of file PixelInactiveAreaFinder.cc.

References edm::ESWatcher< T >::check(), dqmiodumpmetadata::counts, createPlottingFiles_, TrackerGeometry::detsPXB(), TrackerGeometry::detsPXF(), mps_fire::end, Exception, geometryWatcher_, PVValHelper::ladder, nano_mu_digi_cff::layer, TrackerTopology::layer(), LogDebug, LogTrace, nBPixLadders, nModulesPerLadder, TrackerGeometry::numberOfLayers(), PixelSubdetector::PixelBarrel, pixelDetsBarrel_, pixelDetsEndcap_, PixelSubdetector::PixelEndcap, TrackerTopology::pxbLadder(), jetUpdater_cfi::sort, 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());
}

Member Data Documentation

badPixelDetsBarrel_

DetContainer PixelInactiveAreaFinder::badPixelDetsBarrel_

private

Definition at line 119 of file PixelInactiveAreaFinder.h.

Referenced by badDetGroupsBarrel(), createPlottingFiles(), detWorks(), getBadPixelDets(), inactiveAreas(), and printBadPixelDets().

badPixelDetsEndcap_

DetContainer PixelInactiveAreaFinder::badPixelDetsEndcap_

private

Definition at line 120 of file PixelInactiveAreaFinder.h.

Referenced by badAdjecentDetsEndcap(), badDetGroupsEndcap(), createPlottingFiles(), detWorks(), getBadPixelDets(), inactiveAreas(), and printBadPixelDets().

badPixelFEDChannelsTokens_

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

private

Definition at line 91 of file PixelInactiveAreaFinder.h.

Referenced by getBadPixelDets().

createPlottingFiles_

const bool PixelInactiveAreaFinder::createPlottingFiles_

private

Definition at line 82 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas(), and updatePixelDets().

debug_

const bool PixelInactiveAreaFinder::debug_

private

Definition at line 81 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas().

geometryWatcher_

edm::ESWatcher<TrackerDigiGeometryRecord> PixelInactiveAreaFinder::geometryWatcher_

private

Definition at line 111 of file PixelInactiveAreaFinder.h.

Referenced by updatePixelDets().

ignoreSingleFPixPanelModules_

const bool PixelInactiveAreaFinder::ignoreSingleFPixPanelModules_

private

Definition at line 83 of file PixelInactiveAreaFinder.h.

Referenced by badDetGroupsEndcap().

inactiveLayers_

std::vector<SeedingLayerId> PixelInactiveAreaFinder::inactiveLayers_

private

Definition at line 85 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas().

inactiveLayerSetIndices_

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

private

Definition at line 86 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas().

inactivePixelDetectorTokens_

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

private

Definition at line 90 of file PixelInactiveAreaFinder.h.

Referenced by getBadPixelDets().

layerSetIndexInactiveToActive_

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

private

Definition at line 88 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas(), and PixelInactiveAreaFinder::InactiveAreas::spansAndLayerSets().

nBPixLadders

std::array<unsigned short, 4> PixelInactiveAreaFinder::nBPixLadders

private

Definition at line 101 of file PixelInactiveAreaFinder.h.

Referenced by badAdjecentDetsBarrel(), getPhiSpanBarrel(), and updatePixelDets().

nModulesPerLadder

unsigned short PixelInactiveAreaFinder::nModulesPerLadder

private

Definition at line 102 of file PixelInactiveAreaFinder.h.

Referenced by badAdjecentDetsBarrel(), and updatePixelDets().

pixelDetsBarrel_

DetContainer PixelInactiveAreaFinder::pixelDetsBarrel_

private

Definition at line 117 of file PixelInactiveAreaFinder.h.

Referenced by createPlottingFiles(), printPixelDets(), and updatePixelDets().

pixelDetsEndcap_

DetContainer PixelInactiveAreaFinder::pixelDetsEndcap_

private

Definition at line 118 of file PixelInactiveAreaFinder.h.

Referenced by createPlottingFiles(), printPixelDets(), and updatePixelDets().

pixelQuality_

const SiPixelQuality* PixelInactiveAreaFinder::pixelQuality_ = nullptr

private

Definition at line 113 of file PixelInactiveAreaFinder.h.

pixelQualityToken_

edm::ESGetToken<SiPixelQuality, SiPixelQualityRcd> PixelInactiveAreaFinder::pixelQualityToken_

private

Definition at line 94 of file PixelInactiveAreaFinder.h.

Referenced by getBadPixelDets().

trackerGeometry_

const TrackerGeometry* PixelInactiveAreaFinder::trackerGeometry_ = nullptr

private

Definition at line 114 of file PixelInactiveAreaFinder.h.

Referenced by badAdjecentDetsEndcap(), detInfo(), getPhiSpanBarrel(), getPhiSpanEndcap(), getRSpan(), getZSpan(), inactiveAreas(), and updatePixelDets().

trackerGeometryToken_

edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> PixelInactiveAreaFinder::trackerGeometryToken_

private

Definition at line 92 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas().

trackerTopology_

const TrackerTopology* PixelInactiveAreaFinder::trackerTopology_ = nullptr

private

Definition at line 115 of file PixelInactiveAreaFinder.h.

Referenced by badAdjecentDetsBarrel(), badAdjecentDetsEndcap(), detInfo(), getPhiSpanBarrel(), getSpan(), inactiveAreas(), and updatePixelDets().

trackerTopologyToken_

edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> PixelInactiveAreaFinder::trackerTopologyToken_

private

Definition at line 93 of file PixelInactiveAreaFinder.h.

Referenced by inactiveAreas().