#include <StubKiller.h>

Public Types
enum	KillOptions { KillOptions::none = 0, KillOptions::layer5 = 1, KillOptions::layer1 = 2, KillOptions::layer1layer2 = 3, KillOptions::layer1disk1 = 4, KillOptions::random = 5 }

Public Member Functions
bool	killStub (const TTStub< Ref_Phase2TrackerDigi_ > *stub) const

bool	killStub (const TTStub< Ref_Phase2TrackerDigi_ > *stub, const std::vector< int > &layersToKill, const double minPhiToKill, const double maxPhiToKill, const double minZToKill, const double maxZToKill, const double minRToKill, const double maxRToKill, const double fractionOfStubsToKillInLayers, const double fractionOfStubsToKillEverywhere) const

bool	killStubInDeadModule (const TTStub< Ref_Phase2TrackerDigi_ > *stub) const

const std::map< DetId, float > &	listOfDeadModules () const

	StubKiller (KillOptions killScenario, const TrackerTopology trackerTopology, const TrackerGeometry trackerGeometry, const edm::Event &iEvent)

Private Member Functions
void	addDeadLayerModulesToDeadModuleList ()

void	chooseModulesToKill ()

Private Attributes
std::map< DetId, float >	deadModules_

double	fractionOfModulesToKillEverywhere_

double	fractionOfStubsToKillEverywhere_

double	fractionOfStubsToKillInLayers_

KillOptions	killScenario_

std::vector< int >	layersToKill_

double	maxPhiToKill_

double	maxRToKill_

double	maxZToKill_

double	minPhiToKill_

double	minRToKill_

double	minZToKill_

CLHEP::HepRandomEngine *	rndmEngine_

edm::Service< edm::RandomNumberGenerator >	rndmService_

const TrackerGeometry *	trackerGeometry_

const TrackerTopology *	trackerTopology_

Detailed Description

Definition at line 20 of file StubKiller.h.

Member Enumeration Documentation

◆ KillOptions

enum tmtt::StubKiller::KillOptions

strong

Enumerator
none
layer5
layer1
layer1layer2
layer1disk1
random

Definition at line 22 of file StubKiller.h.

22 { none = 0, layer5 = 1, layer1 = 2, layer1layer2 = 3, layer1disk1 = 4, random = 5 };

none

Definition: EcalBoundaryInfoCalculator.h:23

Constructor & Destructor Documentation

◆ StubKiller()

StubKiller::StubKiller	(	StubKiller::KillOptions	killScenario,
		const TrackerTopology *	trackerTopology,
		const TrackerGeometry *	trackerGeometry,
		const edm::Event &	iEvent
	)

Definition at line 9 of file StubKiller.cc.

References addDeadLayerModulesToDeadModuleList(), chooseModulesToKill(), deadModules_, Exception, fractionOfModulesToKillEverywhere_, fractionOfStubsToKillEverywhere_, fractionOfStubsToKillInLayers_, edm::RandomNumberGenerator::getEngine(), edm::Service< T >::isAvailable(), killScenario_, layer1, layer1disk1, layer1layer2, layer5, layersToKill_, M_PI, maxPhiToKill_, maxRToKill_, maxZToKill_, minPhiToKill_, minRToKill_, minZToKill_, random, rndmEngine_, and rndmService_.

       : killScenario_(killScenario),
         trackerTopology_(trackerTopology),
         trackerGeometry_(trackerGeometry),
         minPhiToKill_(0),
         maxPhiToKill_(0),
         minZToKill_(0),
         maxZToKill_(0),
         minRToKill_(0),
         maxRToKill_(0),
         fractionOfStubsToKillInLayers_(0),
         fractionOfStubsToKillEverywhere_(0),
         fractionOfModulesToKillEverywhere_(0) {
     if (rndmService_.isAvailable()) {
       rndmEngine_ = &(rndmService_->getEngine(event.streamID()));
     } else {
       throw cms::Exception("BadConfig")
           << "StubKiller: requires RandomNumberGeneratorService, not present in cfg file, namely:" << endl
           << "process.RandomNumberGeneratorService=cms.Service('RandomNumberGeneratorService',TMTrackProducer=cms.PSet("
              "initialSeed=cms.untracked.uint32(12345)))";
     }
 
     // These scenarios correspond to slide 12 of  https://indico.cern.ch/event/719985/contributions/2970687/attachments/1634587/2607365/StressTestTF-Acosta-Apr18.pdf
     // Scenario 1
 
     // kill layer 5 in one quadrant +5 % random module loss to connect to what was done before
     if (killScenario_ == KillOptions::layer5) {
       layersToKill_ = {5};
       minPhiToKill_ = 0;
       maxPhiToKill_ = 0.5 * M_PI;
       minZToKill_ = -1000;
       maxZToKill_ = 0;
       minRToKill_ = 0;
       maxRToKill_ = 1000;
       fractionOfStubsToKillInLayers_ = 1;
       fractionOfStubsToKillEverywhere_ = 0;
       fractionOfModulesToKillEverywhere_ = 0.05;
     }
     // Scenario 2
     // kill layer 1 in one quadrant +5 % random module loss
     else if (killScenario_ == KillOptions::layer1) {
       layersToKill_ = {1};
       minPhiToKill_ = 0;
       maxPhiToKill_ = 0.5 * M_PI;
       minZToKill_ = -1000;
       maxZToKill_ = 0;
       minRToKill_ = 0;
       maxRToKill_ = 1000;
       fractionOfStubsToKillInLayers_ = 1;
       fractionOfStubsToKillEverywhere_ = 0;
       fractionOfModulesToKillEverywhere_ = 0.05;
     }
     // Scenario 3
     // kill layer 1 + layer 2, both in same quadrant
     else if (killScenario_ == KillOptions::layer1layer2) {
       layersToKill_ = {1, 2};
       minPhiToKill_ = 0;
       maxPhiToKill_ = 0.5 * M_PI;
       minZToKill_ = -1000;
       maxZToKill_ = 0;
       minRToKill_ = 0;
       maxRToKill_ = 1000;
       fractionOfStubsToKillInLayers_ = 1;
       fractionOfStubsToKillEverywhere_ = 0;
       fractionOfModulesToKillEverywhere_ = 0;
     }
     // Scenario 4
     // kill layer 1 and disk 1, both in same quadrant
     else if (killScenario_ == KillOptions::layer1disk1) {
       layersToKill_ = {1, 11};
       minPhiToKill_ = 0;
       maxPhiToKill_ = 0.5 * M_PI;
       minZToKill_ = -1000;
       maxZToKill_ = 0;
       minRToKill_ = 0;
       maxRToKill_ = 66.5;
       fractionOfStubsToKillInLayers_ = 1;
       fractionOfStubsToKillEverywhere_ = 0;
       fractionOfModulesToKillEverywhere_ = 0;
     }
     // An extra scenario not listed in the slides
     // 5% random module loss throughout tracker
     else if (killScenario_ == KillOptions::random) {
       layersToKill_ = {};
       fractionOfStubsToKillInLayers_ = 0;
       fractionOfStubsToKillEverywhere_ = 0.;
       fractionOfModulesToKillEverywhere_ = 0.05;
     }
 
     deadModules_.clear();
     if (fractionOfModulesToKillEverywhere_ > 0) {
       this->chooseModulesToKill();
     }
     this->addDeadLayerModulesToDeadModuleList();
   }

Member Function Documentation

◆ addDeadLayerModulesToDeadModuleList()

void StubKiller::addDeadLayerModulesToDeadModuleList ( )

private

Definition at line 239 of file StubKiller.cc.

References deadModules_, reco::deltaPhi(), TrackerGeometry::detUnits(), spr::find(), fractionOfStubsToKillInLayers_, TrackerTopology::layer(), layersToKill_, maxRToKill_, maxZToKill_, minPhiToKill_, minRToKill_, minZToKill_, TrackerTopology::side(), DetId::subdetId(), StripSubdetector::TIB, TrackerTopology::tidWheel(), StripSubdetector::TOB, trackerGeometry_, and trackerTopology_.

Referenced by StubKiller().

                                                        {
     for (const GeomDetUnit* gd : trackerGeometry_->detUnits()) {
       float moduleR = gd->position().perp();
       float moduleZ = gd->position().z();
       float modulePhi = reco::deltaPhi(gd->position().phi(), 0.);
       DetId geoDetId = gd->geographicalId();
       bool isInBarrel = geoDetId.subdetId() == StripSubdetector::TOB || geoDetId.subdetId() == StripSubdetector::TIB;
 
       int layerID = 0;
       if (isInBarrel) {
         layerID = trackerTopology_->layer(geoDetId);
       } else {
         layerID = 10 * trackerTopology_->side(geoDetId) + trackerTopology_->tidWheel(geoDetId);
       }
       if (find(layersToKill_.begin(), layersToKill_.end(), layerID) != layersToKill_.end()) {
         if (modulePhi > minPhiToKill_ && modulePhi < maxPhiToKill_ && moduleZ > minZToKill_ && moduleZ < maxZToKill_ &&
             moduleR > minRToKill_ && moduleR < maxRToKill_) {
           if (deadModules_.find(gd->geographicalId()) == deadModules_.end()) {
             deadModules_[gd->geographicalId()] = fractionOfStubsToKillInLayers_;
           }
         }
       }
     }
   }

◆ chooseModulesToKill()

void StubKiller::chooseModulesToKill ( )

private

Definition at line 227 of file StubKiller.cc.

References deadModules_, TrackerGeometry::detUnits(), fractionOfModulesToKillEverywhere_, TrackerTopology::isLower(), rndmEngine_, trackerGeometry_, and trackerTopology_.

Referenced by StubKiller().

                                        {
     for (const GeomDetUnit* gd : trackerGeometry_->detUnits()) {
       if (!trackerTopology_->isLower(gd->geographicalId()))
         continue;
       if (rndmEngine_->flat() < fractionOfModulesToKillEverywhere_) {
         deadModules_[gd->geographicalId()] = 1;
       }
     }
   }

◆ killStub() [1/2]

bool StubKiller::killStub ( const TTStub< Ref_Phase2TrackerDigi_ > * stub ) const

Definition at line 110 of file StubKiller.cc.

References fractionOfStubsToKillEverywhere_, fractionOfStubsToKillInLayers_, killScenario_, killStubInDeadModule(), layersToKill_, maxPhiToKill_, maxRToKill_, maxZToKill_, minPhiToKill_, minRToKill_, minZToKill_, and none.

Referenced by tmtt::Stub::setFrontend().

                                                                             {
     if (killScenario_ == KillOptions::none)
       return false;
     else {
       // Check if stub is in dead region specified by *ToKill_
       // And randomly kill stubs throughout tracker (not just thos in specific regions/modules)
       bool killStubRandomly = killStub(stub,
                                        layersToKill_,
                                        minPhiToKill_,
                                        maxPhiToKill_,
                                        minZToKill_,
                                        maxZToKill_,
                                        minRToKill_,
                                        maxRToKill_,
                                        fractionOfStubsToKillInLayers_,
                                        fractionOfStubsToKillEverywhere_);
       // Kill modules in specifid modules
       // Random modules throughout the tracker, and those modules in specific regions (so may already have been killed by killStub above)
       bool killStubInDeadModules = killStubInDeadModule(stub);
       return killStubRandomly || killStubInDeadModules;
     }
   }

◆ killStub() [2/2]

bool StubKiller::killStub	(	const TTStub< Ref_Phase2TrackerDigi_ > *	stub,
		const std::vector< int > &	layersToKill,
		const double	minPhiToKill,
		const double	maxPhiToKill,
		const double	minZToKill,
		const double	maxZToKill,
		const double	minRToKill,
		const double	maxRToKill,
		const double	fractionOfStubsToKillInLayers,
		const double	fractionOfStubsToKillEverywhere
	)		const

Definition at line 141 of file StubKiller.cc.

References TTStub< T >::clusterRef(), deadModules_, reco::deltaPhi(), spr::find(), TTStub< T >::getDetId(), TrackerGeometry::idToDetUnit(), TrackerTopology::layer(), Topology::localPosition(), DetId::rawId(), rndmEngine_, TrackerTopology::side(), PixelGeomDetUnit::specificTopology(), DetId::subdetId(), GeomDet::surface(), StripSubdetector::TIB, TrackerTopology::tidWheel(), StripSubdetector::TOB, Surface::toGlobal(), trackerGeometry_, and trackerTopology_.

                                                                                 {
     // Only kill stubs in specified layers
     if (not layersToKill.empty()) {
       // Get the layer the stub is in, and check if it's in the layer you want to kill
       DetId stackDetid = stub->getDetId();
       DetId geoDetId(stackDetid.rawId() + 1);
 
       // If this module is in the deadModule list, don't also try to kill the stub here
       if (deadModules_.empty() || deadModules_.find(geoDetId) == deadModules_.end()) {
         bool isInBarrel = geoDetId.subdetId() == StripSubdetector::TOB || geoDetId.subdetId() == StripSubdetector::TIB;
 
         int layerID = 0;
         if (isInBarrel) {
           layerID = trackerTopology_->layer(geoDetId);
         } else {
           layerID = 10 * trackerTopology_->side(geoDetId) + trackerTopology_->tidWheel(geoDetId);
         }
 
         if (find(layersToKill.begin(), layersToKill.end(), layerID) != layersToKill.end()) {
           // Get the phi and z of stub, and check if it's in the region you want to kill
           const GeomDetUnit* det0 = trackerGeometry_->idToDetUnit(geoDetId);
           const PixelGeomDetUnit* theGeomDet = dynamic_cast<const PixelGeomDetUnit*>(det0);
           const PixelTopology* topol = dynamic_cast<const PixelTopology*>(&(theGeomDet->specificTopology()));
           MeasurementPoint measurementPoint = stub->clusterRef(0)->findAverageLocalCoordinatesCentered();
           LocalPoint clustlp = topol->localPosition(measurementPoint);
           GlobalPoint pos = theGeomDet->surface().toGlobal(clustlp);
 
           double stubPhi = reco::deltaPhi(pos.phi(), 0.);
 
           if (stubPhi > minPhiToKill && stubPhi < maxPhiToKill && pos.z() > minZToKill && pos.z() < maxZToKill &&
               pos.perp() > minRToKill && pos.perp() < maxRToKill) {
             // Kill fraction of stubs
             if (fractionOfStubsToKillInLayers == 1) {
               return true;
             } else {
               if (rndmEngine_->flat() < fractionOfStubsToKillInLayers) {
                 return true;
               }
             }
           }
         }
       }
     }
 
     // Kill fraction of stubs throughout tracker
     if (fractionOfStubsToKillEverywhere > 0) {
       if (rndmEngine_->flat() < fractionOfStubsToKillEverywhere) {
         return true;
       }
     }
 
     return false;
   }

◆ killStubInDeadModule()

bool StubKiller::killStubInDeadModule ( const TTStub< Ref_Phase2TrackerDigi_ > * stub ) const

Definition at line 206 of file StubKiller.cc.

References deadModules_, TTStub< T >::getDetId(), DetId::rawId(), and rndmEngine_.

Referenced by killStub().

                                                                                         {
     if (not deadModules_.empty()) {
       DetId stackDetid = stub->getDetId();
       DetId geoDetId(stackDetid.rawId() + 1);
       auto deadModule = deadModules_.find(geoDetId);
       if (deadModule != deadModules_.end()) {
         if (deadModule->second == 1) {
           return true;
         } else {
           if (rndmEngine_->flat() < deadModule->second) {
             return true;
           }
         }
       }
     }
 
     return false;
   }