#include <L1TOccupancyClientHistogramService.h>

Public Member Functions
TH2F *	getDifferentialHistogram (std::string test)

std::vector< int >	getLSCertification (std::string iHistName)

std::vector< std::pair< int, int > >	getMaskedBins (std::string test)

unsigned int	getNBinsHistogram (std::string test)

unsigned int	getNBinsMasked (std::string test)

TH2F *	getRebinnedHistogram (DQMStore::IGetter &igetter, std::string iHistName, std::string iHistLocation)

bool	isMasked (std::string test, int x, int y)

bool	isStripMasked (std::string test, int binStrip, int axis)

	L1TOccupancyClientHistogramService ()

	L1TOccupancyClientHistogramService (const edm::ParameterSet &iParameters, DQMStore::IBooker &ibooker, bool iVerbose)

TH2F *	loadHisto (DQMStore::IGetter &igetter, std::string test, std::string histo)

int	maskBins (std::string test, TH2F *histo, int strip, int axis)

void	resetHisto (std::string test)

void	setMaskedBins (std::string test, const std::vector< edm::ParameterSet > &mask)

void	updateHistogramEndLS (DQMStore::IGetter &igetter, std::string test, std::string histo, int iLS)

void	updateHistogramEndRun (std::string iHistName)

Private Attributes
std::map< std::string, TH2F * >	mHistDiffMinus1

std::map< std::string, std::pair< TH2F , TH2F > >	mHistograms

std::map< std::string, bool >	mHistValid

std::map< std::string, std::vector< int > >	mLSListDiff

std::map< std::string, std::vector< int > >	mLSListDiffMinus1

std::map< std::string, std::vector< std::pair< int, int > > * >	mMaskedBins

edm::ParameterSet	mParameters

bool	mVerbose

Detailed Description

Definition at line 23 of file L1TOccupancyClientHistogramService.h.

Constructor & Destructor Documentation

L1TOccupancyClientHistogramService::L1TOccupancyClientHistogramService ( )

Definition at line 20 of file L1TOccupancyClientHistogramService.cc.

20 {}

L1TOccupancyClientHistogramService::L1TOccupancyClientHistogramService	(	const edm::ParameterSet &	iParameters,
		DQMStore::IBooker &	ibooker,
		bool	iVerbose
	)

Definition at line 30 of file L1TOccupancyClientHistogramService.cc.

                                                                                                                                                {
   //mDBE        = iDBE;
   mVerbose    = iVerbose;
   mParameters = iParameters;
 }

Member Function Documentation

TH2F * L1TOccupancyClientHistogramService::getDifferentialHistogram ( std::string test )

Definition at line 441 of file L1TOccupancyClientHistogramService.cc.

                                                                                    {  
   if(mHistValid[iHistName]){return mHistograms[iHistName].second;}
   return nullptr;
 }                                            

vector< int > L1TOccupancyClientHistogramService::getLSCertification ( std::string iHistName )

Definition at line 431 of file L1TOccupancyClientHistogramService.cc.

431 {return mLSListDiff[iHistName];}

L1TOccupancyClientHistogramService::mLSListDiff

std::map< std::string, std::vector< int > > mLSListDiff

Definition: L1TOccupancyClientHistogramService.h:67

vector< pair< int, int > > L1TOccupancyClientHistogramService::getMaskedBins ( std::string test )

Definition at line 150 of file L1TOccupancyClientHistogramService.cc.

                                                                                          {
   return (*mMaskedBins[iHistName]);
 }

unsigned int L1TOccupancyClientHistogramService::getNBinsHistogram ( std::string test )

Definition at line 45 of file L1TOccupancyClientHistogramService.cc.

                                                                                    {
 
   TH2F* pHistogram  = getDifferentialHistogram(iHistName);
   int   nBinsX      = pHistogram->GetNbinsX();
   int   nBinsY      = pHistogram->GetNbinsY();
   int   nMasked     = getNBinsMasked(iHistName);
   unsigned int  nBinsActive = (nBinsX*nBinsY)-nMasked;
 
   return nBinsActive;
 
 }

unsigned int L1TOccupancyClientHistogramService::getNBinsMasked ( std::string test )

Definition at line 162 of file L1TOccupancyClientHistogramService.cc.

                                                                                 {
   return mMaskedBins[iHistName]->size();
 }

TH2F * L1TOccupancyClientHistogramService::getRebinnedHistogram	(	DQMStore::IGetter &	igetter,
		std::string	iHistName,
		std::string	iHistLocation
	)

Definition at line 317 of file L1TOccupancyClientHistogramService.cc.

References DQMStore::IGetter::get(), edm::ParameterSet::getParameter(), MonitorElement::getTH2F(), edm::ParameterSet::getUntrackedParameter(), and mps_fire::i.

                                                                                                                                {
   
   MonitorElement* me = igetter.get(iHistLocation);
 
   TH2F* histMonitor;
   
   if(!me){
     histMonitor           = nullptr;
     mHistValid[iHistName] = false;
   }
   else{
     mHistValid[iHistName] = true;
     histMonitor = new TH2F(*(igetter.get(iHistLocation)->getTH2F()));
 
     // Default rebin factors
     int rebinFactorX=1;
     int rebinFactorY=1;
 
     vector<ParameterSet> testParameters = mParameters.getParameter< vector<ParameterSet> >("testParams");
     for(unsigned int i=0 ; i<testParameters.size() ; i++){
       if(testParameters[i].getParameter<string>("testName")==iHistName){
         ParameterSet algoParameters = testParameters[i].getParameter<ParameterSet>("algoParams");
         rebinFactorX = algoParameters.getUntrackedParameter<int>("rebinFactorX",1);
         rebinFactorY = algoParameters.getUntrackedParameter<int>("rebinFactorY",1);
         break;
       }
     }
 
     // Rebinning
     if(rebinFactorX!=1){histMonitor->RebinY(rebinFactorX);}
     if(rebinFactorY!=1){histMonitor->RebinY(rebinFactorY);}
 
   }
 
   return histMonitor;
   
 }

bool L1TOccupancyClientHistogramService::isMasked	(	std::string	test,
		int	x,
		int	y
	)

Definition at line 220 of file L1TOccupancyClientHistogramService.cc.

References mps_fire::i.

                                                                                         {
 
   vector<pair<int,int> > *thisHistMaskedBins = mMaskedBins[iHistName];
 
   bool binIsMasked = false;
 
   for(unsigned int i=0; i<thisHistMaskedBins->size(); i++) {
     if((*thisHistMaskedBins)[i].first ==iBinX && 
        (*thisHistMaskedBins)[i].second==iBinY){
       binIsMasked=true;
       break;
     }
   }
 
   return binIsMasked;
 }

bool L1TOccupancyClientHistogramService::isStripMasked	(	std::string	test,
		int	binStrip,
		int	axis
	)

Definition at line 247 of file L1TOccupancyClientHistogramService.cc.

References KineDebug3::count(), and mps_fire::i.

                                                                                                  {
 
   bool stripIsMasked = true;
   vector<pair<int,int> > *thisHistMaskedBins = mMaskedBins[iHistName];
 
   // If the histogram to be tested had strips defined along Y
   if(iAxis==1) {
     int count=0;
     for(unsigned int i=0; i<thisHistMaskedBins->size(); i++) {
       if((*thisHistMaskedBins)[i].first==iBinStrip){count++;}
     }
     stripIsMasked = getDifferentialHistogram(iHistName)->GetYaxis()->GetNbins()==count;
   }
   // If the histogram to be tested had strips defined along X
   else {
     int count=0;
     for(unsigned int i=0; i<thisHistMaskedBins->size(); i++) {
       if((*thisHistMaskedBins)[i].second==iBinStrip){count++;}
     }
     stripIsMasked = getDifferentialHistogram(iHistName)->GetXaxis()->GetNbins()==count;
   }
 
   return stripIsMasked;
 }

TH2F * L1TOccupancyClientHistogramService::loadHisto	(	DQMStore::IGetter &	igetter,
		std::string	test,
		std::string	histo
	)

Definition at line 282 of file L1TOccupancyClientHistogramService.cc.

                                                                                                                     {
 
   pair<TH2F*,TH2F*> histPair; 
 
   // Histogram to be monitored should be loaded  in the begining of the run
   TH2F* pHist = getRebinnedHistogram(igetter, iHistName,iHistLocation);
   
   if(mHistValid[iHistName]){
   
     histPair.first = pHist; 
   
     TH2F* histDiff = new TH2F(*histPair.first); // Clone the rebinned histogram to be monitored
     histDiff->Reset();                          // We reset histDiff so we are sure it is empty
     histPair.second=histDiff;
   
     mHistograms[iHistName]=histPair;
   
     // Stating the previous closed LS Block Histogram Diff 
     mHistDiffMinus1[iHistName]=new TH2F(*histDiff);
     
   }
     
   return pHist;  //return pointer to the differential histogram
   
 }

int L1TOccupancyClientHistogramService::maskBins	(	std::string	test,
		TH2F *	histo,
		int	strip,
		int	axis
	)

Definition at line 178 of file L1TOccupancyClientHistogramService.cc.

References KineDebug3::count(), gather_cfg::cout, mps_fire::i, funct::m, and AlCaHLTBitMon_ParallelJobs::p.

                                                                                                      {
 
   vector<pair<int,int> > m = (*mMaskedBins[iHistName]);
   int count=0;
   
   // iAxis==1 : Means symmetry axis is vertical
   if(iAxis==1) {
     for(unsigned int i=0;i<m.size();i++) {
       pair<int,int> &p = m[i];
       if(p.first==iStrip) {
         oHist->SetBinContent(p.first,p.second,0.0);
         count++;
       }
     }
   }
   // iAxis==2 : Means symmetry axis is horizontal
   else if(iAxis==2) {
     for(unsigned int i=0;i<m.size();i++) {
       pair<int,int> &p = m[i];
       if(p.second==iStrip) {
         oHist->SetBinContent(p.first,p.second,0.0);
         count++;
       }
     }
   }
   else {
     if(mVerbose) {cout << "invalid axis" << endl;}
   }
   
   return count;
 }

void L1TOccupancyClientHistogramService::resetHisto ( std::string test )

Definition at line 404 of file L1TOccupancyClientHistogramService.cc.

References edm::second().

                                                                    {
   
   if(mHistValid[iHistName]){
   
     // Replacing mHistDiffMinus1
     delete mHistDiffMinus1[iHistName];
     mHistDiffMinus1[iHistName] = new TH2F(*mHistograms[iHistName].second);  
 
     // Resetting
     mHistograms[iHistName].second->Reset();
 
     // LS Accounting  
     mLSListDiffMinus1[iHistName] = mLSListDiff[iHistName]; // Replacing
     mLSListDiff      [iHistName].clear();                 // Resetting
     
   }
 }

void L1TOccupancyClientHistogramService::setMaskedBins	(	std::string	test,
		const std::vector< edm::ParameterSet > &	mask
	)

Definition at line 65 of file L1TOccupancyClientHistogramService.cc.

References edm::ParameterSet::getParameter(), trackerHits::histo, mps_fire::i, createfilelist::int, funct::m, AlCaHLTBitMon_ParallelJobs::p, xlast, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, Phase2TrackerMonitorDigi_cff::ymax, and Phase2TrackerMonitorDigi_cff::ymin.

                                                                                                                  {
 
   TH2F* histo = mHistograms[iHistName].first;
   vector<pair<int,int> >* m = new vector<pair<int,int> >();
   
   if(mVerbose){printf("Masked areas for: %s\n",iHistName.c_str());}
 
   for(unsigned int i=0;i<iMaskedAreas.size();i++) {
 
     ParameterSet iMA        = iMaskedAreas[i];
     int          iTypeUnits = iMA.getParameter<int>("kind");
 
     //get boundaries from python
     double xmin = iMA.getParameter<double>("xmin");
     double xmax = iMA.getParameter<double>("xmax");
     double ymin = iMA.getParameter<double>("ymin");
     double ymax = iMA.getParameter<double>("ymax");
 
     if(mVerbose){
       string sTypeUnits;
       if     (iTypeUnits == 0){sTypeUnits = "Histogram Units";}
       else if(iTypeUnits == 1){sTypeUnits = "Bin Units";}
       else                    {sTypeUnits = "Unknown Units";}
       printf("Area %3i: xmin=%6.2f xmax=%6.2f ymin=%6.2f ymax=%6.2f %s\n",i,xmin,xmax,ymin,ymax,sTypeUnits.c_str());
     }
 
     int xfirst,yfirst,xlast,ylast;
 
     //if min < max: change
     if(!(xmin<=xmax)){int z=xmax; xmax=xmin; xmin=z;}
     if(!(ymin<=ymax)){int z=ymax; ymax=ymin; ymin=z;}
 
     // If masked area are defined in terms of units of the histogram get bin coordinates
     if(iTypeUnits==0) {
 
       // We get the global bin number for this coordinates
       int globalMaxBin = histo->FindBin(xmax,ymax);
       int globalMinBin = histo->FindBin(xmax,ymax);
 
       // Dummy value for this variable since is a 2D histogram
       int binZ = 0; 
 
       // We convert global bins in axis bin numbers
       histo->GetBinXYZ(globalMinBin,xfirst,yfirst,binZ);
       histo->GetBinXYZ(globalMaxBin,xlast ,ylast ,binZ);
 
       // If the max edge (on X or Y) coincide with the lower edge of the current bin
       // pass one bin bellow (since bins are defined from [a,b[)
       if(histo->GetXaxis()->GetBinLowEdge(globalMaxBin)==xmax){xlast--;}
       if(histo->GetYaxis()->GetBinLowEdge(globalMaxBin)==ymax){ylast--;}
 
     }
     // Else units are bin coordinates just convert from double to int
     else {
       xfirst = (int) xmin;
       xlast  = (int) xmax;
       yfirst = (int) ymin;
       ylast  = (int) ymax;
     }
     
     // Now we generate coordinate pairs for each bin in the masked area
     // and we store them for future use
     for(int x=xfirst; x<=xlast; x++) {
       for(int y=yfirst; y<=ylast; y++) {
         pair<int,int> p;
         p.first  = x;
         p.second = y;
         m->push_back(p);
       }
     }
   }
   
   delete[] mMaskedBins[iHistName];
   mMaskedBins[iHistName]=m;
 
 }

void L1TOccupancyClientHistogramService::updateHistogramEndLS	(	DQMStore::IGetter &	igetter,
		std::string	test,
		std::string	histo,
		int	iLS
	)

Definition at line 362 of file L1TOccupancyClientHistogramService.cc.

References edm::first().

                                                                                                                                      {
     
   if(mHistValid[iHistName]){
   
     TH2F* histo_curr = getRebinnedHistogram(igetter, iHistLocation,iHistLocation); // Get the rebinned histogram current cumulative iHistLocation
 
     TH2F* histo_old = new TH2F(*histo_curr);            // Clonecout <<"WP01"<<end; 
     histo_curr->Add(mHistograms[iHistName].first,-1.0); //calculate the difference to previous cumulative histo
 
     mLSListDiff[iHistName].push_back(iLS);
 
     delete mHistograms[iHistName].first;            //delete old cumulateive histo 
     mHistograms[iHistName].first=histo_old;         //save old as new
     mHistograms[iHistName].second->Add(histo_curr); //save new as current
     delete histo_curr;
   }  
 }

void L1TOccupancyClientHistogramService::updateHistogramEndRun ( std::string iHistName )

Definition at line 387 of file L1TOccupancyClientHistogramService.cc.

References begin, and end.

                                                                               {
   
   if(mHistValid[iHistName]){
   
     mHistograms[iHistName].second->Add(mHistDiffMinus1[iHistName]);
     mLSListDiff[iHistName].insert(mLSListDiff      [iHistName].end(), 
                                   mLSListDiffMinus1[iHistName].begin(),
                                   mLSListDiffMinus1[iHistName].end());
   }
 }