#include <L1ScalersClient.h>

Inheritance diagram for L1ScalersClient:

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override

void	beginJob (void) override
	BeginJob. More...

void	beginRun (const edm::Run &run, const edm::EventSetup &c) override
	BeginRun. More...

void	endLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c) override

void	endRun (const edm::Run &run, const edm::EventSetup &c) override
	EndRun. More...

	L1ScalersClient (const edm::ParameterSet &ps)
	Constructors. More...

	~L1ScalersClient () override
	Destructor. More...

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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)

Private Attributes
std::vector< int >	algoSelected_

MonitorElement *	bxSelected_

int	currentLumiBlockNumber_

int	currentRun_

DQMStore *	dbe_

bool	first_algo

bool	first_tt

std::string	folderName_

MonitorElement *	l1AlgoCurrentRate_

MonitorElement *	l1AlgoCurrentRatePerAlgo_ [140]

MonitorElement *	l1AlgoRateHistories_ [140]

unsigned long int	l1AlgoScalerCounters_ [140]

MonitorElement *	l1TechTrigCurrentRate_

MonitorElement *	l1TechTrigCurrentRatePerAlgo_ [80]

MonitorElement *	l1TechTrigRateHistories_ [80]

unsigned long int	l1TechTrigScalerCounters_ [80]

int	nev_

int	nLumi_

int	numSelected_

MonitorElement *	selected_

std::vector< int >	techSelected_

MonitorElement *	totalAlgoRate_

float	totAlgoPrevCount

MonitorElement *	totalTtRate_

float	totTtPrevCount

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 22 of file L1ScalersClient.h.

Member Typedef Documentation

typedef dqm::legacy::DQMStore L1ScalersClient::DQMStore

Definition at line 25 of file L1ScalersClient.h.

typedef dqm::legacy::MonitorElement L1ScalersClient::MonitorElement

Definition at line 24 of file L1ScalersClient.h.

Constructor & Destructor Documentation

L1ScalersClient::L1ScalersClient ( const edm::ParameterSet & ps )

Constructors.

Definition at line 22 of file L1ScalersClient.cc.

References algoSelected_, cms::cuda::assert(), dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), bxSelected_, dbe_, folderName_, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, kNumAlgoHistos, kNumTTHistos, kPerHisto, l1AlgoCurrentRate_, l1AlgoCurrentRatePerAlgo_, l1AlgoRateHistories_, l1AlgoScalerCounters_, l1TechTrigCurrentRate_, l1TechTrigCurrentRatePerAlgo_, l1TechTrigRateHistories_, l1TechTrigScalerCounters_, LogDebug, MAX_ALGOS, MAX_LUMI_SEG, MAX_TT, mergeVDriftHistosByStation::name, numSelected_, Utilities::operator, submitPVValidationJobs::params, selected_, dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::DQMStore::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, techSelected_, runGCPTkAlMap::title, totalAlgoRate_, totAlgoPrevCount, totalTtRate_, and totTtPrevCount.

     : dbe_(nullptr),
       nLumi_(0),
       l1AlgoCurrentRate_(nullptr),
       l1TechTrigCurrentRate_(nullptr),
       selected_(nullptr),
       bxSelected_(nullptr),
       algoSelected_(ps.getUntrackedParameter<std::vector<int>>("algoMonitorBits", std::vector<int>())),
       techSelected_(ps.getUntrackedParameter<std::vector<int>>("techMonitorBits", std::vector<int>())),
       folderName_(ps.getUntrackedParameter<std::string>("dqmFolder", "L1T/L1Scalers_EvF")),
       currentLumiBlockNumber_(0),
       first_algo(true),
       first_tt(true) {
   LogDebug("Status") << "constructor";
   // get back-end interface
   dbe_ = edm::Service<DQMStore>().operator->();
   assert(dbe_ != nullptr);  // blammo!
   dbe_->setCurrentFolder(folderName_);
 
   l1AlgoCurrentRate_ =
       dbe_->book1D("algo_cur_rate", "current lumi section rate per Algo Bits", MAX_ALGOS, -0.5, MAX_ALGOS - 0.5);
 
   l1TechTrigCurrentRate_ =
       dbe_->book1D("tt_cur_rate", "current lumi section rate per Tech. Trig.s", MAX_TT, -0.5, MAX_TT - 0.5);
   // ----------------------
   numSelected_ = algoSelected_.size() + techSelected_.size();
   selected_ = dbe_->book1D("l1BitsSel",
                            "Selected L1 Algorithm"
                            " and tech Bits",
                            numSelected_,
                            -0.5,
                            numSelected_ - 0.5);
   bxSelected_ = dbe_->book2D(
       "l1BitsBxSel", "Selected L1 Algorithm Bits vs Bx", 3600, -0.5, 3599.5, numSelected_, -0.5, numSelected_ - 0.5);
   int j = 1;
   for (unsigned int i = 0; i < algoSelected_.size(); ++i) {
     char title[256];
     snprintf(title, 256, "Algo %d", algoSelected_[i]);
     selected_->setBinLabel(j, title);
     bxSelected_->setBinLabel(j, title, 2);
     ++j;
   }
   for (unsigned int i = 0; i < techSelected_.size(); ++i) {
     char title[256];
     snprintf(title, 256, "Tech %d", techSelected_[i]);
     selected_->setBinLabel(j, title);
     bxSelected_->setBinLabel(j, title, 2);
     ++j;
   }
 
   // book individual bit rates vs lumi for algo bits.
   totalAlgoRate_ = dbe_->book1D("totAlgoRate", "Total Algo Rate", MAX_LUMI_SEG, -0.5, MAX_LUMI_SEG - 0.5);
   totalTtRate_ = dbe_->book1D("totTtRate", "Total Tech Rate", MAX_LUMI_SEG, -0.5, MAX_LUMI_SEG - 0.5);
 
   totAlgoPrevCount = 0UL;
   totTtPrevCount = 0UL;
 
   std::string algodir = "/AlgoRates";
   dbe_->setCurrentFolder(folderName_ + algodir);
 
   for (int i = 0; i < MAX_ALGOS; ++i) {
     l1AlgoScalerCounters_[i] = 0UL;
     l1AlgoRateHistories_[i] = nullptr;  // not really needed but ...
     char name[256];
     snprintf(name, 256, "rate_algobit%03d", i);
     LogDebug("Parameter") << "name " << i << " is " << name;
     l1AlgoRateHistories_[i] = dbe_->book1D(name, name, MAX_LUMI_SEG, -0.5, MAX_LUMI_SEG - 0.5);
   }
 
   // book individual bit rates vs lumi for technical trigger bits.
 
   std::string techdir = "/TechRates";
   dbe_->setCurrentFolder(folderName_ + techdir);
 
   for (int i = 0; i < MAX_TT; ++i) {
     l1TechTrigScalerCounters_[i] = 0UL;
     l1TechTrigRateHistories_[i] = nullptr;  // not really needed but ...
     char name[256];
     snprintf(name, 256, "rate_ttbit%03d", i);
     LogDebug("Parameter") << "name " << i << " is " << name;
     l1TechTrigRateHistories_[i] = dbe_->book1D(name, name, MAX_LUMI_SEG, -0.5, MAX_LUMI_SEG - 0.5);
   }
 
   // split l1 scalers up into groups of 20, assuming total of 140 bits
   std::string algodir2 = "/AlgoBits";
   dbe_->setCurrentFolder(folderName_ + algodir2);
 
   char metitle1[64];  // histo name
   char mename1[64];   // ME name
   for (int k = 0; k < kNumAlgoHistos; k++) {
     int npath_low = kPerHisto * k;
     int npath_high = kPerHisto * (k + 1) - 1;
     snprintf(mename1, 64, "L1AlgoBits_%0d", k);
     snprintf(metitle1, 64, "L1 rates - Algo Bits %d to %d", npath_low, npath_high);
     l1AlgoCurrentRatePerAlgo_[k] = dbe_->book1D(mename1, metitle1, kPerHisto, -0.5 + npath_low, npath_high + 0.5);
   }
 
   // split l1 scalers up into groups of 20, assuming total of 80 technical bits
 
   std::string techdir2 = "/TechBits";
   dbe_->setCurrentFolder(folderName_ + techdir2);
 
   char metitle2[64];  // histo name
   char mename2[64];   // ME name
   for (int k = 0; k < kNumTTHistos; k++) {
     int npath_low = kPerHisto * k;
     int npath_high = kPerHisto * (k + 1) - 1;
     snprintf(mename2, 64, "L1TechBits_%0d", k);
     snprintf(metitle2, 64, "L1 rates - Tech. Trig. Bits %d to %d", npath_low, npath_high);
     l1TechTrigCurrentRatePerAlgo_[k] = dbe_->book1D(mename2, metitle2, kPerHisto, -0.5 + npath_low, npath_high + 0.5);
   }
 
   std::ostringstream params;
   params << "Algo: ";
   for (unsigned int i = 0; i < algoSelected_.size(); ++i) {
     params << algoSelected_[i] << " ";
   }
   params << ", Tech: ";
   for (unsigned int i = 0; i < techSelected_.size(); ++i) {
     params << techSelected_[i] << " ";
   }
   LogDebug("Parameter") << "L1 bits to monitor are " << params.str();
 }

L1ScalersClient::~L1ScalersClient ( )

inlineoverride

Destructor.

Definition at line 31 of file L1ScalersClient.h.

31 {};

Member Function Documentation

void L1ScalersClient::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	c
	)

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 308 of file L1ScalersClient.cc.

308 {}

void L1ScalersClient::beginJob ( void )

overridevirtual

BeginJob.

Reimplemented from edm::EDAnalyzer.

Definition at line 147 of file L1ScalersClient.cc.

References dbe_, folderName_, LogDebug, and dqm::implementation::DQMStore::setCurrentFolder().

                                    {
   LogDebug("Status") << "beingJob";
   if (dbe_) {
     dbe_->setCurrentFolder(folderName_);
   }
 }

void L1ScalersClient::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

overridevirtual

BeginRun.

Reimplemented from edm::EDAnalyzer.

Definition at line 155 of file L1ScalersClient.cc.

155 {}

void L1ScalersClient::endLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	c
	)

overridevirtual

End LumiBlock DQM Client Diagnostic should be performed here

Reimplemented from edm::EDAnalyzer.

Definition at line 162 of file L1ScalersClient.cc.

References algoSelected_, bxSelected_, currentLumiBlockNumber_, dbe_, spr::find(), first_algo, first_tt, folderName_, dqm::implementation::IGetter::get(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getIntValue(), dqm::impl::MonitorElement::getNbinsX(), mps_fire::i, edm::LuminosityBlockBase::id(), dqmiolumiharvest::j, kPerHisto, l1AlgoCurrentRate_, l1AlgoCurrentRatePerAlgo_, l1AlgoRateHistories_, l1AlgoScalerCounters_, l1TechTrigCurrentRate_, l1TechTrigCurrentRatePerAlgo_, l1TechTrigRateHistories_, l1TechTrigScalerCounters_, LogDebug, edm::LuminosityBlockID::luminosityBlock(), MAX_ALGOS, MAX_LUMI_SEG, MAX_TT, nLumi_, unpackData-CaloStage2::pname, RPCpg::rate(), SECS_PER_LUMI_SECTION, selected_, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinLabel(), dqm::impl::MonitorElement::setTitle(), AlCaHLTBitMon_QueryRunRegistry::string, techSelected_, totalAlgoRate_, totAlgoPrevCount, totalTtRate_, and totTtPrevCount.

                                                                                                   {
   nLumi_ = lumiSeg.id().luminosityBlock();
 
   // get EvF data
 
   MonitorElement *algoScalers = dbe_->get(folderName_ + std::string("/l1AlgoBits"));
   MonitorElement *ttScalers = dbe_->get(folderName_ + std::string("/l1TechBits"));
 
   if (algoScalers == nullptr || ttScalers == nullptr) {
     LogInfo("Status") << "cannot get l1 scalers histogram, bailing out.";
     return;
   }
 
   int nalgobits = algoScalers->getNbinsX();
   int nttbits = ttScalers->getNbinsX();
 
   if (nalgobits > MAX_ALGOS)
     nalgobits = MAX_ALGOS;  // HARD CODE FOR NOW
   if (nttbits > MAX_TT)
     nttbits = MAX_TT;  // HARD CODE FOR NOW
 
   LogDebug("Status") << "I see " << nalgobits << " algo paths. ";
   LogDebug("Status") << "I see " << nttbits << " tt paths. ";
 
   // set the bin labels on the first go-through
   if (first_algo) {
     for (int i = 0; i < nalgobits; ++i) {
       int whichHisto = i / kPerHisto;
       int whichBin = i % kPerHisto + 1;
       char pname[256];
       snprintf(pname, 256, "AlgoBit%03d", i);
       l1AlgoCurrentRatePerAlgo_[whichHisto]->setBinLabel(whichBin, pname);
       snprintf(pname, 256, "Rate - Algorithm Bit %03d", i);
       l1AlgoRateHistories_[i]->setTitle(pname);
     }
     first_algo = false;
   }
 
   // set the bin labels on the first go-through
   if (first_tt) {
     for (int i = 0; i < nttbits; ++i) {
       int whichHisto = i / kPerHisto;
       int whichBin = i % kPerHisto + 1;
       char pname[256];
       snprintf(pname, 256, "TechBit%03d", i);
       l1TechTrigCurrentRatePerAlgo_[whichHisto]->setBinLabel(whichBin, pname);
       snprintf(pname, 256, "Rate - Technical Bit %03d", i);
       l1TechTrigRateHistories_[i]->setTitle(pname);
     }
     first_tt = false;
   }
 
   MonitorElement *nLumi = dbe_->get(folderName_ + std::string("nLumiBlock"));
 
   int testval = (nLumi != nullptr ? nLumi->getIntValue() : -1);
   LogDebug("Parameter") << "Lumi Block from DQM: " << testval << ", local is " << nLumi_;
 
   int nL = (nLumi != nullptr ? nLumi->getIntValue() : nLumi_);
   if (nL > MAX_LUMI_SEG) {
     LogDebug("Status") << "Too many Lumi segments, " << nL << " is greater than MAX_LUMI_SEG,"
                        << " wrapping to " << (nL % MAX_LUMI_SEG);
     nL = nL % MAX_LUMI_SEG;
   }
   float delta_t = (nL - currentLumiBlockNumber_) * SECS_PER_LUMI_SECTION;
   if (delta_t < 0) {
     LogDebug("Status") << " time is negative ... " << delta_t;
     delta_t = -delta_t;
   } else if (nL == currentLumiBlockNumber_) {  // divide-by-zero
     LogInfo("Status") << "divide by zero: same lumi section 2x " << nL;
     return;
   }
   // selected ---------------------  fill in the rates for th
   int currSlot = 1;  // for selected bits histogram
   MonitorElement *algoBx = dbe_->get(folderName_ + std::string("/l1AlgoBits_Vs_Bx"));
   // selected ---------------------  end
   for (int i = 1; i <= nalgobits; ++i) {  // bins start at 1
     float current_count = algoScalers->getBinContent(i);
     // selected -------------------- start
     int bit = i - 1;  //
     if (std::find(algoSelected_.begin(), algoSelected_.end(), bit) != algoSelected_.end()) {
       selected_->setBinContent(currSlot, current_count);
       if (algoBx) {
         for (int j = 1; j <= 3600; ++j) {
           bxSelected_->setBinContent(j, currSlot, algoBx->getBinContent(j, i));
         }
       }
       ++currSlot;
     }
     // selected -------------------- end
     float rate = (current_count - l1AlgoScalerCounters_[i - 1]) / delta_t;
     if (rate > 1E-3) {
       LogDebug("Parameter") << "rate path " << i << " is " << rate;
     }
     l1AlgoCurrentRate_->setBinContent(i, rate);
     l1AlgoCurrentRatePerAlgo_[i / kPerHisto]->setBinContent(i % kPerHisto, rate);
     // currentRate_->setBinError(i, error);
     l1AlgoScalerCounters_[i - 1] = (unsigned long)(current_count);
     l1AlgoRateHistories_[i - 1]->setBinContent(nL, rate);
   }
   // selected ----------------- start
   MonitorElement *techBx = dbe_->get(folderName_ + std::string("/l1TechBits_Vs_Bx"));
   // selected ----------------- end
 
   for (int i = 1; i <= nttbits; ++i) {  // bins start at 1
     float current_count = ttScalers->getBinContent(i);
     // selected -------------------- start
     int bit = i - 1;  //
     if (std::find(techSelected_.begin(), techSelected_.end(), bit) != techSelected_.end()) {
       selected_->setBinContent(currSlot, current_count);
       if (techBx) {
         for (int j = 1; j <= 3600; ++j) {
           bxSelected_->setBinContent(j, currSlot, techBx->getBinContent(j, i));
         }
       }
       ++currSlot;
     }
     // selected -------------------- end
     float rate = (current_count - l1TechTrigScalerCounters_[i - 1]) / delta_t;
     if (rate > 1E-3) {
       LogDebug("Parameter") << "rate path " << i << " is " << rate;
     }
     l1TechTrigCurrentRate_->setBinContent(i, rate);
     l1TechTrigCurrentRatePerAlgo_[i / kPerHisto]->setBinContent(i % kPerHisto, rate);
     // currentRate_->setBinError(i, error);
     l1TechTrigScalerCounters_[i - 1] = (unsigned long)(current_count);
     l1TechTrigRateHistories_[i - 1]->setBinContent(nL, rate);
   }
 
   //  compute total rate
   MonitorElement *l1AlgoCounter = dbe_->get(folderName_ + std::string("/l1AlgoCounter"));
   MonitorElement *l1TtCounter = dbe_->get(folderName_ + std::string("/l1TtCounter"));
   if (l1AlgoCounter != nullptr && l1TtCounter != nullptr) {
     float totAlgoCount = l1AlgoCounter->getIntValue();
     float totTtCount = l1TtCounter->getIntValue();
     float totAlgRate = (totAlgoCount - totAlgoPrevCount) / delta_t;
     float totTtRate = (totTtCount - totTtPrevCount) / delta_t;
     totalAlgoRate_->setBinContent(nL, totAlgRate);
     totAlgoPrevCount = totAlgoCount;
     totalTtRate_->setBinContent(nL, totTtRate);
     totTtPrevCount = totTtCount;
   }
 
   currentLumiBlockNumber_ = nL;
 }