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

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

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices 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_

CLHEP::HepRandomEngine *	engine_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

const unsigned int	popConAlgo_

const bool	printdebug_

std::unique_ptr< TrackerGeometry >	tGeom_

badChannelAlgo	theBCAlgo_

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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 37 of file SiPhase2BadStripChannelBuilder.cc.

Constructor & Destructor Documentation

◆ SiPhase2BadStripChannelBuilder()

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

explicit

Definition at line 78 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 54 of file SiPhase2BadStripChannelBuilder.cc.

References engine_, and edm::RandomNumberGenerator::getEngine().

                                                                             {
     edm::Service<edm::RandomNumberGenerator> rng;
     if (!engine_) {
       engine_ = &rng->getEngine(event.streamID());
     }
   }

◆ algoBeginRun()

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

inlineoverrideprivatevirtual

Reimplemented from ConditionDBWriter< SiStripBadStrip >.

Definition at line 47 of file SiPhase2BadStripChannelBuilder.cc.

References geomToken_, edm::EventSetup::getData(), tGeom_, topoToken_, and tTopo_.

                                                                          {
     if (!tTopo_) {
       tTopo_ = std::make_unique<TrackerTopology>(es.getData(topoToken_));
       tGeom_ = std::make_unique<TrackerGeometry>(es.getData(geomToken_));
     }
   };

◆ clusterizeBadChannels()

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

private

Definition at line 229 of file SiPhase2BadStripChannelBuilder.cc.

References data, HLT_2022v12_cff::distance, L1Scalers_cfi::maskedChannels, printdebug_, mps_fire::result, submitPVValidationJobs::text, and cond::impl::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 280 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 93 of file SiPhase2BadStripChannelBuilder.cc.

References cond::service::PoolDBOutputService::appendOneIOV(), cms::cuda::assert(), badComponentsFraction_, cond::service::PoolDBOutputService::beginOfTime(), clusterizeBadChannels(), cond::service::PoolDBOutputService::createOneIOV(), cond::service::PoolDBOutputService::currentTime(), TauDecayModes::dec, DetId::det(), engine_, Exception, f, spr::find(), first, edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), LogDebug, hgcalPlots::ncols, NONE, PixelTopology::nrows(), getGTfromDQMFile::obj, TrackerGeometry::Ph2PSS, TrackerGeometry::Ph2SS, Phase2TrackerDigi::pixelToChannel(), printdebug_, FastTimerService_cff::range, DetId::rawId(), PixelGeomDetUnit::specificTopology(), DetId::subdetId(), tGeom_, theBCAlgo_, StripSubdetector::TID, StripSubdetector::TOB, and align::Tracker.

                                                                             {
   using Phase2TrackerGeomDetUnit = PixelGeomDetUnit;
   edm::LogInfo("SiPhase2BadStripChannelBuilder") << "... creating dummy SiStripBadStrip Data" << std::endl;
 
   auto obj = std::make_unique<SiStripBadStrip>();
 
   // early return with nullptr if fraction is ==0.
   if (badComponentsFraction_ == 0.f) {
     return obj;
   }
 
   edm::LogInfo("SiPhase2BadStripChannelBuilder")
       << " There are " << tGeom_->detUnits().size() << " modules in this geometry." << std::endl;
 
   for (auto const& det_u : tGeom_->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" << std::endl;
       if (subid == StripSubdetector::TOB || subid == StripSubdetector::TID) {
         if (tGeom_->getDetectorType(rawId) == TrackerGeometry::ModuleType::Ph2PSS ||
             tGeom_->getDetectorType(rawId) == TrackerGeometry::ModuleType::Ph2SS) {
           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::endl;
 
           std::vector<unsigned int> theSiStripVector;
 
           switch (theBCAlgo_) {
             case NAIVE: {
               LogDebug("SiPhase2BadStripChannelBuilder") << "using the NAIVE algorithm" << std::endl;
 
               unsigned short firstBadStrip = std::floor(CLHEP::RandFlat::shoot(engine_, 0, nrows));
               unsigned short NconsecutiveBadStrips = std::floor(CLHEP::RandFlat::shoot(engine_, 1, 10));
 
               // 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 << std::endl;
 
               theSiStripVector.push_back(theBadStripRange);
               break;
             }
             case RANDOM: {
               LogDebug("SiPhase2BadStripChannelBuilder") << "using the RANDOM algorithm" << std::endl;
 
               // 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" << std::endl;
 
               while (usedChannels.size() < nmaxBadStrips) {
                 unsigned short badStripRow = std::floor(CLHEP::RandFlat::shoot(engine_, 0, nrows));
                 unsigned short badStripCol = std::floor(CLHEP::RandFlat::shoot(engine_, 0, ncols));
                 const auto& badChannel = Phase2TrackerDigi::pixelToChannel(badStripRow, badStripCol);
 
                 LogDebug("SiPhase2BadStripChannelBuilder")
                     << __FUNCTION__ << " " << __LINE__ << ": masking channel " << badChannel << " (" << badStripRow
                     << "," << badStripCol << ")" << std::endl;
 
                 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 << std::endl;
                 }
                 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" << std::endl;
 
         }  // if it's a Strip module
       }    // if it's OT
     }      // if it's Tracker
   }        // 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" << std::endl;
   }
 
   tGeom_.release();
   return obj;
 }