#include <HLTScalersClient.h>

Inheritance diagram for HLTScalersClient:

Classes
class	CountLS_t

class	CountLSFifo_t

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	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	beginLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c) override

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...

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

	~HLTScalersClient () override
	Destructor. More...

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources, edm::one::WatchRuns, edm::one::WatchLuminosityBlocks >
	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)

Private Member Functions
std::pair< double, double >	getSlope_ (const CountLSFifo_t &points)

Private Attributes
std::vector< MonitorElement * >	countHistories_

int	currentLumiBlockNumber_

MonitorElement *	currentNormRate_

MonitorElement *	currentRate_

int	currentRun_

DQMStore *	dbe_

bool	debug_

bool	first_

std::string	folderName_

MonitorElement *	hltCount_

std::vector< MonitorElement * >	hltCurrentNormRate_

std::vector< MonitorElement * >	hltCurrentRate_

MonitorElement *	hltNormRate_

MonitorElement *	hltRate_

std::deque< int >	ignores_

unsigned int	kRateIntegWindow_

int	maxFU_

MonitorElement *	mergeCount_

bool	missingPathNames_

int	nev_

int	nLumi_

std::string	processName_

std::vector< MonitorElement * >	rateHistories_

std::vector< MonitorElement * >	rateNormHistories_

CountLSFifo_t	recentNormedOverallCountsPerLS_

std::vector< CountLSFifo_t >	recentNormedPathCountsPerLS_

CountLSFifo_t	recentOverallCountsPerLS_

std::vector< CountLSFifo_t >	recentPathCountsPerLS_

std::ofstream	textfile_

MonitorElement *	updates_

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 56 of file HLTScalersClient.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore HLTScalersClient::DQMStore

Definition at line 63 of file HLTScalersClient.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement HLTScalersClient::MonitorElement

Definition at line 62 of file HLTScalersClient.h.

Constructor & Destructor Documentation

◆ HLTScalersClient()

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

Constructors.

Definition at line 61 of file HLTScalersClient.cc.

References dqm::implementation::IBooker::book1D(), gather_cfg::cout, dbe_, debug_, folderName_, hltCount_, hltNormRate_, hltRate_, LogDebug, MAX_LUMI_SEG_HLT, mergeCount_, Utilities::operator, dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::DQMStore::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, textfile_, and updates_.

     : dbe_(nullptr),
       nLumi_(0),
       currentRate_(nullptr),
       currentLumiBlockNumber_(0),
       first_(true),
       missingPathNames_(true),
       folderName_(ps.getUntrackedParameter<std::string>("dqmFolder", "HLT/HLScalers_EvF")),
       kRateIntegWindow_(ps.getUntrackedParameter<unsigned int>("rateIntegWindow", 3)),
       processName_(ps.getParameter<std::string>("processName")),
       ignores_(),
       debug_(ps.getUntrackedParameter<bool>("debugDump", false)),
       maxFU_(ps.getUntrackedParameter<unsigned int>("maxFU", false)),
       recentOverallCountsPerLS_(kRateIntegWindow_),
       recentNormedOverallCountsPerLS_(2) {
   LogDebug("HLTScalersClient") << "constructor";
   if (debug_) {
     textfile_.open("debug.txt");
     if (!textfile_) {
       std::cout << "constructor: can't open text file" << std::endl;
     }
   }
   // get back-end interface
   usesResource("DQMStore");
   dbe_ = edm::Service<DQMStore>().operator->();
   dbe_->setCurrentFolder(folderName_);
 
   std::string rawdir(folderName_ + "/raw");
   dbe_->setCurrentFolder(rawdir);
   hltRate_ = dbe_->book1D("hltRate", "Overall HLT Accept rate vs LS", MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5);
   dbe_->setCurrentFolder(folderName_);
   hltNormRate_ = dbe_->book1D(
       "hltRateNorm", "Overall HLT Accept rate vs LS, scaled", MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5);
   hltCount_ = dbe_->book1D("hltCount", "Overall HLT Counts vs LS", MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5);
   //   hltCountN_= dbe_->book1D("hltCountN", "Overall HLT Counts per LS vs LS",
   //              MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT-0.5);
   mergeCount_ =
       dbe_->book1D("mergeCount", "Number of merge counts vs LS", MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5);
 
   updates_ = dbe_->book1D("updates", "Status of Updates", 2, 0, 2);
   updates_->setBinLabel(1, "Good Updates");
   updates_->setBinLabel(2, "Incomplete Updates");
 
 }  // end constructor

◆ ~HLTScalersClient()

HLTScalersClient::~HLTScalersClient ( )

inlineoverride

Destructor.

Definition at line 120 of file HLTScalersClient.h.

References debug_, and textfile_.

                                {
     if (debug_) {
       textfile_.close();
     }
   };

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 519 of file HLTScalersClient.cc.

                                                                         {
   // nothing to do here
 }

◆ beginJob()

void HLTScalersClient::beginJob ( void )

overridevirtual

BeginJob.

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 107 of file HLTScalersClient.cc.

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

                                     {
   LogDebug("HLTScalersClient") << "beingJob";
   if (dbe_) {
     dbe_->setCurrentFolder(folderName_);
   }
   first_ = true;
   missingPathNames_ = true;
 }

◆ beginLuminosityBlock()

void HLTScalersClient::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	c
	)

inlineoverride

End LumiBlock DQM Client Diagnostic should be performed here

Definition at line 137 of file HLTScalersClient.h.

137 {}

◆ beginRun()

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

override

BeginRun.

beginRun

Definition at line 117 of file HLTScalersClient.cc.

References first_, LogDebug, missingPathNames_, and writedatasetfile::run.

                                                                          {
   missingPathNames_ = true;
   first_ = true;
   LogDebug("HLTScalersClient") << "beginRun, run " << run.id();
 
 }  // beginRun

◆ endLuminosityBlock()

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

override

End LumiBlock DQM Client Diagnostic should be performed here

Definition at line 132 of file HLTScalersClient.cc.

References newFWLiteAna::bin, dqm::implementation::IBooker::book1D(), countHistories_, gather_cfg::cout, currentNormRate_, currentRate_, dbe_, debug_, relativeConstraints::empty, dqm::impl::MonitorElement::Fill(), first_, SiStripCommissioningSource_FromRAW_cfg::fnames, folderName_, dqm::implementation::IGetter::get(), dqm::impl::MonitorElement::getBinContent(), HLTScalersClient::CountLSFifo_t::getCount(), dqm::impl::MonitorElement::getIntValue(), getSlope_(), hltCount_, hltCurrentNormRate_, hltCurrentRate_, hltNormRate_, hltRate_, mps_fire::i, edm::LuminosityBlockBase::id(), createfilelist::int, edm::isNotFinite(), dqmdumpme::k, kPerHisto, kRateIntegWindow_, label, mps_splice::line, LogDebug, edm::LuminosityBlockID::luminosityBlock(), MAX_LUMI_SEG_HLT, MAX_PATHS, maxFU_, mergeCount_, missingPathNames_, mps_check::msg, Skims_PA_cff::name, names, nLumi_, unpackData-CaloStage2::pname, rateHistories_, rateNormHistories_, recentNormedOverallCountsPerLS_, recentNormedPathCountsPerLS_, recentOverallCountsPerLS_, recentPathCountsPerLS_, DQMOffline_LumiMonitoring_cff::scalers, SECS_PER_LUMI_SECTION, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinError(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::DQMStore::setCurrentFolder(), slope, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, textfile_, HLTScalersClient::CountLSFifo_t::update(), and updates_.

                                                                                                    {
   nLumi_ = lumiSeg.id().luminosityBlock();
 
   // get raw data
   std::string scalHisto = folderName_ + "/raw/hltScalers";
   MonitorElement *scalers = dbe_->get(scalHisto);
   if (scalers == nullptr) {
     LogDebug("HLTScalersClient") << "cannot get hlt scalers histogram, "
                                  << "bailing out.";
     if (debug_)
       std::cout << "No scalers ? Looking for " << scalHisto << std::endl;
     return;
   }
 
   int npaths = scalers->getNbinsX();
   if (npaths > MAX_PATHS)
     npaths = MAX_PATHS;  // HARD CODE FOR NOW
   LogDebug("HLTScalersClient") << "I see " << npaths << " paths. ";
 
   // set the bin labels on the first go-through
   // I need to do this here because we don't have the paths yet
   // on begin-run. I should do this in a less ugly way (see FV?)
   if (first_) {
     std::string rawdir(folderName_ + "/raw");
 
     LogDebug("HLTScalersClient") << "Setting up paths on first endLumiBlock " << npaths;
     dbe_->setCurrentFolder(rawdir);
     currentRate_ = dbe_->book1D("cur_rate", "current lumi section rate per path", npaths, -0.5, npaths - 0.5);
     currentNormRate_ =
         dbe_->book1D("cur_rate_norm", "current norm. lumi section rate per path", npaths, -0.5, npaths - 0.5);
     recentPathCountsPerLS_.reserve(npaths);
     recentNormedPathCountsPerLS_.reserve(npaths);
     char rates_subfolder[256];
     snprintf(rates_subfolder, 256, "%s/RateHistory", folderName_.c_str());
     char counts_subfolder[256];
     snprintf(counts_subfolder, 256, "%s/CountHistory", folderName_.c_str());
 
     hltCurrentRate_.reserve(npaths);
     rateHistories_.reserve(npaths);
     countHistories_.reserve(npaths);
     hltCurrentNormRate_.reserve(npaths);
     rateNormHistories_.reserve(npaths);
 
     dbe_->setCurrentFolder(folderName_);  // these belong in top-level
     for (int i = 0; i < npaths; ++i) {
       dbe_->setCurrentFolder(std::string(rates_subfolder) + "/raw");
 
       char name[256];
       snprintf(name, 256, "raw_rate_p%03d", i);
       //     LogDebug("HLTScalersClient") << "name " << i << " is " << name ;
       rateHistories_.push_back(dbe_->book1D(name, name, MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5));
       snprintf(name, 256, "norm_rate_p%03d", i);
       dbe_->setCurrentFolder(rates_subfolder);
       rateNormHistories_.push_back(dbe_->book1D(name, name, MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5));
       dbe_->setCurrentFolder(counts_subfolder);
       snprintf(name, 256, "counts_p%03d", i);
       countHistories_.push_back(dbe_->book1D(name, name, MAX_LUMI_SEG_HLT, -0.5, MAX_LUMI_SEG_HLT - 0.5));
       // prefill the data structures
       recentPathCountsPerLS_.push_back(CountLSFifo_t(kRateIntegWindow_));
       recentNormedPathCountsPerLS_.push_back(CountLSFifo_t(2));
     }
     dbe_->setCurrentFolder(folderName_);
 
     // split hlt scalers up into groups of 20
     const int maxlen = 64;
     char metitle[maxlen];                     // histo name
     char mename[maxlen];                      // ME name
     int numHistos = int(npaths / kPerHisto);  // this hasta be w/o remainders
 
     int remainder = npaths % kPerHisto;
     if (remainder)
       numHistos += 1;
 
     for (int k = 0; k < numHistos; k++) {
       int npath_low = kPerHisto * k;
       int npath_high = kPerHisto * (k + 1) - 1;
       snprintf(mename, maxlen, "hltScalers_%0d", k);
       snprintf(metitle, maxlen, "HLT scalers - Paths %d to %d", npath_low, npath_high);
       dbe_->setCurrentFolder(rawdir);
       hltCurrentRate_.push_back(dbe_->book1D(mename, metitle, kPerHisto, -0.5 + npath_low, npath_high + 0.5));
       dbe_->setCurrentFolder(folderName_);  // these belong in top-level
       snprintf(mename, maxlen, "hltScalersNorm_%0d", k);
       snprintf(metitle, maxlen, "HLT Rate (scaled) - Paths %d to %d", npath_low, npath_high);
       hltCurrentNormRate_.push_back(dbe_->book1D(mename, metitle, kPerHisto, -0.5 + npath_low, npath_high + 0.5));
     }
 
     first_ = false;
   }
 
   if (missingPathNames_) {
     // first try the scalers histogram and see if the bin names are set
     for (int i = 0; i < npaths; ++i) {
       // needs to be i+1 since root bins start at 1
       const char *name = scalers->getTH1()->GetXaxis()->GetBinLabel(i + 1);
       if (name && (strlen(name) > 0)) {
         if (debug_) {
           std::cout << "path " << i << " name is " << name << std::endl;
         }
         int whichHisto = i / kPerHisto;
         int whichBin = i % kPerHisto + 1;
         char pname[256];
         hltCurrentRate_[whichHisto]->setBinLabel(whichBin, name);
         hltCurrentNormRate_[whichHisto]->setBinLabel(whichBin, name);
         snprintf(pname, 256, "Rate - path %s (Path # %03d)", name, i);
         rateHistories_[i]->setTitle(pname);
         rateNormHistories_[i]->setTitle(pname);
         snprintf(pname, 256, "Counts - path %s (Path # %03d)", name, i);
         countHistories_[i]->setTitle(pname);
 
         currentRate_->setBinLabel(i + 1, name);
         currentNormRate_->setBinLabel(i + 1, name);
 
         missingPathNames_ = false;
       }
     }
   }
   // MEGA-HACK
   if (missingPathNames_) {
     // if that didn't work we load 'em from a text file. damn straight.
     int ipath = 1;
     std::ifstream names("names.dat");
     if (!names) {
       if (debug_) {
         std::ostringstream msg;
         msg << "open of "
             << "names.dat";
         perror(msg.str().c_str());
       }
     } else {  // open succeeded
       missingPathNames_ = false;
       std::string line;
       while (!names.eof()) {
         getline(names, line);
         std::istringstream fnames(line);
         std::string label;
         int bin;
         if (fnames.str().find('#') == 0)  // skip comment lines
           continue;
         if (fnames >> bin >> label) {
           if (debug_) {
             std::cout << bin << "--" << label << "(" << ipath << ")" << std::endl;
           }
           currentRate_->setBinLabel(ipath, label);
           currentNormRate_->setBinLabel(ipath, label);
           countHistories_[ipath - 1]->setTitle(label);
           rateHistories_[ipath - 1]->setTitle(label);
           rateNormHistories_[ipath - 1]->setTitle(label);
           int whichHisto = (ipath - 1) / kPerHisto;
           int whichBin = (ipath - 1) % kPerHisto + 1;
           hltCurrentRate_[whichHisto]->setBinLabel(whichBin, label);
           hltCurrentNormRate_[whichHisto]->setBinLabel(whichBin, label);
           ++ipath;
           if (ipath > npaths)
             break;
         }  //
       }    // loop lines
     }      // open ok
   }
 
   // END SETUP
 
   std::string nLumiHisto(folderName_ + "/nLumiBlock");
   MonitorElement *nLumi = dbe_->get(nLumiHisto);
   if (nLumi == nullptr) {
     nLumiHisto = folderName_ + "/raw/nLumiBlock";
     nLumi = dbe_->get(nLumiHisto);
   }
   int testval = (nLumi != nullptr ? nLumi->getIntValue() : -1);
   LogDebug("HLTScalersClient") << "Lumi Block from DQM: " << testval << ", local is " << nLumi_;
   int nL = (nLumi != nullptr ? nLumi->getIntValue() : nLumi_);
   if (nL > MAX_LUMI_SEG_HLT) {
     LogDebug("HLTScalersClient") << "Too many Lumi segments, " << nL << " is greater than MAX_LUMI_SEG_HLT,"
                                  << " wrapping to " << (nL % MAX_LUMI_SEG_HLT);
     // nL = MAX_LUMI_SEG_HLT;
     nL = nL % MAX_LUMI_SEG_HLT;
   }
 
   // merging counts
   double num_fu = -1.0;
   std::string mergeName(folderName_ + "/raw/hltMerge");
   MonitorElement *merge = dbe_->get(mergeName);
   if (merge != nullptr) {
     num_fu = merge->getBinContent(1);
     if (debug_) {
       std::cout << "Number of received entries: " << num_fu << std::endl;
     }
     mergeCount_->Fill(nL, num_fu);
   }
   // end
 
   // evaluate the data
   // loop over current counts
 
   // this gets filled for all times. Mainly for debugging.
   for (int i = 1; i <= npaths; ++i) {  // bins start at 1
     double current_count = scalers->getBinContent(i);
     // nb that this will now _overwrite_ some settings
     countHistories_[i - 1]->setBinContent(nL, current_count);  // good or bad
   }
 
   std::string overallScalerName(folderName_ + "/raw/hltOverallScaler");
   MonitorElement *hltScaler = dbe_->get(overallScalerName);
   if (hltScaler != nullptr) {
     double current_count = hltScaler->getBinContent(1);
     hltCount_->setBinContent(nL, current_count);
     recentOverallCountsPerLS_.update(CountLS_t(nL, current_count));
     std::pair<double, double> sl = getSlope_(recentOverallCountsPerLS_);
     double slope = sl.first;
     double slope_err = sl.second;
     if (slope > 0) {
       hltRate_->setBinContent(nL, slope);
       if (!edm::isNotFinite(slope_err) && (slope_err >= 0))
         hltRate_->setBinError(nL, slope_err);
     }
   }  // found  histo
 
   if (num_fu >= 0.95 * maxFU_) {
     if (num_fu > maxFU_) {
       maxFU_ = num_fu;
       if (debug_)
         std::cout << "maxFU is now " << maxFU_ << std::endl;
     }
     // good data
     for (int i = 1; i <= npaths; ++i) {  // bins start at 1
       double current_count = scalers->getBinContent(i);
       // DEBUG
       if (!recentPathCountsPerLS_[i - 1].empty() && debug_)
         std::cout << i << "\t-> good one: new => cnt, ls = " << current_count << ", " << nL
                   << ", old = " << recentPathCountsPerLS_[i - 1].back().second << "\t"
                   << recentPathCountsPerLS_[i - 1].back().first << std::endl;
       // END DEBUG
       recentPathCountsPerLS_[i - 1].update(CountLS_t(nL, current_count));
 
       // NB: we do not fill a new entry in the rate histo if we can't
       // calculate it
       std::pair<double, double> sl = getSlope_(recentPathCountsPerLS_[i - 1]);
       double slope = sl.first;
       double slope_err = sl.second;
       // rateHistories_[i-1]->Fill(nL,slope);
       if (slope > 0) {
         rateHistories_[i - 1]->setBinContent(nL, slope);
         // set the current rate(s)
         hltCurrentRate_[(i - 1) / kPerHisto]->setBinContent(i % kPerHisto, slope);
         currentRate_->setBinContent(i, slope);
         if (!edm::isNotFinite(slope_err) && (slope_err >= 0)) {
           currentRate_->setBinError(i, slope_err);
           hltCurrentRate_[(i - 1) / kPerHisto]->setBinError(i % kPerHisto, slope_err);
           rateHistories_[i - 1]->setBinError(nL, slope_err);
         }
       }
 
     }  // loop over paths
 
     // ---------------------------- overall rate, absolute counts
     std::string overallScalerName(folderName_ + "/raw/hltOverallScaler");
     MonitorElement *hltScaler = dbe_->get(overallScalerName);
     if (hltScaler != nullptr) {
       double current_count = hltScaler->getBinContent(1);
       hltCount_->setBinContent(nL, current_count);
       recentOverallCountsPerLS_.update(CountLS_t(nL, current_count));
       std::pair<double, double> sl = getSlope_(recentOverallCountsPerLS_);
       double slope = sl.first;
       double slope_err = sl.second;
       if (slope >= 0) {
         hltRate_->setBinContent(nL, slope);
         if (!edm::isNotFinite(slope_err) && (slope_err >= 0))
           hltRate_->setBinError(nL, slope_err);
       }
     }                   // found  histo
     updates_->Fill(0);  // good
   }                     // check on number of FU's - good data
   else {
     updates_->Fill(1);  // missing updates
   }
 
   // PW DEBUG
   if (debug_) {
     textfile_ << nL << "\t" << npaths << "\t";
     for (int i = 0; i < npaths; ++i) {
       textfile_ << scalers->getBinContent(i) << " ";
     }
     textfile_ << std::endl;
   }
   // end DEBUG
 
 #ifdef LATER
   // ------ overall rate normalized - all data
   overallScalerName = std::string(folderName_ + "/raw/hltOverallScalerN");
   hltScaler = dbe_->get(overallScalerName);
   if (hltScaler != 0) {
     double cnt = hltScaler->getBinContent(1);
     //     hltCountN_->setBinContent(nL,cnt);
     if (debug_) {
       std::cout << "Overall Norm: new => cnt, ls = " << cnt << ", " << nL << ", num_fu = " << num_fu << std::endl;
     }
     recentNormedOverallCountsPerLS_.update(CountLS_t(nL, cnt / num_fu));
     cnt = recentNormedOverallCountsPerLS_.getCount(nL);  // for dupes/partials
     double slope = cnt / num_fu / SECS_PER_LUMI_SECTION;
     if (debug_) {
       std::cout << "Normalized slope = " << slope << std::endl;
     }
     if (slope > 0)
       hltNormRate_->setBinContent(nL, slope);
   }
   //
   std::string scalHistoNorm = folderName_ + "/raw/hltScalersN";
   MonitorElement *scalersN = dbe_->get(scalHistoNorm);
   if (scalersN) {
     for (int i = 0; i < npaths; ++i) {
       double cnt = scalersN->getBinContent(i);
       double slope = cnt / num_fu / SECS_PER_LUMI_SECTION;
       if (slope > 0) {
         rateNormHistories_[i - 1]->setBinContent(nL, slope);
         // set the current rate(s)
         hltCurrentNormRate_[(i - 1) / kPerHisto]->setBinContent(i % kPerHisto, slope);
         currentNormRate_->setBinContent(i, slope);
       }
     }
   }
 #else  // NOT LATER
   // ------ overall rate normalized - all data
   overallScalerName = std::string(folderName_ + "/raw/hltOverallScaler");
   hltScaler = dbe_->get(overallScalerName);
   if (hltScaler != nullptr) {
     double cnt = hltScaler->getBinContent(1);
     //     hltCountN_->setBinContent(nL,cnt);
     float sf = num_fu / maxFU_;
     if (debug_) {
       std::cout << "Overall Norm: new => cnt, ls = " << cnt << ", " << nL << ", num_fu = " << num_fu << ", sf = " << sf
                 << std::endl;
     }
     recentNormedOverallCountsPerLS_.update(CountLS_t(nL, cnt / sf));
     cnt = recentNormedOverallCountsPerLS_.getCount(nL);  // for dupes/partials
     std::pair<double, double> sl = getSlope_(recentNormedOverallCountsPerLS_);
     double slope = sl.first;
     double slope_err = sl.second;
     if (debug_) {
       std::cout << "Normalized slope = " << slope << std::endl;
     }
     if (slope > 0) {
       hltNormRate_->setBinContent(nL, slope);
       if (cnt > 0)
         slope_err = slope * sqrt(2. / num_fu + 2. / cnt);
       if (!edm::isNotFinite(slope_err) && (slope_err >= 0))
         hltNormRate_->setBinError(nL, slope_err);
     }
   }
   //
   std::string scalHistoNorm = folderName_ + "/raw/hltScalers";
   MonitorElement *scalersN = dbe_->get(scalHistoNorm);
   if (scalersN) {
     double sf = num_fu / maxFU_;
     for (int i = 1; i <= npaths; ++i) {
       double cnt = scalersN->getBinContent(i);
       recentNormedPathCountsPerLS_[i - 1].update(CountLS_t(nL, cnt / sf));
       std::pair<double, double> sl = getSlope_(recentNormedPathCountsPerLS_[i - 1]);
       double slope = sl.first;
       double slope_err = sl.second;
       if (slope >= 0) {
         rateNormHistories_[i - 1]->setBinContent(nL, slope);
         // set the current rate(s)
         hltCurrentNormRate_[(i - 1) / kPerHisto]->setBinContent(i % kPerHisto, slope);
         currentNormRate_->setBinContent(i, slope);
         if (slope_err <= 0 && cnt > 0) {
           // ignores error on prev point, so scale by sqrt(2)
           slope_err = slope * sqrt(2. / num_fu + 2. / cnt);
           if (debug_) {
             std::cout << "Slope err " << i << " = " << slope_err << std::endl;
           }
         }
         if (!edm::isNotFinite(slope_err) && (slope_err >= 0)) {
           rateNormHistories_[i - 1]->setBinError(nL, slope_err);
           // set the current rate(s)
           hltCurrentNormRate_[(i - 1) / kPerHisto]->setBinError(i % kPerHisto, slope_err);
           currentNormRate_->setBinError(i, slope_err);
         }
       }
     }
   }
 
 #endif  // LATER
   //
 }

◆ endRun()

void HLTScalersClient::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

override

EndRun.

Definition at line 125 of file HLTScalersClient.cc.

References first_, and missingPathNames_.

                                                                        {
   missingPathNames_ = true;
   first_ = true;
 }

◆ getSlope_()

std::pair< double, double > HLTScalersClient::getSlope_ ( const CountLSFifo_t & points )

private

Definition at line 526 of file HLTScalersClient.cc.

References gather_cfg::cout, debug_, mps_fire::i, dqmiodumpmetadata::n, hiPixelPairStep_cff::points, funct::pow(), SECS_PER_LUMI_SECTION, slope, mathSSE::sqrt(), x, geometryCSVtoXML::xy, and y.

Referenced by endLuminosityBlock().

                                                                                                {
   double slope, sigma_m;
   if (points.size() < points.targetSize()) {
     return std::pair<double, double>(-1, -1);
   }
   // just do a delta if we just want two bins
   else if (points.size() == 2) {
     // just do diff and be done with it
     double delta_ls = points.front().first - points.back().first;
     double delta_cnt = points.front().second - points.back().second;
     slope = delta_cnt / delta_ls;
     sigma_m = -1;
   } else {  // do a fit
     double xy = 0;
     double x = 0;
     double xsq = 0;
     double y = 0;
     double n = double(points.size());
     for (auto i(points.begin()); i != points.end(); ++i) {
       if (debug_)
         std::cout << "x = " << i->first << ", y = " << i->second << std::endl;
       xy += i->first * i->second;
       x += i->first;
       xsq += i->first * i->first;
       y += i->second;
     }
     slope = (n * xy - x * y) / (n * xsq - x * x);
 
     // now get the uncertainty on the slope. Need intercept for this.
     double intercept = (xsq * y - xy * x) / (n * xsq - x * x);
     double sigma_ysq = 0;
     for (auto i(points.begin()); i != points.end(); ++i) {
       sigma_ysq += pow((i->second - slope * i->first - intercept), 2.);
     }
     //     if ( debug_ )
     //       std::cout << "chi^2 = " << sigma_ysq << std::endl;
     sigma_ysq *= 1. / (n - 2.);
 
     sigma_m = sqrt(n * sigma_ysq / (n * xsq - x * x));
   }
 
   //  std::cout << "Slope is " << slope << std::endl;
   slope /= SECS_PER_LUMI_SECTION;
   if (sigma_m > 0)
     sigma_m /= SECS_PER_LUMI_SECTION;
   //   if ( debug_ ) {
   //     std::cout << "Slope = " << slope << " +- " << sigma_m
   //          << std::endl;
   //   std::cout << "intercept is " << intercept
   //        << std::endl;
   //  }
 
   return std::pair<double, double>(slope, sigma_m);
 }

Member Data Documentation

◆ countHistories_

std::vector<MonitorElement *> HLTScalersClient::countHistories_

private

Definition at line 153 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ currentLumiBlockNumber_

int HLTScalersClient::currentLumiBlockNumber_

private

Definition at line 151 of file HLTScalersClient.h.

◆ currentNormRate_

MonitorElement* HLTScalersClient::currentNormRate_

private

Definition at line 164 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ currentRate_

MonitorElement* HLTScalersClient::currentRate_

private

Definition at line 150 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ currentRun_

int HLTScalersClient::currentRun_

private

Definition at line 148 of file HLTScalersClient.h.

◆ dbe_

DQMStore* HLTScalersClient::dbe_

private

Definition at line 144 of file HLTScalersClient.h.

Referenced by beginJob(), endLuminosityBlock(), and HLTScalersClient().

◆ debug_

bool HLTScalersClient::debug_

private

Definition at line 177 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), getSlope_(), HLTScalersClient(), and ~HLTScalersClient().

◆ first_

bool HLTScalersClient::first_

private

Definition at line 168 of file HLTScalersClient.h.

Referenced by beginJob(), beginRun(), endLuminosityBlock(), and endRun().

◆ folderName_

std::string HLTScalersClient::folderName_

private

Definition at line 169 of file HLTScalersClient.h.

Referenced by beginJob(), endLuminosityBlock(), and HLTScalersClient().

◆ hltCount_

MonitorElement* HLTScalersClient::hltCount_

private

Definition at line 157 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), and HLTScalersClient().

◆ hltCurrentNormRate_

std::vector<MonitorElement *> HLTScalersClient::hltCurrentNormRate_

private

Definition at line 166 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ hltCurrentRate_

std::vector<MonitorElement *> HLTScalersClient::hltCurrentRate_

private

Definition at line 155 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ hltNormRate_

MonitorElement* HLTScalersClient::hltNormRate_

private

Definition at line 163 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), and HLTScalersClient().

◆ hltRate_

MonitorElement* HLTScalersClient::hltRate_

private

Definition at line 156 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), and HLTScalersClient().

◆ ignores_

std::deque<int> HLTScalersClient::ignores_

private

Definition at line 173 of file HLTScalersClient.h.

◆ kRateIntegWindow_

unsigned int HLTScalersClient::kRateIntegWindow_

private

Definition at line 170 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ maxFU_

int HLTScalersClient::maxFU_

private

Definition at line 178 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ mergeCount_

MonitorElement* HLTScalersClient::mergeCount_

private

Definition at line 160 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), and HLTScalersClient().

◆ missingPathNames_

bool HLTScalersClient::missingPathNames_

private

Definition at line 168 of file HLTScalersClient.h.

Referenced by beginJob(), beginRun(), endLuminosityBlock(), and endRun().

◆ nev_

int HLTScalersClient::nev_

private

Definition at line 146 of file HLTScalersClient.h.

◆ nLumi_

int HLTScalersClient::nLumi_

private

Definition at line 147 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ processName_

std::string HLTScalersClient::processName_

private

Definition at line 171 of file HLTScalersClient.h.

◆ rateHistories_

std::vector<MonitorElement *> HLTScalersClient::rateHistories_

private

Definition at line 152 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ rateNormHistories_

std::vector<MonitorElement *> HLTScalersClient::rateNormHistories_

private

Definition at line 165 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ recentNormedOverallCountsPerLS_

CountLSFifo_t HLTScalersClient::recentNormedOverallCountsPerLS_

private

Definition at line 183 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ recentNormedPathCountsPerLS_

std::vector<CountLSFifo_t> HLTScalersClient::recentNormedPathCountsPerLS_

private

Definition at line 182 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ recentOverallCountsPerLS_

CountLSFifo_t HLTScalersClient::recentOverallCountsPerLS_

private

Definition at line 180 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ recentPathCountsPerLS_

std::vector<CountLSFifo_t> HLTScalersClient::recentPathCountsPerLS_

private

Definition at line 179 of file HLTScalersClient.h.

Referenced by endLuminosityBlock().

◆ textfile_

std::ofstream HLTScalersClient::textfile_

private

Definition at line 59 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), HLTScalersClient(), and ~HLTScalersClient().

◆ updates_

MonitorElement* HLTScalersClient::updates_

private

Definition at line 159 of file HLTScalersClient.h.

Referenced by endLuminosityBlock(), and HLTScalersClient().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DQMStore

◆ MonitorElement

Constructor & Destructor Documentation

◆ HLTScalersClient()

◆ ~HLTScalersClient()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ beginLuminosityBlock()

◆ beginRun()

◆ endLuminosityBlock()

◆ endRun()

◆ getSlope_()

Member Data Documentation

◆ countHistories_

◆ currentLumiBlockNumber_

◆ currentNormRate_

◆ currentRate_

◆ currentRun_

◆ dbe_

◆ debug_

◆ first_

◆ folderName_

◆ hltCount_

◆ hltCurrentNormRate_

◆ hltCurrentRate_

◆ hltNormRate_

◆ hltRate_

◆ ignores_

◆ kRateIntegWindow_

◆ maxFU_

◆ mergeCount_

◆ missingPathNames_

◆ nev_

◆ nLumi_

◆ processName_

◆ rateHistories_

◆ rateNormHistories_

◆ recentNormedOverallCountsPerLS_

◆ recentNormedPathCountsPerLS_

◆ recentOverallCountsPerLS_

◆ recentPathCountsPerLS_

◆ textfile_

◆ updates_