Inheritance diagram for SiPhase2BadStripChannelBuilder:

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

	~SiPhase2BadStripChannelBuilder () override=default

Public Member Functions inherited from ConditionDBWriter< SiStripBadStrip >
	ConditionDBWriter (const edm::ParameterSet &iConfig)

	~ConditionDBWriter () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::WatchLuminosityBlocks, edm::one::SharedResources >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from ConditionDBWriter< SiStripBadStrip >
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	algoAnalyze (const edm::Event &event, const edm::EventSetup &es) override

void	algoBeginRun (const edm::Run &run, const edm::EventSetup &es) override

std::map< unsigned short, unsigned short >	clusterizeBadChannels (const std::vector< Phase2TrackerDigi::PackedDigiType > &maskedChannels)

std::unique_ptr< SiStripBadStrip >	getNewObject () override

Private Attributes
const float	badComponentsFraction_

std::mt19937	engine_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

const unsigned int	popConAlgo_

const bool	printdebug_

badChannelAlgo	theBCAlgo_

std::vector< const Phase2TrackerGeomDetUnit * >	theOTDets

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_

std::unique_ptr< TrackerTopology >	tTopo_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from ConditionDBWriter< SiStripBadStrip >
void	setDoStore (const bool doStore)
	When set to false the payload will not be written to the db. More...

void	storeOnDbNow ()

cond::Time_t	timeOfLastIOV ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 38 of file SiPhase2BadStripChannelBuilder.cc.

Constructor & Destructor Documentation

◆ SiPhase2BadStripChannelBuilder()

SiPhase2BadStripChannelBuilder::SiPhase2BadStripChannelBuilder ( const edm::ParameterSet & iConfig )

explicit

Definition at line 100 of file SiPhase2BadStripChannelBuilder.cc.

References badComponentsFraction_, Exception, popConAlgo_, and theBCAlgo_.

     : ConditionDBWriter<SiStripBadStrip>(iConfig),
       topoToken_(esConsumes<edm::Transition::BeginRun>()),
       geomToken_(esConsumes<edm::Transition::BeginRun>()),
       printdebug_(iConfig.getUntrackedParameter<bool>("printDebug", false)),
       popConAlgo_(iConfig.getParameter<unsigned int>("popConAlgo")),
       badComponentsFraction_(iConfig.getParameter<double>("badComponentsFraction")) {
   if (badComponentsFraction_ > 1. || badComponentsFraction_ < 0.) {
     throw cms::Exception("Inconsistent configuration")
         << "[SiPhase2BadStripChannelBuilder::c'tor] the requested fraction of bad components is unphysical. \n";
   }
   theBCAlgo_ = static_cast<badChannelAlgo>(popConAlgo_);
 }

◆ ~SiPhase2BadStripChannelBuilder()

SiPhase2BadStripChannelBuilder::~SiPhase2BadStripChannelBuilder ( )

overridedefault

Member Function Documentation

◆ algoAnalyze()

void SiPhase2BadStripChannelBuilder::algoAnalyze	(	const edm::Event &	event,
		const edm::EventSetup &	es
	)

inlineoverrideprivatevirtual

Reimplemented from ConditionDBWriter< SiStripBadStrip >.

Definition at line 75 of file SiPhase2BadStripChannelBuilder.cc.

References engine_.

                                                                             {
     // deterministic seed from the event number
     // should not bias the result as the event number is already
     // assigned randomly-enough
     engine_.seed(event.id().event() + (event.id().luminosityBlock() << 10) + (event.id().run() << 20));
   }

◆ algoBeginRun()

void SiPhase2BadStripChannelBuilder::algoBeginRun	(	const edm::Run &	run,
		const edm::EventSetup &	es
	)

inlineoverrideprivatevirtual

Reimplemented from ConditionDBWriter< SiStripBadStrip >.

Definition at line 48 of file SiPhase2BadStripChannelBuilder.cc.

References cms::cuda::assert(), DetId::det(), geomToken_, edm::EventSetup::getData(), LogDebug, TrackerGeometry::Ph2PSS, TrackerGeometry::Ph2SS, nano_mu_digi_cff::rawId, DetId::rawId(), DetId::subdetId(), theOTDets, StripSubdetector::TID, StripSubdetector::TOB, topoToken_, align::Tracker, and tTopo_.

                                                                          {
     if (!tTopo_) {
       tTopo_ = std::make_unique<TrackerTopology>(es.getData(topoToken_));
       const TrackerGeometry* tkGeom_ = &es.getData(geomToken_);
 
       edm::LogInfo("SiPhase2BadStripChannelBuilder")
           << " There are " << tkGeom_->detUnits().size() << " modules in this geometry.";
 
       for (auto const& det_u : tkGeom_->detUnits()) {
         const DetId detid = det_u->geographicalId();
         uint32_t rawId = detid.rawId();
         int subid = detid.subdetId();
         if (detid.det() == DetId::Detector::Tracker) {
           const Phase2TrackerGeomDetUnit* pixdet = dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u);
           assert(pixdet);
           LogDebug("SiPhase2BadStripChannelBuilder") << rawId << " is a " << subid << " det";
           if (subid == StripSubdetector::TOB || subid == StripSubdetector::TID) {
             if (tkGeom_->getDetectorType(rawId) == TrackerGeometry::ModuleType::Ph2PSS ||
                 tkGeom_->getDetectorType(rawId) == TrackerGeometry::ModuleType::Ph2SS) {
               theOTDets.push_back(pixdet);
             }
           }  // if it's a Strip module
         }    // if it's OT
       }      // if it's Tracker
     }        // loop of geomdets
   };

◆ clusterizeBadChannels()

std::map< unsigned short, unsigned short > SiPhase2BadStripChannelBuilder::clusterizeBadChannels ( const std::vector< Phase2TrackerDigi::PackedDigiType > & maskedChannels )

private

Definition at line 242 of file SiPhase2BadStripChannelBuilder.cc.

References data, HLT_2023v12_cff::distance, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, L1Scalers_cfi::maskedChannels, printdebug_, mps_fire::result, submitPVValidationJobs::text, and to_string().

Referenced by getNewObject().

                                                                       {
   // Here we will store the result
   std::map<unsigned short, unsigned short> result{};
   std::map<int, std::string> printresult{};
 
   // Sort and remove duplicates.
   std::set data(maskedChannels.begin(), maskedChannels.end());
 
   // We will start the evaluation at the beginning of our data
   auto startOfSequence = data.begin();
 
   // Find all sequences
   while (startOfSequence != data.end()) {
     // FInd first value that is not greate than one
     auto endOfSequence =
         std::adjacent_find(startOfSequence, data.end(), [](const auto& v1, const auto& v2) { return v2 != v1 + 1; });
     if (endOfSequence != data.end())
       std::advance(endOfSequence, 1);
 
     auto consecutiveStrips = std::distance(startOfSequence, endOfSequence);
     result[*startOfSequence] = consecutiveStrips;
 
     if (printdebug_) {
       // Build resulting string
       std::ostringstream oss{};
       bool writeDash = false;
       for (auto it = startOfSequence; it != endOfSequence; ++it) {
         oss << (writeDash ? "-" : "") << std::to_string(*it);
         writeDash = true;
       }
 
       // Copy result to map
       for (auto it = startOfSequence; it != endOfSequence; ++it)
         printresult[*it] = oss.str();
     }
 
     // Continue to search for the next sequence
     startOfSequence = endOfSequence;
   }
 
   if (printdebug_) {
     // Show result on the screen. Or use the map in whichever way you want.
     for (const auto& [value, text] : printresult)
       edm::LogInfo("SiPhase2BadStripChannelBuilder") << std::left << std::setw(2) << value << " -> " << text << "\n";
   }
 
   return result;
 }

◆ fillDescriptions()

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

static

Definition at line 293 of file SiPhase2BadStripChannelBuilder.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and ConditionDBWriter< T >::fillPSetDescription().

                                                                                                 {
   edm::ParameterSetDescription desc;
   desc.setComment("Module to build SiStripBadStrip Payloads for the Phase-2 Outer Tracker");
   ConditionDBWriter::fillPSetDescription(desc);  // inherited from mother class
   desc.addUntracked<bool>("printDebug", false)->setComment("maximum amount of print-outs");
   desc.add<unsigned int>("popConAlgo", 1)->setComment("algorithm to populate the payload: 1=NAIVE,2=RANDOM");
   desc.add<double>("badComponentsFraction", 0.01)->setComment("fraction of bad components to populate the payload");
   descriptions.addWithDefaultLabel(desc);
 }

◆ getNewObject()

std::unique_ptr< SiStripBadStrip > SiPhase2BadStripChannelBuilder::getNewObject ( )

overrideprivatevirtual

Implements ConditionDBWriter< SiStripBadStrip >.

Definition at line 115 of file SiPhase2BadStripChannelBuilder.cc.

References cond::service::PoolDBOutputService::appendOneIOV(), badComponentsFraction_, cond::service::PoolDBOutputService::beginOfTime(), clusterizeBadChannels(), cond::service::PoolDBOutputService::createOneIOV(), cond::service::PoolDBOutputService::currentTime(), TauDecayModes::dec, engine_, Exception, f, spr::find(), dqmdumpme::first, edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), LogDebug, hgcalPlots::ncols, NONE, PixelTopology::nrows(), getGTfromDQMFile::obj, Phase2TrackerDigi::pixelToChannel(), printdebug_, FastTimerService_cff::range, nano_mu_digi_cff::rawId, theBCAlgo_, and theOTDets.

                                                                             {
   edm::LogInfo("SiPhase2BadStripChannelBuilder") << "... creating dummy SiStripBadStrip Data";
 
   auto obj = std::make_unique<SiStripBadStrip>();
 
   // early return with nullptr if fraction is ==0.
   if (badComponentsFraction_ == 0.f) {
     return obj;
   }
 
   for (auto const& pixdet : theOTDets) {
     uint32_t rawId = pixdet->geographicalId().rawId();
     int subid = pixdet->geographicalId().subdetId();
 
     const PixelTopology& topol(pixdet->specificTopology());
 
     const int nrows = topol.nrows();
     const int ncols = topol.ncolumns();
 
     LogDebug("SiPhase2BadStripChannelBuilder")
         << "DetId: " << rawId << " subdet: " << subid << " nrows: " << nrows << " ncols: " << ncols;
 
     std::vector<unsigned int> theSiStripVector;
 
     switch (theBCAlgo_) {
       case NAIVE: {
         LogDebug("SiPhase2BadStripChannelBuilder") << "using the NAIVE algorithm";
 
         auto dis1 = std::uniform_int_distribution<>(0, nrows - 1);  // [0, nrows]
         auto dis2 = std::uniform_int_distribution<>(1, 10);         // [1, 10]
 
         unsigned short firstBadStrip = std::floor(dis1(engine_));
         unsigned short NconsecutiveBadStrips = std::floor(dis2(engine_));
 
         // if the interval exceeds the end of the module
         if (firstBadStrip + NconsecutiveBadStrips > nrows) {
           NconsecutiveBadStrips = nrows - firstBadStrip;
         }
 
         unsigned int theBadStripRange;
         theBadStripRange = obj->encodePhase2(firstBadStrip, NconsecutiveBadStrips);
 
         if (printdebug_)
           edm::LogInfo("SiPhase2BadStripChannelBuilder")
               << "detid " << rawId << " \t"
               << " firstBadStrip " << firstBadStrip << "\t "
               << " NconsecutiveBadStrips " << NconsecutiveBadStrips << "\t "
               << " packed integer " << std::hex << theBadStripRange << std::dec;
 
         theSiStripVector.push_back(theBadStripRange);
         break;
       }
       case RANDOM: {
         LogDebug("SiPhase2BadStripChannelBuilder") << "using the RANDOM algorithm";
 
         // auxilliary vector to check if the channels were already used
         std::vector<Phase2TrackerDigi::PackedDigiType> usedChannels;
 
         size_t nmaxBadStrips = std::floor(nrows * ncols * badComponentsFraction_);
 
         LogDebug("SiPhase2BadStripChannelBuilder")
             << __FUNCTION__ << " " << __LINE__ << " will mask: " << nmaxBadStrips << " strips";
 
         auto disRows = std::uniform_int_distribution<>(0, nrows - 1);  // [0, nrows]
         auto disCols = std::uniform_int_distribution<>(0, ncols - 1);  // [0, ncols]
 
         while (usedChannels.size() < nmaxBadStrips) {
           unsigned short badStripRow = std::floor(disRows(engine_));
           unsigned short badStripCol = std::floor(disCols(engine_));
 
           const auto& badChannel = Phase2TrackerDigi::pixelToChannel(badStripRow, badStripCol);
 
           LogDebug("SiPhase2BadStripChannelBuilder") << __FUNCTION__ << " " << __LINE__ << ": masking channel "
                                                      << badChannel << " (" << badStripRow << "," << badStripCol << ")";
 
           if (std::find(usedChannels.begin(), usedChannels.end(), badChannel) == usedChannels.end()) {
             usedChannels.push_back(badChannel);
           }
         }
 
         const auto badChannelsGroups = this->clusterizeBadChannels(usedChannels);
         // loop over the groups of bad strips
         for (const auto& [first, consec] : badChannelsGroups) {
           unsigned int theBadChannelsRange;
           theBadChannelsRange = obj->encodePhase2(first, consec);
 
           if (printdebug_) {
             edm::LogInfo("SiPhase2BadStripChannelBuilder")
                 << "detid " << rawId << " \t"
                 << " firstBadStrip " << first << "\t "
                 << " NconsecutiveBadStrips " << consec << "\t "
                 << " packed integer " << std::hex << theBadChannelsRange << std::dec;
           }
           theSiStripVector.push_back(theBadChannelsRange);
         }
         break;
       }
       case NONE:
         [[fallthrough]];
       default:
         throw cms::Exception("Inconsistent configuration") << "Did not specifiy the right algorithm to be run";
     }
 
     SiStripBadStrip::Range range(theSiStripVector.begin(), theSiStripVector.end());
     if (!obj->put(rawId, range))
       edm::LogError("SiPhase2BadStripChannelBuilder")
           << "[SiPhase2BadStripChannelBuilder::getNewObject] detid already exists";
 
   }  // loop of geomdets
 
   //End now write sistripbadChannel data in DB
   edm::Service<cond::service::PoolDBOutputService> mydbservice;
 
   if (mydbservice.isAvailable()) {
     if (mydbservice->isNewTagRequest("SiStripBadStripRcd")) {
       mydbservice->createOneIOV<SiStripBadStrip>(*obj, mydbservice->beginOfTime(), "SiStripBadStripRcd");
     } else {
       mydbservice->appendOneIOV<SiStripBadStrip>(*obj, mydbservice->currentTime(), "SiStripBadStripRcd");
     }
   } else {
     edm::LogError("SiPhase2BadStripChannelBuilder") << "Service is unavailable";
   }
 
   return obj;
 }