L1TOccupancyClientHistogramService Class Reference

#include <L1TOccupancyClientHistogramService.h>

Public Types
typedef dqm::legacy::DQMStore	DQMStore
typedef dqm::legacy::MonitorElement	MonitorElement

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

Member Typedef Documentation

DQMStore

typedef dqm::legacy::DQMStore L1TOccupancyClientHistogramService::DQMStore

Definition at line 24 of file L1TOccupancyClientHistogramService.h.

MonitorElement

typedef dqm::legacy::MonitorElement L1TOccupancyClientHistogramService::MonitorElement

Definition at line 25 of file L1TOccupancyClientHistogramService.h.

Constructor & Destructor Documentation

L1TOccupancyClientHistogramService() [1/2]

L1TOccupancyClientHistogramService::L1TOccupancyClientHistogramService

(

)

Definition at line 18 of file L1TOccupancyClientHistogramService.cc.

{}

L1TOccupancyClientHistogramService() [2/2]

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

Definition at line 28 of file L1TOccupancyClientHistogramService.cc.

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

Member Function Documentation

getDifferentialHistogram()

TH2F * L1TOccupancyClientHistogramService::getDifferentialHistogram

(

std::string

test

)

Definition at line 449 of file L1TOccupancyClientHistogramService.cc.

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

getLSCertification()

vector< int > L1TOccupancyClientHistogramService::getLSCertification

(

std::string

iHistName

)

Definition at line 439 of file L1TOccupancyClientHistogramService.cc.

{ return mLSListDiff[iHistName]; }

getMaskedBins()

vector< pair< int, int > > L1TOccupancyClientHistogramService::getMaskedBins

(

std::string

test

)

Definition at line 163 of file L1TOccupancyClientHistogramService.cc.

                                                                                          {
  return (*mMaskedBins[iHistName]);
}

getNBinsHistogram()

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;
}

getNBinsMasked()

unsigned int L1TOccupancyClientHistogramService::getNBinsMasked

(

std::string

test

)

Definition at line 175 of file L1TOccupancyClientHistogramService.cc.

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

getRebinnedHistogram()

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

Definition at line 327 of file L1TOccupancyClientHistogramService.cc.

References dqm::implementation::IGetter::get(), edm::ParameterSet::getParameter(), dqm::legacy::MonitorElement::getTH2F(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, and hlt_dqm_clientPB-live_cfg::me.

                                                                                     {
  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;
}

isMasked()

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

Definition at line 232 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;
}

isStripMasked()

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

Definition at line 257 of file L1TOccupancyClientHistogramService.cc.

References submitPVResolutionJobs::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;
}

loadHisto()

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

Definition at line 294 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
}

maskBins()

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

Definition at line 190 of file L1TOccupancyClientHistogramService.cc.

References submitPVResolutionJobs::count, gather_cfg::cout, mps_fire::i, visualization-live-secondInstance_cfg::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;
}

resetHisto()

void L1TOccupancyClientHistogramService::resetHisto

(

std::string

test

)

Definition at line 415 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
  }
}

setMaskedBins()

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

Definition at line 63 of file L1TOccupancyClientHistogramService.cc.

References edm::ParameterSet::getParameter(), timingPdfMaker::histo, mps_fire::i, createfilelist::int, visualization-live-secondInstance_cfg::m, AlCaHLTBitMon_ParallelJobs::p, x, xlast, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, L1TOccupancyClient_cfi::ymax, and L1TOccupancyClient_cfi::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;
}

updateHistogramEndLS()

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

Definition at line 374 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;
  }
}

updateHistogramEndRun()

void L1TOccupancyClientHistogramService::updateHistogramEndRun

(

std::string

iHistName

)

Definition at line 401 of file L1TOccupancyClientHistogramService.cc.

References mps_fire::end.

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

Member Data Documentation

mHistDiffMinus1

std::map<std::string, TH2F*> L1TOccupancyClientHistogramService::mHistDiffMinus1

private

Definition at line 68 of file L1TOccupancyClientHistogramService.h.

mHistograms

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

private

Definition at line 66 of file L1TOccupancyClientHistogramService.h.

mHistValid

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

private

Definition at line 65 of file L1TOccupancyClientHistogramService.h.

mLSListDiff

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

private

Definition at line 69 of file L1TOccupancyClientHistogramService.h.

mLSListDiffMinus1

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

private

Definition at line 70 of file L1TOccupancyClientHistogramService.h.

mMaskedBins

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

private

Definition at line 67 of file L1TOccupancyClientHistogramService.h.

mParameters

edm::ParameterSet L1TOccupancyClientHistogramService::mParameters

private

Definition at line 62 of file L1TOccupancyClientHistogramService.h.

mVerbose

bool L1TOccupancyClientHistogramService::mVerbose

private

Definition at line 61 of file L1TOccupancyClientHistogramService.h.