L1TdeRCT Class Reference

#include <L1TdeRCT.h>

Inheritance diagram for L1TdeRCT:

Public Member Functions
	L1TdeRCT (const edm::ParameterSet &ps)
virtual	~L1TdeRCT ()
Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()
std::string	workerType () const
virtual	~EDAnalyzer ()

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c)
void	beginJob (void)
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &)
void	beginRun (const edm::Run &, const edm::EventSetup &)
void	DivideME1D (MonitorElement *numerator, MonitorElement *denominator, MonitorElement *result)
void	DivideME2D (MonitorElement *numerator, MonitorElement *denominator, MonitorElement *result)
void	endJob (void)
void	readFEDVector (MonitorElement *, const edm::EventSetup &)
Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

Private Attributes
DQMStore *	dbe
int	doubleThreshold_
edm::InputTag	ecalTPGData_
MonitorElement *	fedVectorMonitorLS_
MonitorElement *	fedVectorMonitorRUN_
int	filterTriggerType_
	filter TriggerType More...
edm::InputTag	gtDigisLabel_
std::string	gtEGAlgoName_
edm::InputTag	hcalTPGData_
std::string	histFolder_
ofstream	logFile_
bool	monitorDaemon_
int	nev_
int	notrigCount
std::string	outputFile_
MonitorElement *	rctBitDataHfPlusTau2D_
MonitorElement *	rctBitDataMip2D_
MonitorElement *	rctBitDataOverFlow2D_
MonitorElement *	rctBitDataQuiet2D_
MonitorElement *	rctBitDataTauVeto2D_
MonitorElement *	rctBitEmulHfPlusTau2D_
MonitorElement *	rctBitEmulMip2D_
MonitorElement *	rctBitEmulOverFlow2D_
MonitorElement *	rctBitEmulQuiet2D_
MonitorElement *	rctBitEmulTauVeto2D_
MonitorElement *	rctBitHfPlusTauEff2D_
MonitorElement *	rctBitHfPlusTauIneff2D_
MonitorElement *	rctBitHfPlusTauOvereff2D_
MonitorElement *	rctBitMatchedHfPlusTau2D_
MonitorElement *	rctBitMatchedMip2D_
MonitorElement *	rctBitMatchedOverFlow2D_
MonitorElement *	rctBitMatchedQuiet2D_
MonitorElement *	rctBitMatchedTauVeto2D_
MonitorElement *	rctBitMipEff2D_
MonitorElement *	rctBitMipIneff2D_
MonitorElement *	rctBitMipOvereff2D_
MonitorElement *	rctBitOverFlowEff2D_
MonitorElement *	rctBitOverFlowIneff2D_
MonitorElement *	rctBitOverFlowOvereff2D_
MonitorElement *	rctBitTauVetoEff2D_
MonitorElement *	rctBitTauVetoIneff2D_
MonitorElement *	rctBitTauVetoOvereff2D_
MonitorElement *	rctBitUnmatchedDataHfPlusTau2D_
MonitorElement *	rctBitUnmatchedDataMip2D_
MonitorElement *	rctBitUnmatchedDataOverFlow2D_
MonitorElement *	rctBitUnmatchedDataQuiet2D_
MonitorElement *	rctBitUnmatchedDataTauVeto2D_
MonitorElement *	rctBitUnmatchedEmulHfPlusTau2D_
MonitorElement *	rctBitUnmatchedEmulMip2D_
MonitorElement *	rctBitUnmatchedEmulOverFlow2D_
MonitorElement *	rctBitUnmatchedEmulQuiet2D_
MonitorElement *	rctBitUnmatchedEmulTauVeto2D_
MonitorElement *	rctInputTPGEcalOcc_
MonitorElement *	rctInputTPGEcalOccNoCut_
MonitorElement *	rctInputTPGEcalRank_
MonitorElement *	rctInputTPGHcalOcc_
MonitorElement *	rctInputTPGHcalRank_
MonitorElement *	rctInputTPGHcalSample_
MonitorElement *	rctIsoEffChannel_ [396]
MonitorElement *	rctIsoEmBitDiff_
MonitorElement *	rctIsoEmBitOff_
MonitorElement *	rctIsoEmBitOn_
MonitorElement *	rctIsoEmDataOcc1D_
MonitorElement *	rctIsoEmDataOcc_
MonitorElement *	rctIsoEmEff1_
MonitorElement *	rctIsoEmEff1Occ1D_
MonitorElement *	rctIsoEmEff1Occ_
MonitorElement *	rctIsoEmEff1oneD_
MonitorElement *	rctIsoEmEff2_
MonitorElement *	rctIsoEmEff2Occ1D_
MonitorElement *	rctIsoEmEff2Occ_
MonitorElement *	rctIsoEmEff2oneD_
MonitorElement *	rctIsoEmEmulOcc1D_
MonitorElement *	rctIsoEmEmulOcc_
MonitorElement *	rctIsoEmIneff1D_
MonitorElement *	rctIsoEmIneff2_
MonitorElement *	rctIsoEmIneff2Occ1D_
MonitorElement *	rctIsoEmIneff2Occ_
MonitorElement *	rctIsoEmIneff2oneD_
MonitorElement *	rctIsoEmIneff_
MonitorElement *	rctIsoEmIneffOcc1D_
MonitorElement *	rctIsoEmIneffOcc_
MonitorElement *	rctIsoEmOvereff1D_
MonitorElement *	rctIsoEmOvereff_
MonitorElement *	rctIsoEmOvereffOcc1D_
MonitorElement *	rctIsoEmOvereffOcc_
MonitorElement *	rctIsoIneffChannel_ [396]
MonitorElement *	rctIsoOvereffChannel_ [396]
MonitorElement *	rctNisoEffChannel_ [396]
MonitorElement *	rctNIsoEmBitDiff_
MonitorElement *	rctNIsoEmBitOff_
MonitorElement *	rctNIsoEmBitOn_
MonitorElement *	rctNisoEmDataOcc1D_
MonitorElement *	rctNisoEmDataOcc_
MonitorElement *	rctNisoEmEff1_
MonitorElement *	rctNisoEmEff1Occ1D_
MonitorElement *	rctNisoEmEff1Occ_
MonitorElement *	rctNisoEmEff1oneD_
MonitorElement *	rctNisoEmEff2_
MonitorElement *	rctNisoEmEff2Occ1D_
MonitorElement *	rctNisoEmEff2Occ_
MonitorElement *	rctNisoEmEff2oneD_
MonitorElement *	rctNisoEmEmulOcc1D_
MonitorElement *	rctNisoEmEmulOcc_
MonitorElement *	rctNisoEmIneff1D_
MonitorElement *	rctNisoEmIneff2_
MonitorElement *	rctNisoEmIneff2Occ1D_
MonitorElement *	rctNisoEmIneff2Occ_
MonitorElement *	rctNisoEmIneff2oneD_
MonitorElement *	rctNisoEmIneff_
MonitorElement *	rctNisoEmIneffOcc1D_
MonitorElement *	rctNisoEmIneffOcc_
MonitorElement *	rctNisoEmOvereff1D_
MonitorElement *	rctNisoEmOvereff_
MonitorElement *	rctNisoEmOvereffOcc1D_
MonitorElement *	rctNisoEmOvereffOcc_
MonitorElement *	rctNisoIneffChannel_ [396]
MonitorElement *	rctNisoOvereffChannel_ [396]
MonitorElement *	rctRegBitDiff_
MonitorElement *	rctRegBitOff_
MonitorElement *	rctRegBitOn_
MonitorElement *	rctRegDataOcc1D_
MonitorElement *	rctRegDataOcc2D_
MonitorElement *	rctRegEff1D_
MonitorElement *	rctRegEff2D_
MonitorElement *	rctRegEffChannel_ [396]
MonitorElement *	rctRegEmulOcc1D_
MonitorElement *	rctRegEmulOcc2D_
MonitorElement *	rctRegIneff1D_
MonitorElement *	rctRegIneff2D_
MonitorElement *	rctRegIneffChannel_ [396]
MonitorElement *	rctRegMatchedOcc1D_
MonitorElement *	rctRegMatchedOcc2D_
MonitorElement *	rctRegOvereff1D_
MonitorElement *	rctRegOvereff2D_
MonitorElement *	rctRegOvereffChannel_ [396]
MonitorElement *	rctRegSpEff1D_
MonitorElement *	rctRegSpEff2D_
MonitorElement *	rctRegSpEffOcc1D_
MonitorElement *	rctRegSpEffOcc2D_
MonitorElement *	rctRegSpIneff1D_
MonitorElement *	rctRegSpIneff2D_
MonitorElement *	rctRegSpIneffOcc1D_
MonitorElement *	rctRegSpIneffOcc2D_
MonitorElement *	rctRegUnmatchedDataOcc1D_
MonitorElement *	rctRegUnmatchedDataOcc2D_
MonitorElement *	rctRegUnmatchedEmulOcc1D_
MonitorElement *	rctRegUnmatchedEmulOcc2D_
edm::InputTag	rctSourceData_
edm::InputTag	rctSourceEmul_
bool	singlechannelhistos_
int	trigCount
MonitorElement *	trigEff_ [396]
MonitorElement *	trigEffOcc_ [396]
MonitorElement *	trigEffThresh_
MonitorElement *	trigEffThreshOcc_
MonitorElement *	trigEffTriggOcc_ [396]
MonitorElement *	trigEffTriggThreshOcc_
MonitorElement *	triggerAlgoNumbers_
MonitorElement *	triggerType_
bool	verbose_

Static Private Attributes
static const int	crateFED [90]

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
typedef WorkerT< EDAnalyzer >	WorkerType
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)

Detailed Description

Definition at line 114 of file L1TdeRCT.h.

Constructor & Destructor Documentation

L1TdeRCT::L1TdeRCT

(

const edm::ParameterSet &

ps

)

Definition at line 120 of file L1TdeRCT.cc.

References gather_cfg::cout, dbe, edm::ParameterSet::getUntrackedParameter(), histFolder_, NULL, cppFunctionSkipper::operator, outputFile_, DQMStore::setCurrentFolder(), DQMStore::setVerbose(), singlechannelhistos_, and verbose_.

                                          :
   rctSourceEmul_( ps.getParameter< InputTag >("rctSourceEmul") ),
   rctSourceData_( ps.getParameter< InputTag >("rctSourceData") ),
   ecalTPGData_( ps.getParameter< InputTag >("ecalTPGData") ),
   hcalTPGData_( ps.getParameter< InputTag >("hcalTPGData") ),
   gtDigisLabel_( ps.getParameter< InputTag >("gtDigisLabel") ),
   gtEGAlgoName_ ( ps.getParameter< std::string >("gtEGAlgoName") ),
   doubleThreshold_ ( ps.getParameter< int >("doubleThreshold") ),
   filterTriggerType_ (ps.getParameter< int >("filterTriggerType") )
{



  singlechannelhistos_ = ps.getUntrackedParameter < bool > ("singlechannelhistos", false);

  if (singlechannelhistos_)
    if(verbose_) std::cout << "L1TdeRCT: single channels histos ON" << std::endl;

  // verbosity switch
  verbose_ = ps.getUntrackedParameter < bool > ("verbose", false);

  if (verbose_)
    std::cout << "L1TdeRCT: constructor...." << std::endl;


  dbe = NULL;
  if (ps.getUntrackedParameter < bool > ("DQMStore", false)) {
    dbe = Service < DQMStore > ().operator->();
    dbe->setVerbose(0);
  }

  outputFile_ =
      ps.getUntrackedParameter < std::string > ("outputFile", "");
  if (outputFile_.size() != 0) {
    if(verbose_) std::
  cout << "L1T Monitoring histograms will be saved to " <<
  outputFile_.c_str() << std::endl;
  }

  bool disable =
      ps.getUntrackedParameter < bool > ("disableROOToutput", false);
  if (disable) {
    outputFile_ = "";
  }

  histFolder_
    = ps.getUntrackedParameter<std::string>("HistFolder", "L1TEMU/L1TdeRCT");

  if (dbe != NULL) {
    dbe->setCurrentFolder(histFolder_);
  }



}

L1TdeRCT::~L1TdeRCT ( )

virtual

Definition at line 176 of file L1TdeRCT.cc.

{
}

Member Function Documentation

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

protectedvirtual

Implements edm::EDAnalyzer.

Definition at line 870 of file L1TdeRCT.cc.

References gather_cfg::cout, DivideME1D(), DivideME2D(), doubleThreshold_, ecalTPGData_, edm::EventBase::experimentType(), funct::false, MonitorElement::Fill(), HcalObjRepresent::Fill(), filterTriggerType_, first, newFWLiteAna::found, edm::Event::getByLabel(), gtDigisLabel_, gtEGAlgoName_, hcalTPGData_, i, edm::EventBase::isRealData(), edm::HandleBase::isValid(), j, gen::k, edm::InputTag::label(), n, nev_, notrigCount, PHIBINS, PhiEtaMax, rctBitDataHfPlusTau2D_, rctBitDataMip2D_, rctBitDataOverFlow2D_, rctBitDataQuiet2D_, rctBitDataTauVeto2D_, rctBitEmulHfPlusTau2D_, rctBitEmulMip2D_, rctBitEmulOverFlow2D_, rctBitEmulQuiet2D_, rctBitEmulTauVeto2D_, rctBitHfPlusTauEff2D_, rctBitHfPlusTauIneff2D_, rctBitHfPlusTauOvereff2D_, rctBitMatchedHfPlusTau2D_, rctBitMatchedMip2D_, rctBitMatchedOverFlow2D_, rctBitMatchedQuiet2D_, rctBitMatchedTauVeto2D_, rctBitMipEff2D_, rctBitMipIneff2D_, rctBitMipOvereff2D_, rctBitOverFlowEff2D_, rctBitOverFlowIneff2D_, rctBitOverFlowOvereff2D_, rctBitTauVetoEff2D_, rctBitTauVetoIneff2D_, rctBitTauVetoOvereff2D_, rctBitUnmatchedDataHfPlusTau2D_, rctBitUnmatchedDataMip2D_, rctBitUnmatchedDataOverFlow2D_, rctBitUnmatchedDataQuiet2D_, rctBitUnmatchedDataTauVeto2D_, rctBitUnmatchedEmulHfPlusTau2D_, rctBitUnmatchedEmulMip2D_, rctBitUnmatchedEmulOverFlow2D_, rctBitUnmatchedEmulQuiet2D_, rctBitUnmatchedEmulTauVeto2D_, rctInputTPGEcalOcc_, rctInputTPGEcalOccNoCut_, rctInputTPGEcalRank_, rctInputTPGHcalOcc_, rctInputTPGHcalRank_, rctInputTPGHcalSample_, rctIsoEffChannel_, rctIsoEmBitDiff_, rctIsoEmBitOff_, rctIsoEmBitOn_, rctIsoEmDataOcc1D_, rctIsoEmDataOcc_, rctIsoEmEff1_, rctIsoEmEff1Occ1D_, rctIsoEmEff1Occ_, rctIsoEmEff1oneD_, rctIsoEmEff2_, rctIsoEmEff2Occ1D_, rctIsoEmEff2Occ_, rctIsoEmEff2oneD_, rctIsoEmEmulOcc1D_, rctIsoEmEmulOcc_, rctIsoEmIneff1D_, rctIsoEmIneff2_, rctIsoEmIneff2Occ1D_, rctIsoEmIneff2Occ_, rctIsoEmIneff2oneD_, rctIsoEmIneff_, rctIsoEmIneffOcc1D_, rctIsoEmIneffOcc_, rctIsoEmOvereff1D_, rctIsoEmOvereff_, rctIsoEmOvereffOcc1D_, rctIsoEmOvereffOcc_, rctIsoIneffChannel_, rctIsoOvereffChannel_, rctNisoEffChannel_, rctNIsoEmBitDiff_, rctNIsoEmBitOff_, rctNIsoEmBitOn_, rctNisoEmDataOcc1D_, rctNisoEmDataOcc_, rctNisoEmEff1_, rctNisoEmEff1Occ1D_, rctNisoEmEff1Occ_, rctNisoEmEff1oneD_, rctNisoEmEff2_, rctNisoEmEff2Occ1D_, rctNisoEmEff2Occ_, rctNisoEmEff2oneD_, rctNisoEmEmulOcc1D_, rctNisoEmEmulOcc_, rctNisoEmIneff1D_, rctNisoEmIneff2_, rctNisoEmIneff2Occ1D_, rctNisoEmIneff2Occ_, rctNisoEmIneff2oneD_, rctNisoEmIneff_, rctNisoEmIneffOcc1D_, rctNisoEmIneffOcc_, rctNisoEmOvereff1D_, rctNisoEmOvereff_, rctNisoEmOvereffOcc1D_, rctNisoEmOvereffOcc_, rctNisoIneffChannel_, rctNisoOvereffChannel_, rctRegBitDiff_, rctRegBitOff_, rctRegBitOn_, rctRegDataOcc1D_, rctRegDataOcc2D_, rctRegEff1D_, rctRegEff2D_, rctRegEffChannel_, rctRegEmulOcc1D_, rctRegEmulOcc2D_, rctRegIneff1D_, rctRegIneff2D_, rctRegIneffChannel_, rctRegMatchedOcc1D_, rctRegMatchedOcc2D_, rctRegOvereff1D_, rctRegOvereff2D_, rctRegOvereffChannel_, rctRegSpEff1D_, rctRegSpEff2D_, rctRegSpEffOcc1D_, rctRegSpEffOcc2D_, rctRegSpIneff1D_, rctRegSpIneff2D_, rctRegSpIneffOcc1D_, rctRegSpIneffOcc2D_, rctRegUnmatchedDataOcc1D_, rctRegUnmatchedDataOcc2D_, rctRegUnmatchedEmulOcc1D_, rctRegUnmatchedEmulOcc2D_, rctSourceData_, rctSourceEmul_, hitfit::return, singlechannelhistos_, trigCount, trigEff_, trigEffOcc_, trigEffThresh_, trigEffThreshOcc_, trigEffTriggOcc_, trigEffTriggThreshOcc_, triggerAlgoNumbers_, triggerType_, and verbose_.

{
  nev_++;
  if (verbose_) {
    std::cout << "L1TdeRCT: analyze...." << std::endl;
  }

    // filter according trigger type
    //  enum ExperimentType {
    //        Undefined          =  0,
    //        PhysicsTrigger     =  1,
    //        CalibrationTrigger =  2,
    //        RandomTrigger      =  3,
    //        Reserved           =  4,
    //        TracedEvent        =  5,
    //        TestTrigger        =  6,
    //        ErrorTrigger       = 15

  // fill a histogram with the trigger type, for normalization fill also last bin
    // ErrorTrigger + 1
    double triggerType = static_cast<double> (e.experimentType()) + 0.001;
    double triggerTypeLast = static_cast<double> (edm::EventAuxiliary::ExperimentType::ErrorTrigger)
                            + 0.001;
    triggerType_->Fill(triggerType);
    triggerType_->Fill(triggerTypeLast + 1);

    // filter only if trigger type is greater than 0, negative values disable filtering
    if (filterTriggerType_ >= 0) {

        // now filter, for real data only
        if (e.isRealData()) {
            if (!(e.experimentType() == filterTriggerType_)) {

                edm::LogInfo("L1TdeRCT") << "\n Event of TriggerType "
                        << e.experimentType() << " rejected" << std::endl;
                return;

            }
        }

    }

  // for GT decision word
//  edm::ESHandle<L1GtTriggerMenu> menuRcd;
  edm::Handle< L1GlobalTriggerReadoutRecord > gtRecord;

  // get GT trigger menu, maps algorithms to the bits read out
//  c.get<L1GtTriggerMenuRcd>().get(menuRcd) ;
//  const L1GtTriggerMenu* menu = menuRcd.product();

  // get GT decision word
  //e.getByLabel( edm::InputTag("gtDigis"), gtRecord);
  e.getByLabel( gtDigisLabel_ , gtRecord );
  const DecisionWord dWord = gtRecord->decisionWord();  // this will get the decision word *before* masking disabled bits
 int effEGThresholdBitNumber = 999;
  if (gtEGAlgoName_ == "L1_SingleEG1")
    {
      effEGThresholdBitNumber = 46;
    }
  if (gtEGAlgoName_ == "L1_SingleEG5_0001")
    {
      effEGThresholdBitNumber = 47;
    }
  if (gtEGAlgoName_ == "L1_SingleEG8_0001")
    {
      effEGThresholdBitNumber = 48;
    }
  if (gtEGAlgoName_ == "L1_SingleEG10_0001")
    {
      effEGThresholdBitNumber = 49;
  }
  if (gtEGAlgoName_ == "L1_SingleEG12_0001")
    {
      effEGThresholdBitNumber = 50;
    }
  if (gtEGAlgoName_ == "L1_SingleEG15_0001")
    {
      effEGThresholdBitNumber = 51;
    }
  if (gtEGAlgoName_ == "L1_SingleEG20_0001")
    {
      effEGThresholdBitNumber = 52;
    }

  int algoBitNumber = 0;
  bool triggered = false;
  bool independent_triggered = false;
  DecisionWord::const_iterator algoItr;
  for (algoItr = dWord.begin(); algoItr != dWord.end(); algoItr++)
    {
      if (*algoItr)
        {
          triggerAlgoNumbers_->Fill(algoBitNumber);
          if (algoBitNumber == effEGThresholdBitNumber)
            {
              triggered = true;// Fill triggered events (numerator) here!
            }
          if (algoBitNumber <= 45 || algoBitNumber >= 53)
            {
              independent_triggered = true;// use the muon path only !
            }
        }
      algoBitNumber++;
    }


  if(triggered)
    trigCount++;
  else
    notrigCount++;

  // get TPGs
  edm::Handle<EcalTrigPrimDigiCollection> ecalTpData;
  edm::Handle<HcalTrigPrimDigiCollection> hcalTpData;

  // Get the RCT digis
  edm::Handle < L1CaloEmCollection > emData;
  edm::Handle < L1CaloRegionCollection > rgnData;

  // Get the RCT digis
  edm::Handle < L1CaloEmCollection > emEmul;
  edm::Handle < L1CaloRegionCollection > rgnEmul;

  // need to change to getByLabel
  // bool doEm = true; FIXME gcc461: variable 'doEm' set but not used
  // bool doHd = true; FIXME gcc461: variable 'doHd' set but not used
  bool doEcal = true;
  bool doHcal = true;

  // TPG, first try:
  e.getByLabel(ecalTPGData_,ecalTpData);
  e.getByLabel(hcalTPGData_,hcalTpData);

  if (!ecalTpData.isValid()) {
    edm::LogInfo("TPG DataNotFound") << "can't find EcalTrigPrimDigiCollection with label "
             << ecalTPGData_.label() ;
    if (verbose_)std::cout << "Can not find ecalTpData!" << std::endl ;

    doEcal = false ;
  }

  if(doEcal)
  {
  for(EcalTrigPrimDigiCollection::const_iterator iEcalTp = ecalTpData->begin(); iEcalTp != ecalTpData->end(); iEcalTp++)
    if(iEcalTp->compressedEt() > 0)
    {

  rctInputTPGEcalRank_ -> Fill(1.*(iEcalTp->compressedEt())) ;

  if(iEcalTp->id().ieta() > 0)
  {
  rctInputTPGEcalOccNoCut_ -> Fill(1.*(iEcalTp->id().ieta())-0.5,iEcalTp->id().iphi()) ;
  if(iEcalTp->compressedEt() > 3) rctInputTPGEcalOcc_ -> Fill(1.*(iEcalTp->id().ieta())-0.5,iEcalTp->id().iphi()) ;
  }
  else
  {
  rctInputTPGEcalOccNoCut_ -> Fill(1.*(iEcalTp->id().ieta())+0.5,iEcalTp->id().iphi()) ;
  if(iEcalTp->compressedEt() > 3) rctInputTPGEcalOcc_ -> Fill(1.*(iEcalTp->id().ieta())+0.5,iEcalTp->id().iphi()) ;
  }

if(verbose_) std::cout << " ECAL data: Energy: " << iEcalTp->compressedEt() << " eta " << iEcalTp->id().ieta() << " phi " << iEcalTp->id().iphi() << std::endl ;
    }
   }

  if (!hcalTpData.isValid()) {
    edm::LogInfo("TPG DataNotFound") << "can't find HcalTrigPrimDigiCollection with label "
             << hcalTPGData_.label() ;
    if (verbose_)std::cout << "Can not find hcalTpData!" << std::endl ;

    doHcal = false ;
  }


  if(doHcal)
  {

  for(HcalTrigPrimDigiCollection::const_iterator iHcalTp = hcalTpData->begin(); iHcalTp != hcalTpData->end(); iHcalTp++)
  {
    int highSample=0;
    int highEt=0;

    for (int nSample = 0; nSample < 10; nSample++)
      {
  if (iHcalTp->sample(nSample).compressedEt() != 0)
    {
      if(verbose_) std::cout << "HCAL data: Et "
          << iHcalTp->sample(nSample).compressedEt()
          << "  fg "
          << iHcalTp->sample(nSample).fineGrain()
          << "  ieta " << iHcalTp->id().ieta()
          << "  iphi " << iHcalTp->id().iphi()
          << "  sample " << nSample
                      << std::endl ;
      if (iHcalTp->sample(nSample).compressedEt() > highEt)
        {
    highSample = nSample;
                highEt =  iHcalTp->sample(nSample).compressedEt() ;
        }
    }

       }

     if(highEt != 0)
      {
                  if(iHcalTp->id().ieta() > 0)
                  rctInputTPGHcalOcc_ -> Fill(1.*(iHcalTp->id().ieta())-0.5,iHcalTp->id().iphi()) ;
                  else
                  rctInputTPGHcalOcc_ -> Fill(1.*(iHcalTp->id().ieta())+0.5,iHcalTp->id().iphi()) ;
                  rctInputTPGHcalSample_ -> Fill(highSample,highEt) ;
                  rctInputTPGHcalRank_ -> Fill(highEt) ;
       }

    }
  }


  e.getByLabel(rctSourceData_,rgnData);
  e.getByLabel(rctSourceEmul_,rgnEmul);

  if (!rgnData.isValid()) {
    edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection with label "
             << rctSourceData_.label() ;
    if (verbose_)std::cout << "Can not find rgnData!" << std::endl ;
    // doHd = false;
  }

//  if ( doHd ) {
  if (!rgnEmul.isValid()) {
    edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection with label "
             << rctSourceEmul_.label() ;
    // doHd = false;
    if (verbose_)std::cout << "Can not find rgnEmul!" << std::endl ;
  }
//  }


  e.getByLabel(rctSourceData_,emData);
  e.getByLabel(rctSourceEmul_,emEmul);

  if (!emData.isValid()) {
    edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection with label "
             << rctSourceData_.label() ;
    if (verbose_)std::cout << "Can not find emData!" << std::endl ;
    // doEm = false;
  }

//  if ( doEm ) {

  if (!emEmul.isValid()) {
    edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection with label "
             << rctSourceEmul_.label() ;
    if (verbose_)std::cout << "Can not find emEmul!" << std::endl ;
    // doEm = false;
    return ;
  }

//  }


  // Isolated and non-isolated EM

  // StepI: Reset

  int nelectrIsoData = 0;
  int nelectrNisoData = 0;
  int nelectrIsoEmul = 0;
  int nelectrNisoEmul = 0;

  int electronDataRank[2][PhiEtaMax]={{0}};
  int electronDataEta[2][PhiEtaMax]={{0}};
  int electronDataPhi[2][PhiEtaMax]={{0}};
  int electronEmulRank[2][PhiEtaMax]={{0}};
  int electronEmulEta[2][PhiEtaMax]={{0}};
  int electronEmulPhi[2][PhiEtaMax]={{0}};

    // region/bit arrays
  int nRegionData = 0;
  int nRegionEmul = 0;

  int regionDataRank[PhiEtaMax] = {0};
  int regionDataEta [PhiEtaMax] = {0};
  int regionDataPhi [PhiEtaMax] = {0};

  bool regionDataOverFlow [PhiEtaMax] = {false};
  bool regionDataTauVeto  [PhiEtaMax] = {false};
  bool regionDataMip      [PhiEtaMax] = {false};
  bool regionDataQuiet    [PhiEtaMax] = {false};
  bool regionDataHfPlusTau[PhiEtaMax] = {false};

  int regionEmulRank[PhiEtaMax] = {0};
  int regionEmulEta [PhiEtaMax] = {0};
  int regionEmulPhi [PhiEtaMax] = {0};

  bool regionEmulOverFlow [PhiEtaMax] = {false};
  bool regionEmulTauVeto  [PhiEtaMax] = {false};
  bool regionEmulMip      [PhiEtaMax] = {false};
  bool regionEmulQuiet    [PhiEtaMax] = {false};
  bool regionEmulHfPlusTau[PhiEtaMax] = {false};

if(first)
{
  first = false ;
}


  // StepII: fill variables

  for (L1CaloEmCollection::const_iterator iem = emEmul->begin();
       iem != emEmul->end();
       iem++)
  {
    if(iem->rank() >= 1)
    {
      if(iem->isolated())
      {
        rctIsoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());

        // to  show bad channles in the 2D efficiency plots
        rctIsoEmIneffOcc_->Fill (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
        rctIsoEmEff1Occ_->Fill  (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);

        int channel;

        channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
        rctIsoEmEmulOcc1D_->Fill(channel);
        electronEmulRank[0][nelectrIsoEmul]=iem->rank() ;
        electronEmulEta[0][nelectrIsoEmul]=iem->regionId().ieta();
        electronEmulPhi[0][nelectrIsoEmul]=iem->regionId().iphi();
        nelectrIsoEmul++ ;
      }

      else
      {
        rctNisoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());

        // to  show bad channles in the 2D efficiency plots
        rctNisoEmIneffOcc_->Fill (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
        rctNisoEmEff1Occ_->Fill  (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);

        int channel;
//

        channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
        rctNisoEmEmulOcc1D_->Fill(channel);
        electronEmulRank[1][nelectrNisoEmul]=iem->rank() ;
        electronEmulEta[1][nelectrNisoEmul]=iem->regionId().ieta();
        electronEmulPhi[1][nelectrNisoEmul]=iem->regionId().iphi();
        nelectrNisoEmul++ ;
      }
    }
  }

  for (L1CaloEmCollection::const_iterator iem = emData->begin();
       iem != emData->end();
       iem++)
  {
    if(iem->rank() >= 1)
    {
      if (iem->isolated())
      {
        rctIsoEmDataOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());

        // new stuff to avoid 0's in emulator 2D //
        // rctIsoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(),0.01);
        rctIsoEmOvereffOcc_->Fill (iem->regionId().ieta(),
                                   iem->regionId().iphi(), 0.01);

        int channel;

        channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
        rctIsoEmDataOcc1D_->Fill(channel);

        // new stuff to avoid 0's
        // rctIsoEmEmulOcc1D_->Fill(channel);

        electronDataRank[0][nelectrIsoData]=iem->rank() ;
        electronDataEta[0][nelectrIsoData]=iem->regionId().ieta();
        electronDataPhi[0][nelectrIsoData]=iem->regionId().iphi();
        nelectrIsoData++ ;
      }

      else
      {
        rctNisoEmDataOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());

        // new stuff to avoid 0's in emulator 2D //
        // rctNisoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(),0.01);
        rctNisoEmOvereffOcc_->Fill (iem->regionId().ieta(),
                                    iem->regionId().iphi(), 0.01);

        int channel;

        channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
        rctNisoEmDataOcc1D_->Fill(channel);

        // new stuff to avoid 0's
        // rctNisoEmEmulOcc1D_->Fill(channel);

        electronDataRank[1][nelectrNisoData]=iem->rank() ;
        electronDataEta[1][nelectrNisoData]=iem->regionId().ieta();
        electronDataPhi[1][nelectrNisoData]=iem->regionId().iphi();
        nelectrNisoData++ ;
      }
    }
  }

    // fill region/bit arrays for emulator
  for(L1CaloRegionCollection::const_iterator ireg = rgnEmul->begin();
      ireg != rgnEmul->end();
      ireg++)
  {
//     std::cout << "Emul: " << nRegionEmul << " " << ireg->gctEta() << " " << ireg->gctPhi() << std::endl;
    if(ireg->overFlow())  rctBitEmulOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->tauVeto())   rctBitEmulTauVeto2D_  ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->mip())       rctBitEmulMip2D_      ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->quiet())     rctBitEmulQuiet2D_    ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->fineGrain()) rctBitEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->et() > 0)
    {
      rctRegEmulOcc1D_->Fill(PHIBINS*ireg->gctEta() + ireg->gctPhi());
      rctRegEmulOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi());
    }

    // to show bad channels in 2D efficiency plots:
    if(ireg->overFlow()) {
      rctBitUnmatchedEmulOverFlow2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
      rctBitMatchedOverFlow2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01);
    }

    if(ireg->tauVeto()) {
      rctBitUnmatchedEmulTauVeto2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
      rctBitMatchedTauVeto2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01);
    }

    if(ireg->mip()) {
      rctBitUnmatchedEmulMip2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
      rctBitMatchedMip2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01);
    }

    if(ireg->quiet()) {
      rctBitUnmatchedEmulQuiet2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
      rctBitMatchedQuiet2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01);
    }

    if(ireg->fineGrain()) {
      rctBitUnmatchedEmulHfPlusTau2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
      rctBitMatchedHfPlusTau2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01);
    }

    if(ireg->et() > 0) {
      rctRegUnmatchedEmulOcc2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
      rctRegMatchedOcc2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01);
/*      rctRegDeltaEtOcc2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01); */
    }

    nRegionEmul = PHIBINS * ireg->gctEta() + ireg->gctPhi();

    regionEmulRank     [nRegionEmul] = ireg->et() ;
    regionEmulEta      [nRegionEmul] = ireg->gctEta();
    regionEmulPhi      [nRegionEmul] = ireg->gctPhi();
    regionEmulOverFlow [nRegionEmul] = ireg->overFlow();
    regionEmulTauVeto  [nRegionEmul] = ireg->tauVeto();
    regionEmulMip      [nRegionEmul] = ireg->mip();
    regionEmulQuiet    [nRegionEmul] = ireg->quiet();
    regionEmulHfPlusTau[nRegionEmul] = ireg->fineGrain();
  }
      // fill region/bit arrays for hardware
  for(L1CaloRegionCollection::const_iterator ireg = rgnData->begin();
      ireg != rgnData->end();
      ireg++)
  {
//     std::cout << "Data: " << nRegionData << " " << ireg->gctEta() << " " << ireg->gctPhi() << std::endl;
    if(ireg->overFlow())  rctBitDataOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->tauVeto())   rctBitDataTauVeto2D_  ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->mip())       rctBitDataMip2D_      ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->quiet())     rctBitDataQuiet2D_    ->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->fineGrain()) rctBitDataHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi());
    if(ireg->et() > 0)
      {
      rctRegDataOcc1D_      ->Fill(PHIBINS*ireg->gctEta() + ireg->gctPhi());
      rctRegDataOcc2D_      ->Fill(ireg->gctEta(), ireg->gctPhi());
      }
    // to show bad channels in 2D inefficiency:
    // if(ireg->overFlow())  rctBitEmulOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    // if(ireg->tauVeto())   rctBitEmulTauVeto2D_  ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    // if(ireg->mip())       rctBitEmulMip2D_      ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    // if(ireg->quiet())     rctBitEmulQuiet2D_    ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    // if(ireg->fineGrain()) rctBitEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    // if(ireg->et() > 0)    rctRegEmulOcc2D_      ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    if(ireg->overFlow())  rctBitUnmatchedDataOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    if(ireg->tauVeto())   rctBitUnmatchedDataTauVeto2D_  ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    if(ireg->mip())       rctBitUnmatchedDataMip2D_      ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    if(ireg->quiet())     rctBitUnmatchedDataQuiet2D_    ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    if(ireg->fineGrain()) rctBitUnmatchedDataHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
    if(ireg->et() > 0)    rctRegUnmatchedDataOcc2D_      ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);

    nRegionData = PHIBINS * ireg->gctEta() + ireg->gctPhi();

    regionDataRank     [nRegionData] = ireg->et() ;
    regionDataEta      [nRegionData] = ireg->gctEta();
    regionDataPhi      [nRegionData] = ireg->gctPhi();
    regionDataOverFlow [nRegionData] = ireg->overFlow();
    regionDataTauVeto  [nRegionData] = ireg->tauVeto();
    regionDataMip      [nRegionData] = ireg->mip();
    regionDataQuiet    [nRegionData] = ireg->quiet();
    regionDataHfPlusTau[nRegionData] = ireg->fineGrain();
  }

 if(verbose_)
{
  std::cout << "I found Data! Iso: " << nelectrIsoData << " Niso: " << nelectrNisoData <<  std::endl ;
  for(int i=0; i<nelectrIsoData; i++)
  std::cout << " Iso Energy " << electronDataRank[0][i] << " eta " << electronDataEta[0][i] << " phi " << electronDataPhi[0][i] << std::endl ;
  for(int i=0; i<nelectrNisoData; i++)
  std::cout << " Niso Energy " << electronDataRank[1][i] << " eta " << electronDataEta[1][i] << " phi " << electronDataPhi[1][i] << std::endl ;

  std::cout << "I found Emul! Iso: " << nelectrIsoEmul << " Niso: " << nelectrNisoEmul <<  std::endl ;
  for(int i=0; i<nelectrIsoEmul; i++)
  std::cout << " Iso Energy " << electronEmulRank[0][i] << " eta " << electronEmulEta[0][i] << " phi " << electronEmulPhi[0][i] << std::endl ;
  for(int i=0; i<nelectrNisoEmul; i++)
  std::cout << " Niso Energy " << electronEmulRank[1][i] << " eta " << electronEmulEta[1][i] << " phi " << electronEmulPhi[1][i] << std::endl ;

  std::cout << "I found Data! Regions: " << PhiEtaMax <<  std::endl ;
  for(int i=0; i<(int)PhiEtaMax; i++)
 if(regionDataRank[i] !=0 )  std::cout << " Energy " << regionDataRank[i] << " eta " << regionDataEta[i] << " phi " << regionDataPhi[i] << std::endl ;

  std::cout << "I found Emul! Regions: " << PhiEtaMax <<  std::endl ;
  for(int i=0; i<(int)PhiEtaMax; i++)
 if(regionEmulRank[i] !=0 )  std::cout << " Energy " << regionEmulRank[i] << " eta " << regionEmulEta[i] << " phi " << regionEmulPhi[i] << std::endl ;
}

  // StepIII: calculate and fill

  for(int k=0; k<2; k++)
  {
    int nelectrE, nelectrD;

    if(k==0)
    {
      nelectrE=nelectrIsoEmul;
      nelectrD=nelectrIsoData;
    }

    else
    {
      nelectrE=nelectrNisoEmul;
      nelectrD=nelectrNisoData;
    }

    for(int i = 0; i < nelectrE; i++)
      {
    //bool triggered = l1SingleEG2; //false; //HACK until true trigger implimented
    double trigThresh = doubleThreshold_;  //ditto
      if(singlechannelhistos_) {
        int chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
        if(k==1 && independent_triggered) { //non-iso
          //std::cout << "eta " << electronEmulEta[k][i] << " phi " << electronEmulPhi[k][i] << " with rank " <<  electronEmulRank[k][i] << std::endl;
          trigEffOcc_[chnl]->Fill(electronEmulRank[k][i]);
//      }
        if(triggered)
          trigEffTriggOcc_[chnl]->Fill(electronEmulRank[k][i]); }
      }
      //find number of objects with rank above 2x trigger threshold
      //and number after requiring a trigger too
      if(electronEmulRank[k][i]>=trigThresh){
        if(k==1 && independent_triggered) { //non-iso
          trigEffThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i]);
          trigEffTriggThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.01);
//      }
        if(triggered)
          trigEffTriggThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001); }
      }



    Bool_t found = kFALSE;

    for(int j = 0; j < nelectrD; j++)
      {
        if(electronEmulEta[k][i]==electronDataEta[k][j] &&
           electronEmulPhi[k][i]==electronDataPhi[k][j])
        {
          if(k==0)
          {
            rctIsoEmEff1Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
            // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99

            int chnl;

            chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
            rctIsoEmEff1Occ1D_->Fill(chnl);
            if(singlechannelhistos_)
            {
              int energy_difference;

              energy_difference=(electronEmulRank[k][i] - electronDataRank[k][j]);
              rctIsoEffChannel_[chnl]->Fill(energy_difference);
            }
        
            if(electronEmulRank[k][i]==electronDataRank[k][j])
            {
              rctIsoEmEff2Occ1D_->Fill(chnl);
              rctIsoEmEff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98012);
              // Weight is for ROOT; should just exceed 0.99
              // NOTE: Weight is different for eff 2 because this isn't filled initially
              // for current definition of Eff2 and Ineff2 we need to add additional
              // factor 0.99 since we divide over eff1 which is 0.99001 e.g. we use 0.99001**2 !
              rctIsoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.0099);
            }
            else
            {
              rctIsoEmIneff2Occ1D_->Fill(chnl);
              rctIsoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.9801);
          //Check for the bit that is different and store it
          bitset<8> bitDifference( electronEmulRank[k][i]^electronDataRank[k][j] );
          for( size_t n=0; n < bitDifference.size(); n++){
          if( n < 4 ){ rctIsoEmBitDiff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bitDifference[n] ); }
          if( n >= 4 ){ rctIsoEmBitDiff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bitDifference[n] ); }
          }
            }
          }

          else
          {
            rctNisoEmEff1Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
            // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99

            int chnl;

            chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
            rctNisoEmEff1Occ1D_->Fill(chnl);
            if(singlechannelhistos_)
            {
              int energy_difference;

              energy_difference=(electronEmulRank[k][i] - electronDataRank[k][j]) ;
              rctNisoEffChannel_[chnl]->Fill(energy_difference) ;
            }


            if(electronEmulRank[k][i]==electronDataRank[k][j])
            {
              rctNisoEmEff2Occ1D_->Fill(chnl);
              rctNisoEmEff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98012);
              // Weight is for ROOT; should just exceed 0.99
              // NOTE: Weight is different for eff 2 because this isn't filled initially
              // see comments fo Iso
              rctNisoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.0099);
            }
            else
            {
              rctNisoEmIneff2Occ1D_->Fill(chnl);
              rctNisoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.9801);
          //Check for the bit that is different and store it
          bitset<8> bitDifference( electronEmulRank[k][i]^electronDataRank[k][j] );
          for( size_t n=0; n < bitDifference.size(); n++){
          if( n < 4 ){ rctNIsoEmBitDiff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bitDifference[n] ); }
          if( n >= 4 ){ rctNIsoEmBitDiff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bitDifference[n] ); }
          }
            }
          }

          found = kTRUE;
        }
      }

      if(found == kFALSE)
      {
        if(k==0)
        {
          rctIsoEmIneffOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98);
          // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99

          int chnl;

      //Store the bit map for the emulator
      bitset<8> bit( electronEmulRank[k][i] );
      for( size_t n=0; n < bit.size(); n++){
         if( n < 4 ){ rctIsoEmBitOff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bit[n] ); }
         if( n >= 4 ){ rctIsoEmBitOff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bit[n] ); }
      }

          chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
          rctIsoEmIneffOcc1D_->Fill(chnl);
          if(singlechannelhistos_)
          {
            rctIsoIneffChannel_[chnl]->Fill(electronEmulRank[k][i]);
          }
        }

        else
        {
          rctNisoEmIneffOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98);
          // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99

          int chnl;

          chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
          rctNisoEmIneffOcc1D_->Fill(chnl);

      //Store the bit map for the emulator
      bitset<8> bit( electronEmulRank[k][i] );
      for( size_t n=0; n < bit.size(); n++){
         if( n < 4 ){ rctNIsoEmBitOff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bit[n] ); }
         if( n >= 4 ){ rctNIsoEmBitOff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bit[n] ); }
      }

          if(singlechannelhistos_)
          {
            rctNisoIneffChannel_[chnl]->Fill(electronEmulRank[k][i]);
          }
        }
      }

    }

    DivideME1D(rctIsoEmEff1Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmEff1oneD_);
    DivideME2D(rctIsoEmEff1Occ_, rctIsoEmEmulOcc_, rctIsoEmEff1_) ;
//    DivideME1D(rctIsoEmEff2Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmEff2oneD_);
//    DivideME2D(rctIsoEmEff2Occ_, rctIsoEmEmulOcc_, rctIsoEmEff2_) ;
    DivideME1D(rctIsoEmEff2Occ1D_, rctIsoEmEff1Occ1D_, rctIsoEmEff2oneD_);
    DivideME2D(rctIsoEmEff2Occ_, rctIsoEmEff1Occ_, rctIsoEmEff2_) ;
//    DivideME1D(rctIsoEmIneff2Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmIneff2oneD_);
//    DivideME2D(rctIsoEmIneff2Occ_, rctIsoEmEmulOcc_, rctIsoEmIneff2_) ;
    DivideME1D(rctIsoEmIneff2Occ1D_, rctIsoEmEff1Occ1D_, rctIsoEmIneff2oneD_);
    DivideME2D(rctIsoEmIneff2Occ_, rctIsoEmEff1Occ_, rctIsoEmIneff2_) ;

    DivideME1D(rctNisoEmEff1Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmEff1oneD_);
    DivideME2D(rctNisoEmEff1Occ_, rctNisoEmEmulOcc_, rctNisoEmEff1_);
//    DivideME1D(rctNisoEmEff2Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmEff2oneD_);
//    DivideME2D(rctNisoEmEff2Occ_, rctNisoEmEmulOcc_, rctNisoEmEff2_);
    DivideME1D(rctNisoEmEff2Occ1D_, rctNisoEmEff1Occ1D_, rctNisoEmEff2oneD_);
    DivideME2D(rctNisoEmEff2Occ_, rctNisoEmEff1Occ_, rctNisoEmEff2_);
//    DivideME1D(rctNisoEmIneff2Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmIneff2oneD_);
//    DivideME2D(rctNisoEmIneff2Occ_, rctNisoEmEmulOcc_, rctNisoEmIneff2_);
    DivideME1D(rctNisoEmIneff2Occ1D_, rctNisoEmEff1Occ1D_, rctNisoEmIneff2oneD_);
    DivideME2D(rctNisoEmIneff2Occ_, rctNisoEmEff1Occ_, rctNisoEmIneff2_);

    DivideME1D(rctIsoEmIneffOcc1D_, rctIsoEmEmulOcc1D_, rctIsoEmIneff1D_);
    DivideME2D(rctIsoEmIneffOcc_, rctIsoEmEmulOcc_, rctIsoEmIneff_);
    DivideME1D(rctNisoEmIneffOcc1D_, rctNisoEmEmulOcc1D_, rctNisoEmIneff1D_);
    DivideME2D(rctNisoEmIneffOcc_, rctNisoEmEmulOcc_, rctNisoEmIneff_);

    DivideME2D(trigEffTriggThreshOcc_, trigEffThreshOcc_, trigEffThresh_);
    if(singlechannelhistos_) {
      for(int i = 0; i < nelectrE; i++)
    {
      int chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
      DivideME1D(trigEffTriggOcc_[chnl], trigEffOcc_[chnl], trigEff_[chnl]);
    }
    }

    for(int i = 0; i < nelectrD; i++)
    {
      Bool_t found = kFALSE;

      for(int j = 0; j < nelectrE; j++)
      {
        if(electronEmulEta[k][j]==electronDataEta[k][i] &&
           electronEmulPhi[k][j]==electronDataPhi[k][i])
        {
          found = kTRUE;
        }
      }

      if(found == kFALSE)
      {
        if(k==0)
        {
          rctIsoEmOvereffOcc_->Fill(electronDataEta[k][i], electronDataPhi[k][i], 0.98);
          // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99

          int chnl;

      //Store the bit map for the emulator
      bitset<8> bit( electronDataRank[k][i] );
      for( size_t n=0; n < bit.size(); n++){
         if( n < 4 ){ rctIsoEmBitOn_->Fill( electronDataEta[k][i], electronDataPhi[k][i]+n*0.25, bit[n] ); }
         if( n >= 4 ){ rctIsoEmBitOn_->Fill( electronDataEta[k][i]+0.5, electronDataPhi[k][i]+(n-4)*0.25, bit[n] ); }
      }

          chnl=PHIBINS*electronDataEta[k][i]+electronDataPhi[k][i];
          rctIsoEmOvereffOcc1D_->Fill(chnl);

          if(singlechannelhistos_)
          {
            rctIsoOvereffChannel_[chnl]->Fill(electronDataRank[k][i]);
          }
        }

        else
        {
          rctNisoEmOvereffOcc_->Fill(electronDataEta[k][i], electronDataPhi[k][i], 0.98);
          // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99

          int chnl;

      //Store the bit map for the emulator
      bitset<8> bit( electronDataRank[k][i] );
      for( size_t n=0; n < bit.size(); n++){
         if( n < 4 ){ rctNIsoEmBitOn_->Fill( electronDataEta[k][i], electronDataPhi[k][i]+n*0.25, bit[n] ); }
         if( n >= 4 ){ rctNIsoEmBitOn_->Fill( electronDataEta[k][i]+0.5, electronDataPhi[k][i]+(n-4)*0.25, bit[n] ); }
      }

          chnl=PHIBINS*electronDataEta[k][i]+electronDataPhi[k][i];
          rctNisoEmOvereffOcc1D_->Fill(chnl) ;

          if(singlechannelhistos_)
          {
            rctNisoOvereffChannel_[chnl]->Fill(electronDataRank[k][i]);
          }
        }
      }
    }

  }

    // we try new definition of overefficiency:
    DivideME1D(rctIsoEmOvereffOcc1D_, rctIsoEmDataOcc1D_, rctIsoEmOvereff1D_);
    DivideME2D(rctIsoEmOvereffOcc_, rctIsoEmDataOcc_, rctIsoEmOvereff_);
    DivideME1D(rctNisoEmOvereffOcc1D_, rctNisoEmDataOcc1D_, rctNisoEmOvereff1D_);
    DivideME2D(rctNisoEmOvereffOcc_, rctNisoEmDataOcc_, rctNisoEmOvereff_);


    // calculate region/bit information
  for(unsigned int i = 0; i < (int)PhiEtaMax; i++)
{
      Bool_t regFound       = kFALSE;
      Bool_t overFlowFound  = kFALSE;
      Bool_t tauVetoFound   = kFALSE;
      Bool_t mipFound       = kFALSE;
      Bool_t quietFound     = kFALSE;
      Bool_t hfPlusTauFound = kFALSE;

//       for(int j = 0; j < nRegionData; j++)
//    {
//         if(regionEmulEta[i] == regionDataEta[j] &&
//            regionEmulPhi[i] == regionDataPhi[j])
//         {
          if(regionDataRank[i] >= 1 && regionEmulRank[i] >= 1)
          {
            int chnl;

            chnl = PHIBINS*regionEmulEta[i] + regionEmulPhi[i];
            rctRegMatchedOcc1D_->Fill(chnl);
            rctRegMatchedOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
            // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99

            if(singlechannelhistos_) rctRegEffChannel_[chnl]->Fill(regionEmulRank[i] - regionDataRank[i]);

           // see comments for Iso Eff2

            if(regionEmulRank[i] == regionDataRank[i])
             {
             rctRegSpEffOcc1D_->Fill(chnl);
//             rctRegSpEffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.99001);
             rctRegSpEffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98012);
             rctRegSpIneffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.0099);
             }
            else
             {
             rctRegSpIneffOcc1D_->Fill(chnl);
             rctRegSpIneffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.9801);

          bitset<10> bitDifference( regionEmulRank[i]^regionDataRank[i] );
          for( size_t n=0; n < bitDifference.size(); n++){
          if( n < 5 ){ rctRegBitDiff_->Fill( regionEmulEta[i], regionEmulPhi[i]+n*0.2, bitDifference[n] ); }
          if( n >= 5 ){ rctRegBitDiff_->Fill( regionEmulEta[i]+0.5, regionEmulPhi[i]+(n-5)*0.2, bitDifference[n] ); }
          }

             }
            // Weight is for ROOT; should just exceed 0.99
            // NOTE: Weight is different for eff 2 because this isn't filled initially

            regFound = kTRUE;
          }

          if(regionEmulOverFlow[i] == true &&
             regionDataOverFlow[i] == true)
          {
            rctBitMatchedOverFlow2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
            overFlowFound = kTRUE;
          }

          if(regionEmulTauVeto[i] == true &&
             regionDataTauVeto[i] == true)
          {
            rctBitMatchedTauVeto2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
            tauVetoFound = kTRUE;
          }

          if (regionEmulMip[i] == true && regionDataMip[i] == true) {
            rctBitMatchedMip2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98001);
            mipFound = kTRUE;
          }

          if (regionEmulQuiet[i] == true && regionDataQuiet[i] == true) {
            rctBitMatchedQuiet2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98001);
            quietFound = kTRUE;
          }

          if (regionEmulHfPlusTau[i] == true && regionDataHfPlusTau[i] == true) {
            rctBitMatchedHfPlusTau2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98001);
            hfPlusTauFound = kTRUE;
          }


//         }
//       }



      if(regFound == kFALSE && regionEmulRank[i] >= 1 )
      {
        int chnl;

    bitset<10> bit( regionEmulRank[i] );
    for( size_t n=0; n < bit.size(); n++){
       if( n < 5 ){ rctRegBitOff_->Fill( regionEmulEta[i], regionEmulPhi[i]+n*0.2, bit[n] ); }
       if( n >= 5 ){ rctRegBitOff_->Fill( regionEmulEta[i]+0.5, regionEmulPhi[i]+(n-5)*0.2, bit[n] ); }
    }

        chnl = PHIBINS*regionEmulEta[i] + regionEmulPhi[i];
        rctRegUnmatchedEmulOcc1D_->Fill(chnl);
        rctRegUnmatchedEmulOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i],0.98);
        // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99

        if(singlechannelhistos_) rctRegIneffChannel_[chnl]->Fill(regionEmulRank[i]);
      }

      if(overFlowFound == kFALSE && regionEmulOverFlow[i] == true)
      {
        rctBitUnmatchedEmulOverFlow2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
      }

      if(tauVetoFound == kFALSE && regionEmulTauVeto[i] == true)
      {
        rctBitUnmatchedEmulTauVeto2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
      }

      if (mipFound == kFALSE && regionEmulMip[i] == true) {
        rctBitUnmatchedEmulMip2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98);
      }

      if (quietFound == kFALSE && regionEmulQuiet[i] == true) {
        rctBitUnmatchedEmulQuiet2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98);
      }

      if (hfPlusTauFound == kFALSE && regionEmulHfPlusTau[i] == true ) {
        rctBitUnmatchedEmulHfPlusTau2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98);
      }


}


      DivideME1D(rctRegMatchedOcc1D_, rctRegEmulOcc1D_, rctRegEff1D_);
      DivideME2D(rctRegMatchedOcc2D_, rctRegEmulOcc2D_, rctRegEff2D_);
//      DivideME1D(rctRegSpEffOcc1D_, rctRegEmulOcc1D_, rctRegSpEff1D_);
//      DivideME2D(rctRegSpEffOcc2D_, rctRegEmulOcc2D_, rctRegSpEff2D_);
      DivideME1D(rctRegSpEffOcc1D_, rctRegMatchedOcc1D_, rctRegSpEff1D_);
      DivideME2D(rctRegSpEffOcc2D_, rctRegMatchedOcc2D_, rctRegSpEff2D_);
//      DivideME1D(rctRegSpIneffOcc1D_, rctRegEmulOcc1D_, rctRegSpIneff1D_);
//      DivideME2D(rctRegSpIneffOcc2D_, rctRegEmulOcc2D_, rctRegSpIneff2D_);
      DivideME1D(rctRegSpIneffOcc1D_, rctRegMatchedOcc1D_, rctRegSpIneff1D_);
      DivideME2D(rctRegSpIneffOcc2D_, rctRegMatchedOcc2D_, rctRegSpIneff2D_);
      DivideME2D(rctBitMatchedOverFlow2D_, rctBitEmulOverFlow2D_, rctBitOverFlowEff2D_);
      DivideME2D(rctBitMatchedTauVeto2D_, rctBitEmulTauVeto2D_, rctBitTauVetoEff2D_);
      DivideME2D (rctBitMatchedMip2D_, rctBitEmulMip2D_, rctBitMipEff2D_);
      // QUIETBIT: To add quiet bit information, uncomment following line:
      // DivideME2D (rctBitMatchedQuiet2D_, rctBitEmulQuiet2D_, rctBitQuietEff2D_);
      DivideME2D (rctBitMatchedHfPlusTau2D_, rctBitEmulHfPlusTau2D_, rctBitHfPlusTauEff2D_);

      DivideME1D (rctRegUnmatchedEmulOcc1D_, rctRegEmulOcc1D_, rctRegIneff1D_);
      DivideME2D (rctRegUnmatchedEmulOcc2D_, rctRegEmulOcc2D_, rctRegIneff2D_);
      DivideME2D (rctBitUnmatchedEmulOverFlow2D_, rctBitEmulOverFlow2D_, rctBitOverFlowIneff2D_);
      DivideME2D (rctBitUnmatchedEmulTauVeto2D_, rctBitEmulTauVeto2D_, rctBitTauVetoIneff2D_);
      DivideME2D (rctBitUnmatchedEmulMip2D_, rctBitEmulMip2D_, rctBitMipIneff2D_);
      // QUIETBIT: To add quiet bit information, uncomment the following line:
      // DivideME2D (rctBitUnmatchedEmulQuiet2D_, rctBitEmulQuiet2D_, rctBitQuietIneff2D_);
      DivideME2D (rctBitUnmatchedEmulHfPlusTau2D_, rctBitEmulHfPlusTau2D_, rctBitHfPlusTauIneff2D_);


  // for(int i = 0; i < nRegionData; i++)
  for (int i = 0; i < (int)PhiEtaMax; i++)
{
      Bool_t regFound       = kFALSE;
      Bool_t overFlowFound  = kFALSE;
      Bool_t tauVetoFound   = kFALSE;
      Bool_t mipFound       = kFALSE;
      Bool_t quietFound     = kFALSE;
      Bool_t hfPlusTauFound = kFALSE;

//       for(int j = 0; j < nRegionEmul; j++)
//      {
//         if(regionEmulEta[j] == regionDataEta[i] &&
//            regionEmulPhi[j] == regionDataPhi[i])
//         {

          if(regionEmulRank[i] >= 1 && regionDataRank[i] >= 1)
            regFound = kTRUE;

          if(regionDataOverFlow[i] == true &&
             regionEmulOverFlow[i] == true)
            overFlowFound = kTRUE;

          if(regionDataTauVeto[i] == true &&
             regionEmulTauVeto[i] == true)
            tauVetoFound = kTRUE;

          if (regionDataMip[i] == true && regionEmulMip[i] == true)
            mipFound = kTRUE;

          if (regionDataQuiet[i] == true && regionEmulQuiet[i] == true)
            quietFound = kTRUE;

          if (regionDataHfPlusTau[i] == true && regionEmulHfPlusTau[i] == true)
            hfPlusTauFound = kTRUE;
//         }
//       }

      if(regFound == kFALSE && regionDataRank[i] >= 1)
      {
        int chnl;

    bitset<10> bit( regionDataRank[i] );
    for( size_t n=0; n < bit.size(); n++){
        if( n < 5 ){ rctRegBitOn_->Fill( regionDataEta[i], regionDataPhi[i]+n*0.2, bit[n] ); }
        if( n >= 5 ){ rctRegBitOn_->Fill( regionDataEta[i]+0.5, regionDataPhi[i]+(n-5)*0.2, bit[n] ); }
    }


        chnl = PHIBINS*regionDataEta[i] + regionDataPhi[i];
        rctRegUnmatchedDataOcc1D_->Fill(chnl);
        rctRegUnmatchedDataOcc2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
        // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99

        // we try a new definition of overefficiency:
        // DivideME1D(rctRegUnmatchedDataOcc1D_, rctRegDataOcc1D_, rctRegOvereff1D_);
        // DivideME2D(rctRegUnmatchedDataOcc2D_, rctRegDataOcc2D_, rctRegOvereff2D_);

        if(singlechannelhistos_) rctRegOvereffChannel_[chnl]->Fill(regionDataRank[i]);
      }

      if(overFlowFound == kFALSE && regionDataOverFlow[i] == true )
      {
        rctBitUnmatchedDataOverFlow2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
      }

      if(tauVetoFound == kFALSE && regionDataTauVeto[i] == true )
      {
        rctBitUnmatchedDataTauVeto2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
      }

      if (mipFound == kFALSE && regionDataMip[i] == true ) {
        rctBitUnmatchedDataMip2D_->Fill (regionDataEta[i], regionDataPhi[i], 0.98);
      }

      if (quietFound == kFALSE && regionDataQuiet[i] == true ) {
        rctBitUnmatchedDataQuiet2D_->Fill (regionDataEta[i], regionDataPhi[i], 0.98);
      }

      if (hfPlusTauFound == kFALSE && regionDataHfPlusTau[i] == true ) {
        rctBitUnmatchedDataHfPlusTau2D_->Fill (regionDataEta[i], regionDataPhi[i], 0.98);
      }

}

    // we try a new definition of overefficiency:
    DivideME1D(rctRegUnmatchedDataOcc1D_, rctRegDataOcc1D_, rctRegOvereff1D_);
    DivideME2D(rctRegUnmatchedDataOcc2D_, rctRegDataOcc2D_, rctRegOvereff2D_);
    DivideME2D(rctBitUnmatchedDataOverFlow2D_, rctBitDataOverFlow2D_, rctBitOverFlowOvereff2D_);
    DivideME2D(rctBitUnmatchedDataTauVeto2D_, rctBitDataTauVeto2D_, rctBitTauVetoOvereff2D_);
    DivideME2D (rctBitUnmatchedDataMip2D_, rctBitDataMip2D_,
          rctBitMipOvereff2D_);
    // QUIETBIT: To add quiet bit information, uncomment following 2 lines:
    // DivideME2D (rctBitUnmatchedDataQuiet2D_, rctBitDataQuiet2D_,
          // rctBitQuietOvereff2D_);
    DivideME2D (rctBitUnmatchedDataHfPlusTau2D_, rctBitDataHfPlusTau2D_,
          rctBitHfPlusTauOvereff2D_);

}

void L1TdeRCT::beginJob ( void  )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 180 of file L1TdeRCT.cc.

References BITETABINS, BITETAMAX, BITETAMIN, BITPHIBINS, BITPHIMAX, BITPHIMIN, BITRPHIBINS, BITRPHIMAX, BITRPHIMIN, DQMStore::book1D(), DQMStore::book2D(), CHNLBINS, CHNLMAX, CHNLMIN, crateFED, dbe, DEBINS, DEMAX, DEMIN, ELBINS, ELMAX, ELMIN, ETABINS, ETAMAX, ETAMIN, fedVectorMonitorLS_, fedVectorMonitorRUN_, MonitorElement::getTH2F(), histFolder_, i, j, m, mergeVDriftHistosByStation::name, nev_, notrigCount, cppFunctionSkipper::operator, PHIBINS, PHIMAX, PHIMIN, rctBitDataHfPlusTau2D_, rctBitDataMip2D_, rctBitDataOverFlow2D_, rctBitDataQuiet2D_, rctBitDataTauVeto2D_, rctBitEmulHfPlusTau2D_, rctBitEmulMip2D_, rctBitEmulOverFlow2D_, rctBitEmulQuiet2D_, rctBitEmulTauVeto2D_, rctBitHfPlusTauEff2D_, rctBitHfPlusTauIneff2D_, rctBitHfPlusTauOvereff2D_, rctBitMatchedHfPlusTau2D_, rctBitMatchedMip2D_, rctBitMatchedOverFlow2D_, rctBitMatchedQuiet2D_, rctBitMatchedTauVeto2D_, rctBitMipEff2D_, rctBitMipIneff2D_, rctBitMipOvereff2D_, rctBitOverFlowEff2D_, rctBitOverFlowIneff2D_, rctBitOverFlowOvereff2D_, rctBitTauVetoEff2D_, rctBitTauVetoIneff2D_, rctBitTauVetoOvereff2D_, rctBitUnmatchedDataHfPlusTau2D_, rctBitUnmatchedDataMip2D_, rctBitUnmatchedDataOverFlow2D_, rctBitUnmatchedDataQuiet2D_, rctBitUnmatchedDataTauVeto2D_, rctBitUnmatchedEmulHfPlusTau2D_, rctBitUnmatchedEmulMip2D_, rctBitUnmatchedEmulOverFlow2D_, rctBitUnmatchedEmulQuiet2D_, rctBitUnmatchedEmulTauVeto2D_, rctInputTPGEcalOcc_, rctInputTPGEcalOccNoCut_, rctInputTPGEcalRank_, rctInputTPGHcalOcc_, rctInputTPGHcalRank_, rctInputTPGHcalSample_, rctIsoEffChannel_, rctIsoEmBitDiff_, rctIsoEmBitOff_, rctIsoEmBitOn_, rctIsoEmDataOcc1D_, rctIsoEmDataOcc_, rctIsoEmEff1_, rctIsoEmEff1Occ1D_, rctIsoEmEff1Occ_, rctIsoEmEff1oneD_, rctIsoEmEff2_, rctIsoEmEff2Occ1D_, rctIsoEmEff2Occ_, rctIsoEmEff2oneD_, rctIsoEmEmulOcc1D_, rctIsoEmEmulOcc_, rctIsoEmIneff1D_, rctIsoEmIneff2_, rctIsoEmIneff2Occ1D_, rctIsoEmIneff2Occ_, rctIsoEmIneff2oneD_, rctIsoEmIneff_, rctIsoEmIneffOcc1D_, rctIsoEmIneffOcc_, rctIsoEmOvereff1D_, rctIsoEmOvereff_, rctIsoEmOvereffOcc1D_, rctIsoEmOvereffOcc_, rctIsoIneffChannel_, rctIsoOvereffChannel_, rctNisoEffChannel_, rctNIsoEmBitDiff_, rctNIsoEmBitOff_, rctNIsoEmBitOn_, rctNisoEmDataOcc1D_, rctNisoEmDataOcc_, rctNisoEmEff1_, rctNisoEmEff1Occ1D_, rctNisoEmEff1Occ_, rctNisoEmEff1oneD_, rctNisoEmEff2_, rctNisoEmEff2Occ1D_, rctNisoEmEff2Occ_, rctNisoEmEff2oneD_, rctNisoEmEmulOcc1D_, rctNisoEmEmulOcc_, rctNisoEmIneff1D_, rctNisoEmIneff2_, rctNisoEmIneff2Occ1D_, rctNisoEmIneff2Occ_, rctNisoEmIneff2oneD_, rctNisoEmIneff_, rctNisoEmIneffOcc1D_, rctNisoEmIneffOcc_, rctNisoEmOvereff1D_, rctNisoEmOvereff_, rctNisoEmOvereffOcc1D_, rctNisoEmOvereffOcc_, rctNisoIneffChannel_, rctNisoOvereffChannel_, rctRegBitDiff_, rctRegBitOff_, rctRegBitOn_, rctRegDataOcc1D_, rctRegDataOcc2D_, rctRegEff1D_, rctRegEff2D_, rctRegEffChannel_, rctRegEmulOcc1D_, rctRegEmulOcc2D_, rctRegIneff1D_, rctRegIneff2D_, rctRegIneffChannel_, rctRegMatchedOcc1D_, rctRegMatchedOcc2D_, rctRegOvereff1D_, rctRegOvereff2D_, rctRegOvereffChannel_, rctRegSpEff1D_, rctRegSpEff2D_, rctRegSpEffOcc1D_, rctRegSpEffOcc2D_, rctRegSpIneff1D_, rctRegSpIneff2D_, rctRegSpIneffOcc1D_, rctRegSpIneffOcc2D_, rctRegUnmatchedDataOcc1D_, rctRegUnmatchedDataOcc2D_, rctRegUnmatchedEmulOcc1D_, rctRegUnmatchedEmulOcc2D_, DQMStore::rmdir(), DQMStore::setCurrentFolder(), singlechannelhistos_, TPGETABINS, TPGETAMAX, TPGETAMIN, TPGPHIBINS, TPGPHIMAX, TPGPHIMIN, TPGRANK, TPGRANKMAX, TPGRANKMIN, trigCount, trigEff_, trigEffOcc_, trigEffThresh_, trigEffThreshOcc_, trigEffTriggOcc_, trigEffTriggThreshOcc_, triggerAlgoNumbers_, and triggerType_.

{

  nev_ = 0;

  // get hold of back-end interface
  DQMStore *dbe = 0;
  dbe = Service < DQMStore > ().operator->();

  if (dbe) {
    dbe->setCurrentFolder(histFolder_);
    dbe->rmdir(histFolder_);
  }


  if (dbe) {

    dbe->setCurrentFolder(histFolder_);

    triggerType_ =
      dbe->book1D("TriggerType", "TriggerType", 17, -0.5, 16.5);

    triggerAlgoNumbers_ =
      dbe->book1D("gtTriggerAlgoNumbers", "gtTriggerAlgoNumbers", 128, -0.5, 127.5);

    rctInputTPGEcalOcc_ =
  dbe->book2D("rctInputTPGEcalOcc", "rctInputTPGEcalOcc", TPGETABINS, TPGETAMIN,
        TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);

    rctInputTPGEcalOccNoCut_ =
  dbe->book2D("rctInputTPGEcalOccNoCut", "rctInputTPGEcalOccNoCut", TPGETABINS, TPGETAMIN,
        TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);

    rctInputTPGEcalRank_ =
  dbe->book1D("rctInputTPGEcalRank", "rctInputTPGEcalRank", TPGRANK, TPGRANKMIN, TPGRANKMAX) ;

    rctInputTPGHcalOcc_ =
  dbe->book2D("rctInputTPGHcalOcc", "rctInputTPGHcalOcc", TPGETABINS, TPGETAMIN,
        TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);

    rctInputTPGHcalSample_ =
  dbe->book1D("rctInputTPGHcalSample", "rctInputTPGHcalSample", 10, -0.5, 9.5) ;

    rctInputTPGHcalRank_ =
  dbe->book1D("rctInputTPGHcalRank", "rctInputTPGHcalRank", TPGRANK, TPGRANKMIN, TPGRANKMAX) ;

    dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/");

    trigEffThresh_ =
      dbe->book2D("trigEffThresh", "Rank occupancy >= 2x trig thresh",
          ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData");

    trigEffThreshOcc_ =
      dbe->book2D("trigEffThreshOcc", "Rank occupancy >= 2x trig thresh",
          ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
    trigEffTriggThreshOcc_ =
      dbe->book2D("trigEffTriggThreshOcc", "Rank occupancy >= 2x trig thresh, triggered",
          ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    dbe->setCurrentFolder(histFolder_+"/IsoEm");

    rctIsoEmEff1_ =
  dbe->book2D("rctIsoEmEff1", "rctIsoEmEff1", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmEff1oneD_ =
  dbe->book1D("rctIsoEmEff1oneD", "rctIsoEmEff1oneD",
        CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmEff2_ =
  dbe->book2D("rctIsoEmEff2", "rctIsoEmEff2, energy matching required", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmEff2oneD_ =
  dbe->book1D("rctIsoEmEff2oneD", "rctIsoEmEff2oneD, energy matching required",
        CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmIneff2_ =
  dbe->book2D("rctIsoEmIneff2", "rctIsoEmIneff2, energy matching required", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmIneff2oneD_ =
  dbe->book1D("rctIsoEmIneff2oneD", "rctIsoEmIneff2oneD, energy matching required",
        CHNLBINS, CHNLMIN, CHNLMAX);


    rctIsoEmIneff_ =
  dbe->book2D("rctIsoEmIneff", "rctIsoEmIneff", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmIneff1D_ =
  dbe->book1D("rctIsoEmIneff1D", "rctIsoEmIneff1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmOvereff_ =
  dbe->book2D("rctIsoEmOvereff", "rctIsoEmOvereff", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmOvereff1D_ =
  dbe->book1D("rctIsoEmOvereff1D", "rctIsoEmOvereff1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData");

    rctIsoEmDataOcc_ =
  dbe->book2D("rctIsoEmDataOcc", "rctIsoEmDataOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmDataOcc1D_ =
  dbe->book1D("rctIsoEmDataOcc1D", "rctIsoEmDataOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmEmulOcc_ =
  dbe->book2D("rctIsoEmEmulOcc", "rctIsoEmEmulOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmEmulOcc1D_ =
  dbe->book1D("rctIsoEmEmulOcc1D", "rctIsoEmEmulOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmEff1Occ_ =
  dbe->book2D("rctIsoEmEff1Occ", "rctIsoEmEff1Occ", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmEff1Occ1D_ =
  dbe->book1D("rctIsoEmEff1Occ1D", "rctIsoEmEff1Occ1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmEff2Occ_ =
  dbe->book2D("rctIsoEmEff2Occ", "rctIsoEmEff2Occ", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmEff2Occ1D_ =
  dbe->book1D("rctIsoEmEff2Occ1D", "rctIsoEmEff2Occ1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmIneff2Occ_ =
  dbe->book2D("rctIsoEmIneff2Occ", "rctIsoEmIneff2Occ", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmIneff2Occ1D_ =
  dbe->book1D("rctIsoEmIneff2Occ1D", "rctIsoEmIneff2Occ1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmIneffOcc_ =
  dbe->book2D("rctIsoEmIneffOcc", "rctIsoEmIneffOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmIneffOcc1D_ =
  dbe->book1D("rctIsoEmIneffOcc1D", "rctIsoEmIneffOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctIsoEmOvereffOcc_ =
  dbe->book2D("rctIsoEmOvereffOcc", "rctIsoEmOvereffOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctIsoEmOvereffOcc1D_ =
  dbe->book1D("rctIsoEmOvereffOcc1D", "rctIsoEmOvereffOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);


    dbe->setCurrentFolder(histFolder_+"/NisoEm");
    rctNisoEmEff1_ =
  dbe->book2D("rctNisoEmEff1", "rctNisoEmEff1", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmEff1oneD_ =
  dbe->book1D("rctNisoEmEff1oneD", "rctNisoEmEff1oneD",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmEff2_ =
  dbe->book2D("rctNisoEmEff2", "rctNisoEmEff2, energy matching required", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmEff2oneD_ =
  dbe->book1D("rctNisoEmEff2oneD", "rctNisoEmEff2oneD, energy matching required",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmIneff2_ =
  dbe->book2D("rctNisoEmIneff2", "rctNisoEmIneff2, energy matching required", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmIneff2oneD_ =
  dbe->book1D("rctNisoEmIneff2oneD", "rctNisoEmIneff2oneD, energy matching required",
                    CHNLBINS, CHNLMIN, CHNLMAX);


    rctNisoEmIneff_ =
  dbe->book2D("rctNisoEmIneff", "rctNisoEmIneff", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmIneff1D_ =
  dbe->book1D("rctNisoEmIneff1D", "rctNisoEmIneff1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmOvereff_ =
  dbe->book2D("rctNisoEmOvereff", "rctNisoEmOvereff", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmOvereff1D_ =
  dbe->book1D("rctNisoEmOvereff1D", "rctNisoEmOvereff1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData");

    rctNisoEmDataOcc_ =
  dbe->book2D("rctNisoEmDataOcc", "rctNisoEmDataOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmDataOcc1D_ =
  dbe->book1D("rctNisoEmDataOcc1D", "rctNisoEmDataOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmEmulOcc_ =
  dbe->book2D("rctNisoEmEmulOcc", "rctNisoEmEmulOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmEmulOcc1D_ =
  dbe->book1D("rctNisoEmEmulOcc1D", "rctNisoEmEmulOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmEff1Occ_ =
  dbe->book2D("rctNisoEmEff1Occ", "rctNisoEmEff1Occ", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmEff1Occ1D_ =
  dbe->book1D("rctNisoEmEff1Occ1D", "rctNisoEmEff1Occ1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmEff2Occ_ =
  dbe->book2D("rctNisoEmEff2Occ", "rctNisoEmEff2Occ", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmEff2Occ1D_ =
  dbe->book1D("rctNisoEmEff2Occ1D", "rctNisoEmEff2Occ1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmIneff2Occ_ =
  dbe->book2D("rctNisoEmIneff2Occ", "rctNisoEmIneff2Occ", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmIneff2Occ1D_ =
  dbe->book1D("rctNisoEmIneff2Occ1D", "rctNisoEmIneff2Occ1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmIneffOcc_ =
  dbe->book2D("rctNisoEmIneffOcc", "rctNisoEmIneffOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmIneffOcc1D_ =
  dbe->book1D("rctNisoEmIneffOcc1D", "rctNisoEmIneffOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    rctNisoEmOvereffOcc_ =
  dbe->book2D("rctNisoEmOvereffOcc", "rctNisoEmOvereffOcc", ETABINS, ETAMIN,
        ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctNisoEmOvereffOcc1D_ =
  dbe->book1D("rctNisoEmOvereffOcc1D", "rctNisoEmOvereffOcc1D",
                    CHNLBINS, CHNLMIN, CHNLMAX);

    // region information
    dbe->setCurrentFolder(histFolder_+"/RegionData");

    rctRegEff1D_ =
      dbe->book1D("rctRegEff1D", "1D region efficiency",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegIneff1D_ =
      dbe->book1D("rctRegIneff1D", "1D region inefficiency",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegOvereff1D_ =
      dbe->book1D("rctRegOvereff1D", "1D region overefficiency",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegSpEff1D_ =
      dbe->book1D("rctRegSpEff1D", "1D region efficiency, energy matching required",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegSpIneff1D_ =
      dbe->book1D("rctRegSpIneff1D", "1D region inefficiency, energy matching required",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegEff2D_ =
      dbe->book2D("rctRegEff2D", "2D region efficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegIneff2D_ =
      dbe->book2D("rctRegIneff2D", "2D region inefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegOvereff2D_ =
      dbe->book2D("rctRegOvereff2D", "2D region overefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegSpEff2D_ =
      dbe->book2D("rctRegSpEff2D", "2D region efficiency, energy matching required",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegSpIneff2D_ =
      dbe->book2D("rctRegSpIneff2D", "2D region inefficiency, energy matching required",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData");

    rctRegDataOcc1D_ =
      dbe->book1D("rctRegDataOcc1D", "1D region occupancy from data",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegEmulOcc1D_ =
      dbe->book1D("rctRegEmulOcc1D", "1D region occupancy from emulator",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegMatchedOcc1D_ =
      dbe->book1D("rctRegMatchedOcc1D", "1D region occupancy for matched hits",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegUnmatchedDataOcc1D_ =
      dbe->book1D("rctRegUnmatchedDataOcc1D", "1D region occupancy for unmatched hardware hits",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegUnmatchedEmulOcc1D_ =
      dbe->book1D("rctRegUnmatchedEmulOcc1D", "1D region occupancy for unmatched emulator hits",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegSpEffOcc1D_ =
      dbe->book1D("rctRegSpEffOcc1D", "1D region occupancy for \\Delta E_{T} efficiency",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegSpIneffOcc1D_ =
      dbe->book1D("rctRegSpIneffOcc1D", "1D region occupancy for \\Delta E_{T} efficiency ",
      CHNLBINS, CHNLMIN, CHNLMAX);

    rctRegDataOcc2D_ =
      dbe->book2D("rctRegDataOcc2D", "2D region occupancy from hardware",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegEmulOcc2D_ =
      dbe->book2D("rctRegEmulOcc2D", "2D region occupancy from emulator",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegMatchedOcc2D_ =
      dbe->book2D("rctRegMatchedOcc2D", "2D region occupancy for matched hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegUnmatchedDataOcc2D_ =
      dbe->book2D("rctRegUnmatchedDataOcc2D", "2D region occupancy for unmatched hardware hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegUnmatchedEmulOcc2D_ =
      dbe->book2D("rctRegUnmatchedEmulOcc2D", "2D region occupancy for unmatched emulator hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

//    rctRegDeltaEt2D_ =
//      dbe->book2D("rctRegDeltaEt2D", " \\Delta E_{T}  for each channel",
//      CHNLBINS, CHNLMIN, CHNLMAX, 100, -50., 50.);

    rctRegSpEffOcc2D_ =
      dbe->book2D("rctRegSpEffOcc2D", "2D region occupancy for \\Delta E_{T} efficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctRegSpIneffOcc2D_ =
      dbe->book2D("rctRegSpIneffOcc2D", "2D region occupancy for \\Delta E_{T} inefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    // bit information
    dbe->setCurrentFolder(histFolder_+"/BitData");

    rctBitOverFlowEff2D_ =
      dbe->book2D("rctBitOverFlowEff2D", "2D overflow bit efficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitOverFlowIneff2D_ =
      dbe->book2D("rctBitOverFlowIneff2D", "2D overflow bit inefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitOverFlowOvereff2D_ =
      dbe->book2D("rctBitOverFlowOvereff2D", "2D overflow bit overefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitTauVetoEff2D_ =
      dbe->book2D("rctBitTauVetoEff2D", "2D tau veto bit efficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitTauVetoIneff2D_ =
      dbe->book2D("rctBitTauVetoIneff2D", "2D tau veto bit inefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitTauVetoOvereff2D_ =
      dbe->book2D("rctBitTauVetoOvereff2D", "2D tau veto bit overefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMipEff2D_ =
      dbe->book2D("rctBitMipEff2D", "2D mip bit efficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMipIneff2D_ =
      dbe->book2D("rctBitMipIneff2D", "2D mip bit inefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMipOvereff2D_ =
      dbe->book2D("rctBitMipOvereff2D", "2D mip bit overefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    // QUIETBIT: To add quiet bit information, uncomment following 11 lines:
    // rctBitQuietEff2D_ =
      // dbe->book2D("rctBitQuietEff2D", "2D quiet bit efficiency",
      // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    // rctBitQuietIneff2D_ =
      // dbe->book2D("rctBitQuietIneff2D", "2D quiet bit inefficiency",
      // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    // rctBitQuietOvereff2D_ =
      // dbe->book2D("rctBitQuietOvereff2D", "2D quiet bit overefficiency",
      // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitHfPlusTauEff2D_ =
      dbe->book2D("rctBitHfPlusTauEff2D", "2D HfPlusTau bit efficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitHfPlusTauIneff2D_ =
      dbe->book2D("rctBitHfPlusTauIneff2D", "2D HfPlusTau bit inefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitHfPlusTauOvereff2D_ =
      dbe->book2D("rctBitHfPlusTauOvereff2D", "2D HfPlusTau bit overefficiency",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    dbe->setCurrentFolder(histFolder_+"/BitData/ServiceData");

    rctBitEmulOverFlow2D_ =
      dbe->book2D("rctBitEmulOverFlow2D", "2D overflow bit from emulator",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitDataOverFlow2D_ =
      dbe->book2D("rctBitDataOverFlow2D", "2D overflow bit from hardware",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMatchedOverFlow2D_ =
      dbe->book2D("rctBitMatchedOverFlow2D", "2D overflow bit for matched hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedEmulOverFlow2D_ =
      dbe->book2D("rctBitUnmatchedEmulOverFlow2D", "2D overflow bit for unmatched emulator hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedDataOverFlow2D_ =
      dbe->book2D("rctBitUnmatchedDataOverFlow2D", "2D overflow bit for unmatched hardware hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitEmulTauVeto2D_ =
      dbe->book2D("rctBitEmulTauVeto2D", "2D tau veto bit from emulator",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitDataTauVeto2D_ =
      dbe->book2D("rctBitDataTauVeto2D", "2D tau veto bit from hardware",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMatchedTauVeto2D_ =
      dbe->book2D("rctBitMatchedTauVeto2D", "2D tau veto bit for matched hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedEmulTauVeto2D_ =
      dbe->book2D("rctBitUnmatchedEmulTauVeto2D", "2D tau veto bit for unmatched emulator hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedDataTauVeto2D_ =
      dbe->book2D("rctBitUnmatchedDataTauVeto2D", "2D tau veto bit for unmatched hardware hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitEmulMip2D_ =
      dbe->book2D("rctBitEmulMip2D", "2D mip bit from emulator",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitDataMip2D_ =
      dbe->book2D("rctBitDataMip2D", "2D mip bit from hardware",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMatchedMip2D_ =
      dbe->book2D("rctBitMatchedMip2D", "2D mip bit for matched hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedEmulMip2D_ =
      dbe->book2D("rctBitUnmatchedEmulMip2D", "2D mip bit for unmatched emulator hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedDataMip2D_ =
      dbe->book2D("rctBitUnmatchedDataMip2D", "2D mip bit for unmatched hardware hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitEmulQuiet2D_ =
      dbe->book2D("rctBitEmulQuiet2D", "2D quiet bit from emulator",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitDataQuiet2D_ =
      dbe->book2D("rctBitDataQuiet2D", "2D quiet bit from hardware",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMatchedQuiet2D_ =
      dbe->book2D("rctBitMatchedQuiet2D", "2D quiet bit for matched hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedEmulQuiet2D_ =
      dbe->book2D("rctBitUnmatchedEmulQuiet2D", "2D quiet bit for unmatched emulator hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedDataQuiet2D_ =
      dbe->book2D("rctBitUnmatchedDataQuiet2D", "2D quiet bit for unmatched hardware hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitEmulHfPlusTau2D_ =
      dbe->book2D("rctBitEmulHfPlusTau2D", "2D HfPlusTau bit from emulator",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitDataHfPlusTau2D_ =
      dbe->book2D("rctBitDataHfPlusTau2D", "2D HfPlusTau bit from hardware",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitMatchedHfPlusTau2D_ =
      dbe->book2D("rctBitMatchedHfPlusTau2D", "2D HfPlusTau bit for matched hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedEmulHfPlusTau2D_ =
      dbe->book2D("rctBitUnmatchedEmulHfPlusTau2D", "2D HfPlusTau bit for unmatched emulator hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);

    rctBitUnmatchedDataHfPlusTau2D_ =
      dbe->book2D("rctBitUnmatchedDataHfPlusTau2D", "2D HfPlusTau bit for unmatched hardware hits",
      ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
    dbe->setCurrentFolder(histFolder_+"/BitMon");
    rctRegBitOn_ = 
      dbe->book2D("rctRegBitOn", "Monitoring for Bits Stuck On",
      BITETABINS, BITETAMIN, BITETAMAX, BITRPHIBINS, BITRPHIMIN, BITRPHIMAX);

    rctRegBitOff_ = 
      dbe->book2D("rctRegBitOff", "Monitoring for Bits Stuck Off",
      BITETABINS, BITETAMIN, BITETAMAX, BITRPHIBINS, BITRPHIMIN, BITRPHIMAX);

    rctRegBitDiff_ = 
      dbe->book2D("rctRegBitDiff", "Monitoring for Bits Difference",
      BITETABINS, BITETAMIN, BITETAMAX, BITRPHIBINS, BITRPHIMIN, BITRPHIMAX);

    rctIsoEmBitOn_ = 
      dbe->book2D("rctIsoEmBitOn", "Monitoring for Bits Stuck On",
      BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);

    rctIsoEmBitOff_ = 
      dbe->book2D("rctIsoEmBitOff", "Monitoring for Bits Stuck Off",
      BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);

    rctIsoEmBitDiff_ = 
      dbe->book2D("rctIsoEmBitDiff", "Monitoring for Bits Difference",
      BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);

    rctNIsoEmBitOn_ = 
      dbe->book2D("rctNIsoEmBitOn", "Monitoring for Bits Stuck On",
      BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);

    rctNIsoEmBitOff_ = 
      dbe->book2D("rctNIsoEmBitOff", "Monitoring for Bits Stuck Off",
      BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);

    rctNIsoEmBitDiff_ = 
      dbe->book2D("rctNIsoEmBitDiff", "Monitoring for Bits Difference",
      BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);


    dbe->setCurrentFolder(histFolder_+"/DBData");
    fedVectorMonitorRUN_ = dbe->book2D("rctFedVectorMonitorRUN", "FED Vector Monitor Per Run",90,0,90,2,0,2);
    fedVectorMonitorLS_ = dbe->book2D("rctFedVectorMonitorLS", "FED Vector Monitor Per LS",90,0,90,2,0,2);

    for(unsigned int i=0;i<90;++i) {
      char fed[10];
      sprintf(fed,"%d",crateFED[i]);
      fedVectorMonitorRUN_->getTH2F()->GetXaxis()->SetBinLabel(i+1,fed);
      fedVectorMonitorLS_->getTH2F()->GetXaxis()->SetBinLabel(i+1,fed);
    }
      fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(1,"OUT");
      fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(2,"IN");
      fedVectorMonitorLS_->getTH2F()->GetYaxis()->SetBinLabel(1,"OUT");
      fedVectorMonitorLS_->getTH2F()->GetYaxis()->SetBinLabel(2,"IN");

    

// for single channels

    if(singlechannelhistos_)
   {
    for(int m=0; m<12; m++)
    {
    if(m==0) dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData/Eff1SnglChnls");
    if(m==1) dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData/Eff1SnglChnls");
    if(m==2) dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData/EffSnglChnls");
    if(m==3) dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData/IneffSnglChnls");
    if(m==4) dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData/IneffSnglChnls");
    if(m==5) dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData/IneffSnglChnls");
    if(m==6) dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData/OvereffSnglChnls");
    if(m==7) dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData/OvereffSnglChnls");
    if(m==8) dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData/OvereffSnglChnls");
    if(m==9) dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData/SingleChannels");
    if(m==10) dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData/SingleChannels");
    if(m==11) dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData/SingleChannels");

    for(int i=0; i<ETAMAX; i++)
    {
     for(int j=0; j<PHIMAX; j++)
     {
     char name[80], channel[80]={""} ;

     if(m==0) strcpy(name,"(Eemul-Edata)Chnl") ;
     if(m==1) strcpy(name,"(Eemul-Edata)Chnl") ;
     if(m==2) strcpy(name,"(Eemul-Edata)Chnl") ;
     if(m==3) strcpy(name,"EemulChnl") ;
     if(m==4) strcpy(name,"EemulChnl") ;
     if(m==5) strcpy(name,"EemulChnl") ;
     if(m==6) strcpy(name,"EdataChnl") ;
     if(m==7) strcpy(name,"EdataChnl") ;
     if(m==8) strcpy(name,"EdataChnl") ;
     if(m==9) strcpy(name,"EemulChnlEff") ;
     if(m==10) strcpy(name,"EemulChnlTrig") ;
     if(m==11) strcpy(name,"EemulChnl") ;

     if(i<10 && j<10) sprintf(channel,"_0%d0%d",i,j);
     else if(i<10) sprintf(channel,"_0%d%d",i,j);
      else if(j<10) sprintf(channel,"_%d0%d",i,j);
       else sprintf(channel,"_%d%d",i,j);
     strcat(name,channel);

     int chnl=PHIBINS*i+j;

     if(m==0) rctIsoEffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==1) rctNisoEffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==2) rctRegEffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==3) rctIsoIneffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==4) rctNisoIneffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==5) rctRegIneffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==6) rctIsoOvereffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==7) rctNisoOvereffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==8) rctRegOvereffChannel_[chnl] =
  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
     if(m==9) trigEff_[chnl] =
     dbe->book1D(name, name, ELBINS, ELMIN, ELMAX);
     if(m==10) trigEffOcc_[chnl] =
     dbe->book1D(name, name, ELBINS, ELMIN, ELMAX);
     if(m==11) trigEffTriggOcc_[chnl] =
     dbe->book1D(name, name, ELBINS, ELMIN, ELMAX);
     }
    }
    }
   }

//end of single channels


  }
  notrigCount=0;
  trigCount=0;

}

void L1TdeRCT::beginLuminosityBlock ( const edm::LuminosityBlock &  ls, const edm::EventSetup &  es  )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1980 of file L1TdeRCT.cc.

References fedVectorMonitorLS_, and readFEDVector().

{
  readFEDVector(fedVectorMonitorLS_,es);
}

void L1TdeRCT::beginRun ( const edm::Run &  run, const edm::EventSetup &  es  )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1974 of file L1TdeRCT.cc.

References fedVectorMonitorRUN_, and readFEDVector().

{
  readFEDVector(fedVectorMonitorRUN_,es);

}

void L1TdeRCT::DivideME1D ( MonitorElement *  numerator, MonitorElement *  denominator, MonitorElement *  result  )

protected

Definition at line 1963 of file L1TdeRCT.cc.

References MonitorElement::getTH1F().

Referenced by analyze().

                                                                                                       {

   TH1F* num = numerator->getTH1F();
   TH1F* den = denominator->getTH1F();
   TH1F* res = result->getTH1F();

   res->Divide(num,den,1,1,"");

}

void L1TdeRCT::DivideME2D ( MonitorElement *  numerator, MonitorElement *  denominator, MonitorElement *  result  )

protected

Definition at line 1953 of file L1TdeRCT.cc.

References MonitorElement::getTH2F().

Referenced by analyze().

                                                                                                       {

   TH2F* num = numerator->getTH2F();
   TH2F* den = denominator->getTH2F();
   TH2F* res = result->getTH2F();

   res->Divide(num,den,1,1,"");

}

void L1TdeRCT::endJob ( void  )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 854 of file L1TdeRCT.cc.

References gather_cfg::cout, dbe, nev_, outputFile_, DQMStore::save(), and verbose_.

{
  if (verbose_)
    std::cout << "L1TdeRCT: end job...." << std::endl;
  LogInfo("EndJob") << "analyzed " << nev_ << " events";

  if (outputFile_.size() != 0 && dbe)
    dbe->save(outputFile_);

  //std::cout << "trig count is " << trigCount << std::endl;
  //std::cout << "no trig count is " << notrigCount << std::endl;


  return;
}

void L1TdeRCT::readFEDVector ( MonitorElement *  histogram, const edm::EventSetup &  es  )

protected

Definition at line 1985 of file L1TdeRCT.cc.

References crateFED, spr::find(), edm::EventSetup::get(), i, RunInfo::m_fed_in, edm::ESHandle< class >::product(), MonitorElement::setBinContent(), and edmLumisInFiles::summary.

Referenced by beginLuminosityBlock(), and beginRun().

{
  // adding fed mask into channel mask
  edm::ESHandle<RunInfo> sum;
  es.get<RunInfoRcd>().get(sum);
  const RunInfo* summary=sum.product();

  std::vector<int> caloFeds;  // pare down the feds to the intresting ones

  const std::vector<int> Feds = summary->m_fed_in;
  for(std::vector<int>::const_iterator cf = Feds.begin(); cf != Feds.end(); ++cf){
    int fedNum = *cf;
    if(fedNum > 600 && fedNum <724) 
      caloFeds.push_back(fedNum);
  }
  
  for(unsigned int i=0;i<90;++i) {
    std::vector<int>::iterator fv = std::find(caloFeds.begin(),caloFeds.end(),crateFED[i]);
    if(fv!=caloFeds.end()) {
      histogram->setBinContent(i+1,2,1);
      histogram->setBinContent(i+1,1,0);
    }
    else
      {
    histogram->setBinContent(i+1,2,0);
    histogram->setBinContent(i+1,1,1);

      }
    
  }
  
} 

Member Data Documentation

const int L1TdeRCT::crateFED

staticprivate

Initial value:

=
    {613, 614, 603, 702, 718,
     611, 612, 602, 700, 718,
     627, 610, 601,716,  722,
     625, 626, 609, 714, 722,
     623, 624, 608, 712, 722,
     621, 622, 607, 710, 720,
     619, 620, 606, 708, 720,
     617, 618, 605, 706, 720,
     615, 616, 604, 704, 718,
     631, 632, 648, 703, 719,
     629, 630, 647, 701, 719,
     645, 628, 646, 717, 723,
     643, 644, 654, 715, 723,
     641, 642, 653, 713, 723,
     639, 640, 652, 711, 721,
     637, 638, 651, 709, 721,
     635, 636, 650, 707, 721,
     633, 634, 649, 705, 719
}

Definition at line 325 of file L1TdeRCT.h.

Referenced by beginJob(), and readFEDVector().

DQMStore* L1TdeRCT::dbe

private

Definition at line 144 of file L1TdeRCT.h.

Referenced by beginJob(), endJob(), and L1TdeRCT().

int L1TdeRCT::doubleThreshold_

private

Definition at line 346 of file L1TdeRCT.h.

Referenced by analyze().

edm::InputTag L1TdeRCT::ecalTPGData_

private

Definition at line 342 of file L1TdeRCT.h.

Referenced by analyze().

MonitorElement* L1TdeRCT::fedVectorMonitorLS_

private

Definition at line 327 of file L1TdeRCT.h.

Referenced by beginJob(), and beginLuminosityBlock().

MonitorElement* L1TdeRCT::fedVectorMonitorRUN_

private

Definition at line 326 of file L1TdeRCT.h.

Referenced by beginJob(), and beginRun().

int L1TdeRCT::filterTriggerType_

private

filter TriggerType

Definition at line 349 of file L1TdeRCT.h.

Referenced by analyze().

edm::InputTag L1TdeRCT::gtDigisLabel_

private

Definition at line 344 of file L1TdeRCT.h.

Referenced by analyze().

std::string L1TdeRCT::gtEGAlgoName_

private

Definition at line 345 of file L1TdeRCT.h.

Referenced by analyze().

edm::InputTag L1TdeRCT::hcalTPGData_

private

Definition at line 343 of file L1TdeRCT.h.

Referenced by analyze().

std::string L1TdeRCT::histFolder_

private

Definition at line 334 of file L1TdeRCT.h.

Referenced by beginJob(), and L1TdeRCT().

ofstream L1TdeRCT::logFile_

private

Definition at line 338 of file L1TdeRCT.h.

bool L1TdeRCT::monitorDaemon_

private

Definition at line 337 of file L1TdeRCT.h.

int L1TdeRCT::nev_

private

Definition at line 332 of file L1TdeRCT.h.

Referenced by analyze(), beginJob(), and endJob().

int L1TdeRCT::notrigCount

private

Definition at line 352 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

std::string L1TdeRCT::outputFile_

private

Definition at line 333 of file L1TdeRCT.h.

Referenced by endJob(), and L1TdeRCT().

MonitorElement* L1TdeRCT::rctBitDataHfPlusTau2D_

private

Definition at line 223 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitDataMip2D_

private

Definition at line 206 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitDataOverFlow2D_

private

Definition at line 190 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitDataQuiet2D_

private

Definition at line 214 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitDataTauVeto2D_

private

Definition at line 198 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitEmulHfPlusTau2D_

private

Definition at line 222 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitEmulMip2D_

private

Definition at line 205 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitEmulOverFlow2D_

private

Definition at line 189 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitEmulQuiet2D_

private

Definition at line 213 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitEmulTauVeto2D_

private

Definition at line 197 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitHfPlusTauEff2D_

private

Definition at line 227 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitHfPlusTauIneff2D_

private

Definition at line 228 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitHfPlusTauOvereff2D_

private

Definition at line 229 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMatchedHfPlusTau2D_

private

Definition at line 224 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMatchedMip2D_

private

Definition at line 207 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMatchedOverFlow2D_

private

Definition at line 191 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMatchedQuiet2D_

private

Definition at line 215 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMatchedTauVeto2D_

private

Definition at line 199 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMipEff2D_

private

Definition at line 210 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMipIneff2D_

private

Definition at line 211 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitMipOvereff2D_

private

Definition at line 212 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitOverFlowEff2D_

private

Definition at line 194 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitOverFlowIneff2D_

private

Definition at line 195 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitOverFlowOvereff2D_

private

Definition at line 196 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitTauVetoEff2D_

private

Definition at line 202 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitTauVetoIneff2D_

private

Definition at line 203 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitTauVetoOvereff2D_

private

Definition at line 204 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedDataHfPlusTau2D_

private

Definition at line 226 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedDataMip2D_

private

Definition at line 209 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedDataOverFlow2D_

private

Definition at line 193 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedDataQuiet2D_

private

Definition at line 217 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedDataTauVeto2D_

private

Definition at line 201 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedEmulHfPlusTau2D_

private

Definition at line 225 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedEmulMip2D_

private

Definition at line 208 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedEmulOverFlow2D_

private

Definition at line 192 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedEmulQuiet2D_

private

Definition at line 216 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctBitUnmatchedEmulTauVeto2D_

private

Definition at line 200 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctInputTPGEcalOcc_

private

Definition at line 233 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctInputTPGEcalOccNoCut_

private

Definition at line 234 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctInputTPGEcalRank_

private

Definition at line 235 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctInputTPGHcalOcc_

private

Definition at line 236 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctInputTPGHcalRank_

private

Definition at line 237 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctInputTPGHcalSample_

private

Definition at line 238 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEffChannel_[396]

private

Definition at line 300 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmBitDiff_

private

Definition at line 268 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmBitOff_

private

Definition at line 267 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmBitOn_

private

Definition at line 266 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmDataOcc1D_

private

Definition at line 253 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmDataOcc_

private

Definition at line 240 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff1_

private

Definition at line 247 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff1Occ1D_

private

Definition at line 255 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff1Occ_

private

Definition at line 242 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff1oneD_

private

Definition at line 260 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff2_

private

Definition at line 248 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff2Occ1D_

private

Definition at line 256 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff2Occ_

private

Definition at line 243 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEff2oneD_

private

Definition at line 261 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEmulOcc1D_

private

Definition at line 254 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmEmulOcc_

private

Definition at line 241 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneff1D_

private

Definition at line 263 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneff2_

private

Definition at line 249 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneff2Occ1D_

private

Definition at line 257 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneff2Occ_

private

Definition at line 244 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneff2oneD_

private

Definition at line 262 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneff_

private

Definition at line 250 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneffOcc1D_

private

Definition at line 258 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmIneffOcc_

private

Definition at line 245 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmOvereff1D_

private

Definition at line 264 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmOvereff_

private

Definition at line 251 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmOvereffOcc1D_

private

Definition at line 259 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoEmOvereffOcc_

private

Definition at line 246 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoIneffChannel_[396]

private

Definition at line 301 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctIsoOvereffChannel_[396]

private

Definition at line 302 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEffChannel_[396]

private

Definition at line 304 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNIsoEmBitDiff_

private

Definition at line 298 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNIsoEmBitOff_

private

Definition at line 297 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNIsoEmBitOn_

private

Definition at line 296 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmDataOcc1D_

private

Definition at line 283 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmDataOcc_

private

Definition at line 270 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff1_

private

Definition at line 277 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff1Occ1D_

private

Definition at line 285 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff1Occ_

private

Definition at line 272 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff1oneD_

private

Definition at line 290 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff2_

private

Definition at line 278 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff2Occ1D_

private

Definition at line 286 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff2Occ_

private

Definition at line 273 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEff2oneD_

private

Definition at line 291 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEmulOcc1D_

private

Definition at line 284 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmEmulOcc_

private

Definition at line 271 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneff1D_

private

Definition at line 293 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneff2_

private

Definition at line 279 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneff2Occ1D_

private

Definition at line 287 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneff2Occ_

private

Definition at line 274 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneff2oneD_

private

Definition at line 292 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneff_

private

Definition at line 280 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneffOcc1D_

private

Definition at line 288 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmIneffOcc_

private

Definition at line 275 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmOvereff1D_

private

Definition at line 294 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmOvereff_

private

Definition at line 281 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmOvereffOcc1D_

private

Definition at line 289 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoEmOvereffOcc_

private

Definition at line 276 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoIneffChannel_[396]

private

Definition at line 305 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctNisoOvereffChannel_[396]

private

Definition at line 306 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegBitDiff_

private

Definition at line 184 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegBitOff_

private

Definition at line 183 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegBitOn_

private

Definition at line 182 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegDataOcc1D_

private

Definition at line 153 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegDataOcc2D_

private

Definition at line 167 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegEff1D_

private

Definition at line 161 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegEff2D_

private

Definition at line 176 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegEffChannel_[396]

private

Definition at line 309 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegEmulOcc1D_

private

Definition at line 154 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegEmulOcc2D_

private

Definition at line 168 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegIneff1D_

private

Definition at line 162 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegIneff2D_

private

Definition at line 177 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegIneffChannel_[396]

private

Definition at line 310 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegMatchedOcc1D_

private

Definition at line 155 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegMatchedOcc2D_

private

Definition at line 169 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegOvereff1D_

private

Definition at line 163 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegOvereff2D_

private

Definition at line 178 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegOvereffChannel_[396]

private

Definition at line 311 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpEff1D_

private

Definition at line 164 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpEff2D_

private

Definition at line 179 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpEffOcc1D_

private

Definition at line 158 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpEffOcc2D_

private

Definition at line 173 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpIneff1D_

private

Definition at line 165 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpIneff2D_

private

Definition at line 180 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpIneffOcc1D_

private

Definition at line 159 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegSpIneffOcc2D_

private

Definition at line 174 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegUnmatchedDataOcc1D_

private

Definition at line 156 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegUnmatchedDataOcc2D_

private

Definition at line 170 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegUnmatchedEmulOcc1D_

private

Definition at line 157 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::rctRegUnmatchedEmulOcc2D_

private

Definition at line 171 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

edm::InputTag L1TdeRCT::rctSourceData_

private

Definition at line 341 of file L1TdeRCT.h.

Referenced by analyze().

edm::InputTag L1TdeRCT::rctSourceEmul_

private

Definition at line 340 of file L1TdeRCT.h.

Referenced by analyze().

bool L1TdeRCT::singlechannelhistos_

private

Definition at line 336 of file L1TdeRCT.h.

Referenced by analyze(), beginJob(), and L1TdeRCT().

int L1TdeRCT::trigCount

private

Definition at line 352 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::trigEff_[396]

private

Definition at line 317 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::trigEffOcc_[396]

private

Definition at line 318 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::trigEffThresh_

private

Definition at line 314 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::trigEffThreshOcc_

private

Definition at line 315 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::trigEffTriggOcc_[396]

private

Definition at line 319 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::trigEffTriggThreshOcc_

private

Definition at line 316 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::triggerAlgoNumbers_

private

Definition at line 147 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

MonitorElement* L1TdeRCT::triggerType_

private

Definition at line 150 of file L1TdeRCT.h.

Referenced by analyze(), and beginJob().

bool L1TdeRCT::verbose_

private

Definition at line 335 of file L1TdeRCT.h.

Referenced by analyze(), endJob(), and L1TdeRCT().