l1t::L1TGlobalAnalyzer Class Reference

Inheritance diagram for l1t::L1TGlobalAnalyzer:

Public Member Functions
	L1TGlobalAnalyzer (const edm::ParameterSet &)
	~L1TGlobalAnalyzer ()
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)

Private Types
enum	ObjectType {   MU =0x1, EG =0x2, Tau =0x3, Jet =0x4,   Sum =0x5, DmxEG =0x6, DmxTau =0x7, DmxJet =0x8,   DmxSum =0x9, GtAlg =0xA, EmulGtAlg =0xB }

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override
virtual void	beginJob () override
virtual void	endJob () override

Private Attributes
TFileDirectory	algDir_
std::map< ObjectType, TFileDirectory >	dirs_
TFileDirectory	dmxVGtDir_
bool	doHistos_
bool	doText_
TFileDirectory	evtDispDir_
TH1F *	hAlgoBits_
TH2F *	hAlgoBitsEmulDxVsHw_
TH2F *	hAlgoBitsEmulGtVsHw_
std::map< ObjectType, TH1F * >	hbx_
TH2F *	hDmxVsGTEGEt_
TH2F *	hDmxVsGTEGEta_
TH2F *	hDmxVsGTEGPhi_
TH2F *	hDmxVsGTJetEt_
TH2F *	hDmxVsGTJetEta_
TH2F *	hDmxVsGTJetPhi_
TH2F *	hDmxVsGTSumEt_ETM_
TH2F *	hDmxVsGTSumEt_ETT_
TH2F *	hDmxVsGTSumEt_HTM_
TH2F *	hDmxVsGTSumEt_HTT_
TH2F *	hDmxVsGTSumPhi_ETM_
TH2F *	hDmxVsGTSumPhi_HTM_
TH2F *	hDmxVsGTTauEt_
TH2F *	hDmxVsGTTauEta_
TH2F *	hDmxVsGTTauPhi_
TH1F *	hEmulDxAlgoBits_
TH1F *	hEmulGtAlgoBits_
std::map< ObjectType, TH1F * >	het_
std::map< ObjectType, TH1F * >	heta_
std::map< ObjectType, TH2F * >	hetaphi_
std::map< ObjectType, TH1F * >	hphi_
edm::EDGetToken	m_dmxEGToken
edm::EDGetToken	m_dmxJetToken
edm::EDGetToken	m_dmxSumToken
edm::EDGetToken	m_dmxTauToken
bool	m_doDmxEGs
bool	m_doDmxJets
bool	m_doDmxSums
bool	m_doDmxTaus
bool	m_doEGs
bool	m_doEmulDxAlg
bool	m_doEmulGtAlg
bool	m_doGtAlg
bool	m_doJets
bool	m_doMUs
bool	m_doSums
bool	m_doTaus
edm::EDGetToken	m_egToken
edm::EDGetToken	m_emulDxAlgToken
edm::EDGetToken	m_emulGtAlgToken
edm::EDGetToken	m_gtAlgToken
edm::EDGetToken	m_jetToken
edm::EDGetToken	m_muToken
edm::EDGetToken	m_sumToken
edm::EDGetToken	m_tauToken
std::vector< ObjectType >	types_
std::vector< std::string >	typeStr_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 54 of file L1TGlobalAnalyzer.cc.

Member Enumeration Documentation

enum l1t::L1TGlobalAnalyzer::ObjectType

private

Enumerator
MU
EG
Tau
Jet
Sum
DmxEG
DmxTau
DmxJet
DmxSum
GtAlg
EmulGtAlg

Definition at line 105 of file L1TGlobalAnalyzer.cc.

                 {
                  MU=0x1,
          EG=0x2,
          Tau=0x3,
          Jet=0x4,
          Sum=0x5,
          DmxEG=0x6,
          DmxTau=0x7,
          DmxJet=0x8,
          DmxSum=0x9,
                  GtAlg=0xA,
                  EmulGtAlg=0xB
          };

Constructor & Destructor Documentation

L1TGlobalAnalyzer::L1TGlobalAnalyzer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 166 of file L1TGlobalAnalyzer.cc.

References DmxEG, DmxJet, DmxSum, DmxTau, EG, edm::ParameterSet::getParameter(), m_dmxEGToken, m_dmxJetToken, m_dmxSumToken, m_dmxTauToken, m_doDmxEGs, m_doDmxJets, m_doDmxSums, m_doDmxTaus, m_doEGs, m_doEmulDxAlg, m_doEmulGtAlg, m_doGtAlg, m_doJets, m_doMUs, m_doSums, m_doTaus, m_egToken, m_emulDxAlgToken, m_emulGtAlgToken, m_gtAlgToken, m_jetToken, m_muToken, m_sumToken, m_tauToken, MU, Sum, types_, and typeStr_.

                                                                     :
    doText_(iConfig.getUntrackedParameter<bool>("doText", true)),
    doHistos_(iConfig.getUntrackedParameter<bool>("doHistos", true))
{
   //now do what ever initialization is needed

  // register what you consume and keep token for later access:
  edm::InputTag nullTag("None");

  edm::InputTag dmxEGTag  = iConfig.getParameter<edm::InputTag>("dmxEGToken");
  m_dmxEGToken          = consumes<l1t::EGammaBxCollection>(dmxEGTag);
  m_doDmxEGs            = !(dmxEGTag==nullTag);

  edm::InputTag dmxTauTag = iConfig.getParameter<edm::InputTag>("dmxTauToken");
  m_dmxTauToken         = consumes<l1t::TauBxCollection>(dmxTauTag);
  m_doDmxTaus           = !(dmxTauTag==nullTag);

  edm::InputTag dmxJetTag = iConfig.getParameter<edm::InputTag>("dmxJetToken");
  m_dmxJetToken         = consumes<l1t::JetBxCollection>(dmxJetTag);
  m_doDmxJets           = !(dmxJetTag==nullTag);  

  edm::InputTag dmxSumTag = iConfig.getParameter<edm::InputTag>("dmxEtSumToken");
  m_dmxSumToken         = consumes<l1t::EtSumBxCollection>(dmxSumTag);
  m_doDmxSums           = !(dmxSumTag==nullTag);

  edm::InputTag muTag  = iConfig.getParameter<edm::InputTag>("muToken");
  m_muToken          = consumes<l1t::MuonBxCollection>(muTag);
  m_doMUs            = !(muTag==nullTag);

  edm::InputTag egTag  = iConfig.getParameter<edm::InputTag>("egToken");
  m_egToken          = consumes<l1t::EGammaBxCollection>(egTag);
  m_doEGs            = !(egTag==nullTag);

  edm::InputTag tauTag = iConfig.getParameter<edm::InputTag>("tauToken");
  m_tauToken         = consumes<l1t::TauBxCollection>(tauTag);
  m_doTaus           = !(tauTag==nullTag);

  edm::InputTag jetTag = iConfig.getParameter<edm::InputTag>("jetToken");
  m_jetToken         = consumes<l1t::JetBxCollection>(jetTag);
  m_doJets           = !(jetTag==nullTag);  

  edm::InputTag sumTag = iConfig.getParameter<edm::InputTag>("etSumToken");
  m_sumToken         = consumes<l1t::EtSumBxCollection>(sumTag);
  m_doSums           = !(sumTag==nullTag);

  edm::InputTag gtAlgTag = iConfig.getParameter<edm::InputTag>("gtAlgToken");
  m_gtAlgToken         = consumes<GlobalAlgBlkBxCollection>(gtAlgTag);
  m_doGtAlg            = !(gtAlgTag==nullTag); 

  edm::InputTag emulGtAlgTag = iConfig.getParameter<edm::InputTag>("emulGtAlgToken");
  m_emulGtAlgToken         = consumes<GlobalAlgBlkBxCollection>(emulGtAlgTag);
  m_doEmulGtAlg            = !(emulGtAlgTag==nullTag);

  edm::InputTag emulDxAlgTag = iConfig.getParameter<edm::InputTag>("emulDxAlgToken");
  m_emulDxAlgToken         = consumes<GlobalAlgBlkBxCollection>(emulDxAlgTag);
  m_doEmulDxAlg            = !(emulDxAlgTag==nullTag);

  types_.push_back( DmxEG );
  types_.push_back( DmxTau );
  types_.push_back( DmxJet );
  types_.push_back( DmxSum );
  types_.push_back( MU );
  types_.push_back( EG );
  types_.push_back( Tau );
  types_.push_back( Jet );
  types_.push_back( Sum );

  typeStr_.push_back( "dmxeg" );
  typeStr_.push_back( "dmxtau" );
  typeStr_.push_back( "dmxjet" );
  typeStr_.push_back( "dmxsum" );
  typeStr_.push_back( "mu" );
  typeStr_.push_back( "eg" );
  typeStr_.push_back( "tau" );
  typeStr_.push_back( "jet" );
  typeStr_.push_back( "sum" );

}

L1TGlobalAnalyzer::~L1TGlobalAnalyzer

(

)

Definition at line 246 of file L1TGlobalAnalyzer.cc.

{
 
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)

}

Member Function Documentation

void L1TGlobalAnalyzer::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 261 of file L1TGlobalAnalyzer.cc.

References DmxEG, DmxJet, DmxSum, DmxTau, doText_, EG, edm::Event::getByToken(), hAlgoBits_, hAlgoBitsEmulDxVsHw_, hAlgoBitsEmulGtVsHw_, hbx_, hDmxVsGTEGEt_, hDmxVsGTEGEta_, hDmxVsGTEGPhi_, hDmxVsGTJetEt_, hDmxVsGTJetEta_, hDmxVsGTJetPhi_, hDmxVsGTSumEt_ETM_, hDmxVsGTSumEt_ETT_, hDmxVsGTSumEt_HTM_, hDmxVsGTSumEt_HTT_, hDmxVsGTSumPhi_ETM_, hDmxVsGTSumPhi_HTM_, hDmxVsGTTauEt_, hDmxVsGTTauEta_, hDmxVsGTTauPhi_, hEmulDxAlgoBits_, hEmulGtAlgoBits_, het_, heta_, hetaphi_, hphi_, fwrapper::jets, L1Analysis::kMissingEt, L1Analysis::kMissingHt, L1Analysis::kTotalEt, L1Analysis::kTotalHt, m_dmxEGToken, m_dmxJetToken, m_dmxSumToken, m_dmxTauToken, m_doDmxEGs, m_doDmxJets, m_doDmxSums, m_doDmxTaus, m_doEGs, m_doEmulDxAlg, m_doEmulGtAlg, m_doGtAlg, m_doJets, m_doMUs, m_doSums, m_doTaus, m_egToken, m_emulDxAlgToken, m_emulGtAlgToken, m_gtAlgToken, m_jetToken, m_muToken, m_sumToken, m_tauToken, MU, patZpeak::muons, Sum, and runonSM::text.

{
  using namespace edm;

  std::stringstream text;


  // get EG
  if (m_doDmxEGs) {
    Handle< BXVector<l1t::EGamma> > dmxegs;
    iEvent.getByToken(m_dmxEGToken,dmxegs);
    
    for ( int ibx=dmxegs->getFirstBX(); ibx<=dmxegs->getLastBX(); ++ibx) {

      for ( auto itr = dmxegs->begin(ibx); itr != dmxegs->end(ibx); ++itr ) {
        hbx_.at(DmxEG)->Fill( ibx );
    het_.at(DmxEG)->Fill( itr->hwPt() );
    heta_.at(DmxEG)->Fill( itr->hwEta() );
    hphi_.at(DmxEG)->Fill( itr->hwPhi() );
        hetaphi_.at(DmxEG)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Dmx EG : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;      



      }
      
    }

  }

  // get tau
  if (m_doDmxTaus) {
    Handle< BXVector<l1t::Tau> > dmxtaus;
    iEvent.getByToken(m_dmxTauToken,dmxtaus);
    
    for ( int ibx=dmxtaus->getFirstBX(); ibx<=dmxtaus->getLastBX(); ++ibx) {

      for ( auto itr = dmxtaus->begin(ibx); itr != dmxtaus->end(ibx); ++itr ) {
        hbx_.at(DmxTau)->Fill( ibx );
    het_.at(DmxTau)->Fill( itr->hwPt() );
    heta_.at(DmxTau)->Fill( itr->hwEta() );
    hphi_.at(DmxTau)->Fill( itr->hwPhi() );
        hetaphi_.at(DmxTau)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Dmx Tau : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;      

      }
      
    }
    
  }

  // get jet
  if (m_doDmxJets) {
    Handle< BXVector<l1t::Jet> > dmxjets;
    iEvent.getByToken(m_dmxJetToken,dmxjets);
    
    for ( int ibx=dmxjets->getFirstBX(); ibx<=dmxjets->getLastBX(); ++ibx) {

      for ( auto itr = dmxjets->begin(ibx); itr != dmxjets->end(ibx); ++itr ) {
        hbx_.at(DmxJet)->Fill( ibx );
    het_.at(DmxJet)->Fill( itr->hwPt() );
    heta_.at(DmxJet)->Fill( itr->hwEta() );
    hphi_.at(DmxJet)->Fill( itr->hwPhi() );
        hetaphi_.at(DmxJet)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Dmx Jet : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;

      }
      
    }

  }

  // get sums
  if (m_doDmxSums) {
    Handle< BXVector<l1t::EtSum> > dmxsums;
    iEvent.getByToken(m_dmxSumToken,dmxsums);
    
    for ( int ibx=dmxsums->getFirstBX(); ibx<=dmxsums->getLastBX(); ++ibx) {

      for ( auto itr = dmxsums->begin(ibx); itr != dmxsums->end(ibx); ++itr ) {
    hbx_.at(DmxSum)->Fill( ibx );
    het_.at(DmxSum)->Fill( itr->hwPt() );
    heta_.at(DmxSum)->Fill( itr->hwEta() );
    hphi_.at(DmxSum)->Fill( itr->hwPhi() );
        hetaphi_.at(DmxSum)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Dmx Sum : " << " type=" << itr->getType() << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;

      }

    }

  }


  // get Muons
  if (m_doMUs) {
    Handle< BXVector<l1t::Muon> > muons;
    iEvent.getByToken(m_muToken,muons);
    
    for ( int ibx=muons->getFirstBX(); ibx<=muons->getLastBX(); ++ibx) {

      for ( auto itr = muons->begin(ibx); itr != muons->end(ibx); ++itr ) {
        hbx_.at(MU)->Fill( ibx );
    het_.at(MU)->Fill( itr->hwPt() );
    heta_.at(MU)->Fill( itr->hwEta() );
    hphi_.at(MU)->Fill( itr->hwPhi() );
        hetaphi_.at(MU)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Muon : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;

      }
      
    }

  }



  // get EG
  if (m_doEGs) {
    Handle< BXVector<l1t::EGamma> > egs;
    iEvent.getByToken(m_egToken,egs);
    
    for ( int ibx=egs->getFirstBX(); ibx<=egs->getLastBX(); ++ibx) {

      for ( auto itr = egs->begin(ibx); itr != egs->end(ibx); ++itr ) {
        hbx_.at(EG)->Fill( ibx );
    het_.at(EG)->Fill( itr->hwPt() );
    heta_.at(EG)->Fill( itr->hwEta() );
    hphi_.at(EG)->Fill( itr->hwPhi() );
        hetaphi_.at(EG)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "EG : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;

      }
      
    }

  }

  // get tau
  if (m_doTaus) {
    Handle< BXVector<l1t::Tau> > taus;
    iEvent.getByToken(m_tauToken,taus);
    
    for ( int ibx=taus->getFirstBX(); ibx<=taus->getLastBX(); ++ibx) {

      for ( auto itr = taus->begin(ibx); itr != taus->end(ibx); ++itr ) {
        hbx_.at(Tau)->Fill( ibx );
    het_.at(Tau)->Fill( itr->hwPt() );
    heta_.at(Tau)->Fill( itr->hwEta() );
    hphi_.at(Tau)->Fill( itr->hwPhi() );
        hetaphi_.at(Tau)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Tau : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;

      }
      
    }
    
  }

  // get jet
  if (m_doJets) {
    Handle< BXVector<l1t::Jet> > jets;
    iEvent.getByToken(m_jetToken,jets);
    
    for ( int ibx=jets->getFirstBX(); ibx<=jets->getLastBX(); ++ibx) {

      for ( auto itr = jets->begin(ibx); itr != jets->end(ibx); ++itr ) {
        hbx_.at(Jet)->Fill( ibx );
    het_.at(Jet)->Fill( itr->hwPt() );
    heta_.at(Jet)->Fill( itr->hwEta() );
    hphi_.at(Jet)->Fill( itr->hwPhi() );
        hetaphi_.at(Jet)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );

    text << "Jet : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;

      }
      
    }

  }

  // get sums
  if (m_doSums) {
    Handle< BXVector<l1t::EtSum> > sums;
    iEvent.getByToken(m_sumToken,sums);
    
    for ( int ibx=sums->getFirstBX(); ibx<=sums->getLastBX(); ++ibx) {

      for ( auto itr = sums->begin(ibx); itr != sums->end(ibx); ++itr ) {

    hbx_.at(Sum)->Fill( ibx );
    het_.at(Sum)->Fill( itr->hwPt() );
    heta_.at(Sum)->Fill( itr->hwEta() );
    hphi_.at(Sum)->Fill( itr->hwPhi() );
        hetaphi_.at(Sum)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
    text << "Sum : " << " type=" << itr->getType() << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
      }

    }

  }
  
  //Algorithm Bits
  if (m_doGtAlg) {
    Handle< BXVector<GlobalAlgBlk> > algs;
    iEvent.getByToken(m_gtAlgToken,algs);
    
    for ( int ibx=algs->getFirstBX(); ibx<=algs->getLastBX(); ++ibx) {

      for ( auto itr = algs->begin(ibx); itr != algs->end(ibx); ++itr ) {
           
    for(int algBit=0; algBit<128; algBit++) {  //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
      if(itr->getAlgoDecisionFinal(algBit)) {
        hAlgoBits_->Fill(algBit);
        text << "HW Fired Alg Bit : " << algBit  << std::endl;
      }  
        }
      }

    }

  }

  //Algorithm Bits (Emulation seeded by GT input)
  if (m_doEmulGtAlg) {
    Handle< BXVector<GlobalAlgBlk> > emulGtAlgs;
    iEvent.getByToken(m_emulGtAlgToken,emulGtAlgs);
    
    for ( int ibx=emulGtAlgs->getFirstBX(); ibx<=emulGtAlgs->getLastBX(); ++ibx) {

      for ( auto itr = emulGtAlgs->begin(ibx); itr != emulGtAlgs->end(ibx); ++itr ) {
           
    for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
      if(itr->getAlgoDecisionFinal(algBit)) {
         hEmulGtAlgoBits_->Fill(algBit);
         text << "Emul w/ GTInput Fired Alg Bit : " << algBit  << std::endl;
      }  
        }
      }

    }

  }

  //Algorithm Bits (Emulation seeded by Demux Output)
  if (m_doEmulDxAlg) {
    Handle< BXVector<GlobalAlgBlk> > emulDxAlgs;
    iEvent.getByToken(m_emulDxAlgToken,emulDxAlgs);
    
    for ( int ibx=emulDxAlgs->getFirstBX(); ibx<=emulDxAlgs->getLastBX(); ++ibx) {

      for ( auto itr = emulDxAlgs->begin(ibx); itr != emulDxAlgs->end(ibx); ++itr ) {
           
    for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
      if(itr->getAlgoDecisionFinal(algBit)) {
          hEmulDxAlgoBits_->Fill(algBit);
          text << "Emul w/ Demux output Fired Alg Bit : " << algBit  << std::endl;
          }
    }
      }

    }

  }


  // EG (Dmx vs GT)
  if (m_doEGs & m_doDmxEGs) {
    Handle< BXVector<l1t::EGamma> > egs;
    iEvent.getByToken(m_egToken,egs);

    Handle< BXVector<l1t::EGamma> > dmxegs;
    iEvent.getByToken(m_dmxEGToken,dmxegs);
    
    for ( int ibx=egs->getFirstBX(); ibx<=egs->getLastBX(); ++ibx) {

      // Cycle through all GT egs
      for (unsigned int igtEG=0; igtEG<egs->size(ibx); igtEG++) {
 
    double gtEGEt = egs->at(ibx,igtEG).hwPt();
        double dmxEGEt = 0.0;
        if(dmxegs->size(ibx)>igtEG) dmxEGEt = dmxegs->at(ibx,igtEG).hwPt();
        hDmxVsGTEGEt_->Fill(gtEGEt,dmxEGEt);        

    double gtEGEta = egs->at(ibx,igtEG).hwEta();
        double dmxEGEta = 0.0;
        if(dmxegs->size(ibx)>igtEG) dmxEGEta = dmxegs->at(ibx,igtEG).hwEta();
        hDmxVsGTEGEta_->Fill(gtEGEta,dmxEGEta);        

    double gtEGPhi = egs->at(ibx,igtEG).hwPhi();
        double dmxEGPhi = 0.0;
        if(dmxegs->size(ibx)>igtEG) dmxEGPhi = dmxegs->at(ibx,igtEG).hwPhi();
        hDmxVsGTEGPhi_->Fill(gtEGPhi,dmxEGPhi);        



      }
      // if there are extra egs in the dmx record them
      for (unsigned int idmEG=egs->size(ibx); idmEG<dmxegs->size(ibx); idmEG++) {

        
    double gtEGEt = 0.0; //no GT jet exists
        double dmxEGEt = dmxegs->at(ibx,idmEG).hwPt();
        hDmxVsGTEGEt_->Fill(gtEGEt,dmxEGEt);        

    double gtEGEta = 0.0;
        double dmxEGEta = dmxegs->at(ibx,idmEG).hwEta();
        hDmxVsGTEGEta_->Fill(gtEGEta,dmxEGEta);        

    double gtEGPhi = 0.0;
        double dmxEGPhi  = dmxegs->at(ibx,idmEG).hwPhi();
        hDmxVsGTEGPhi_->Fill(gtEGPhi,dmxEGPhi);        
         
      }      
       
    }

  }


  // Tau (Dmx vs GT)
  if (m_doTaus & m_doDmxTaus) {
    Handle< BXVector<l1t::Tau> > taus;
    iEvent.getByToken(m_tauToken,taus);

    Handle< BXVector<l1t::Tau> > dmxtaus;
    iEvent.getByToken(m_dmxTauToken,dmxtaus);
    
    for ( int ibx=taus->getFirstBX(); ibx<=taus->getLastBX(); ++ibx) {

      // Cycle through all GT taus
      for (unsigned int igtTau=0; igtTau<taus->size(ibx); igtTau++) {
 
    double gtTauEt = taus->at(ibx,igtTau).hwPt();
        double dmxTauEt = 0.0;
        if(dmxtaus->size(ibx)>igtTau) dmxTauEt = dmxtaus->at(ibx,igtTau).hwPt();
        hDmxVsGTTauEt_->Fill(gtTauEt,dmxTauEt);        

    double gtTauEta = taus->at(ibx,igtTau).hwEta();
        double dmxTauEta = 0.0;
        if(dmxtaus->size(ibx)>igtTau) dmxTauEta = dmxtaus->at(ibx,igtTau).hwEta();
        hDmxVsGTTauEta_->Fill(gtTauEta,dmxTauEta);        

    double gtTauPhi = taus->at(ibx,igtTau).hwPhi();
        double dmxTauPhi = 0.0;
        if(dmxtaus->size(ibx)>igtTau) dmxTauPhi = dmxtaus->at(ibx,igtTau).hwPhi();
        hDmxVsGTTauPhi_->Fill(gtTauPhi,dmxTauPhi);        



      }
      // if there are extra taus in the dmx record them
      for (unsigned int idmTau=taus->size(ibx); idmTau<dmxtaus->size(ibx); idmTau++) {

        
    double gtTauEt = 0.0; //no GT jet exists
        double dmxTauEt = dmxtaus->at(ibx,idmTau).hwPt();
        hDmxVsGTTauEt_->Fill(gtTauEt,dmxTauEt);        

    double gtTauEta = 0.0;
        double dmxTauEta = dmxtaus->at(ibx,idmTau).hwEta();
        hDmxVsGTTauEta_->Fill(gtTauEta,dmxTauEta);        

    double gtTauPhi = 0.0;
        double dmxTauPhi  = dmxtaus->at(ibx,idmTau).hwPhi();
        hDmxVsGTTauPhi_->Fill(gtTauPhi,dmxTauPhi);        
         
      }      
       
    }

  }


  
  // Jets (Dmx vs GT)
  if (m_doJets & m_doDmxJets) {
    Handle< BXVector<l1t::Jet> > jets;
    iEvent.getByToken(m_jetToken,jets);

    Handle< BXVector<l1t::Jet> > dmxjets;
    iEvent.getByToken(m_dmxJetToken,dmxjets);
    
    for ( int ibx=jets->getFirstBX(); ibx<=jets->getLastBX(); ++ibx) {

      // Cycle through all GT jets
      for (unsigned int igtJ=0; igtJ<jets->size(ibx); igtJ++) {
 
    double gtJetEt = jets->at(ibx,igtJ).hwPt();
        double dmxJetEt = 0.0;
        if(dmxjets->size(ibx)>igtJ) dmxJetEt = dmxjets->at(ibx,igtJ).hwPt();
        hDmxVsGTJetEt_->Fill(gtJetEt,dmxJetEt);        

    double gtJetEta = jets->at(ibx,igtJ).hwEta();
        double dmxJetEta = 0.0;
        if(dmxjets->size(ibx)>igtJ) dmxJetEta = dmxjets->at(ibx,igtJ).hwEta();
        hDmxVsGTJetEta_->Fill(gtJetEta,dmxJetEta);        

    double gtJetPhi = jets->at(ibx,igtJ).hwPhi();
        double dmxJetPhi = 0.0;
        if(dmxjets->size(ibx)>igtJ) dmxJetPhi = dmxjets->at(ibx,igtJ).hwPhi();
        hDmxVsGTJetPhi_->Fill(gtJetPhi,dmxJetPhi);        



      }
      // if there are extra jets in the dmx record them
      for (unsigned int idmJ=jets->size(ibx); idmJ<dmxjets->size(ibx); idmJ++) {

        
    double gtJetEt = 0.0; //no GT jet exists
        double dmxJetEt = dmxjets->at(ibx,idmJ).hwPt();
        hDmxVsGTJetEt_->Fill(gtJetEt,dmxJetEt);        

    double gtJetEta = 0.0;
        double dmxJetEta = dmxjets->at(ibx,idmJ).hwEta();
        hDmxVsGTJetEta_->Fill(gtJetEta,dmxJetEta);        

    double gtJetPhi = 0.0;
        double dmxJetPhi  = dmxjets->at(ibx,idmJ).hwPhi();
        hDmxVsGTJetPhi_->Fill(gtJetPhi,dmxJetPhi);        
         
      }      
       
    }

  }

  // Sums (Dmx vs GT)
  if (m_doSums & m_doDmxSums) {
    Handle< BXVector<l1t::EtSum> > sums;
    iEvent.getByToken(m_sumToken,sums);

    Handle< BXVector<l1t::EtSum> > dmxSums;
    iEvent.getByToken(m_dmxSumToken,dmxSums);
    
    for ( int ibx=sums->getFirstBX(); ibx<=sums->getLastBX(); ++ibx) {

      // Cycle through all GT sums
      for (unsigned int igtS=0; igtS<sums->size(ibx); igtS++) {
 
    double gtSumEt = sums->at(ibx,igtS).hwPt();
        double dmxSumEt = 0.0;
        if(dmxSums->size(ibx)>igtS) dmxSumEt = dmxSums->at(ibx,igtS).hwPt();

    double gtSumPhi = sums->at(ibx,igtS).hwPhi();
        double dmxSumPhi = 0.0;
        if(dmxSums->size(ibx)>igtS) dmxSumPhi = dmxSums->at(ibx,igtS).hwPhi();

        if(sums->at(ibx,igtS).getType() == dmxSums->at(ibx,igtS).getType()) {
          switch(sums->at(ibx,igtS).getType()) {
      case l1t::EtSum::EtSumType::kTotalEt:
          hDmxVsGTSumEt_ETT_->Fill(gtSumEt,dmxSumEt);

              break;  
      case l1t::EtSum::EtSumType::kTotalHt:
          hDmxVsGTSumEt_HTT_->Fill(gtSumEt,dmxSumEt);

              break;  
      case l1t::EtSum::EtSumType::kMissingEt:
          hDmxVsGTSumEt_ETM_->Fill(gtSumEt,dmxSumEt);
              hDmxVsGTSumPhi_ETM_->Fill(gtSumPhi,dmxSumPhi);
              break;  
      case l1t::EtSum::EtSumType::kMissingHt:
          hDmxVsGTSumEt_HTM_->Fill(gtSumEt,dmxSumEt);
              hDmxVsGTSumPhi_HTM_->Fill(gtSumPhi,dmxSumPhi);
              break;
          default:
          break;  
          }                 
        } else {
          text << "WARNING:  EtSum Types do not line up between DeMux and uGT " << std::endl;
        }
      }
      // if there are extra sumss in the dmx record them...should not be any...but let's check
      for (unsigned int idmS=sums->size(ibx); idmS<dmxSums->size(ibx); idmS++) {

        
    double gtSumEt = 0.0; //no GT jet exists
        double dmxSumEt = dmxSums->at(ibx,idmS).hwPt();        

    double gtSumPhi = 0.0;
        double dmxSumPhi  = dmxSums->at(ibx,idmS).hwPhi();

          switch(dmxSums->at(ibx,idmS).getType()) {
      case l1t::EtSum::EtSumType::kTotalEt:
          hDmxVsGTSumEt_ETT_->Fill(gtSumEt,dmxSumEt);

              break;  
      case l1t::EtSum::EtSumType::kTotalHt:
          hDmxVsGTSumEt_HTT_->Fill(gtSumEt,dmxSumEt);

              break;  
      case l1t::EtSum::EtSumType::kMissingEt:
          hDmxVsGTSumEt_ETM_->Fill(gtSumEt,dmxSumEt);
              hDmxVsGTSumPhi_ETM_->Fill(gtSumPhi,dmxSumPhi);
              break;  
      case l1t::EtSum::EtSumType::kMissingHt:
          hDmxVsGTSumEt_HTM_->Fill(gtSumEt,dmxSumEt);
              hDmxVsGTSumPhi_HTM_->Fill(gtSumPhi,dmxSumPhi);
              break;  
          default:
          break;
          }                 
         
      }      
       
    }

  }
  
  
  //Algorithm Bits (Emulation vs HW)
  if (m_doGtAlg && m_doEmulGtAlg) {
    Handle< BXVector<GlobalAlgBlk> > hwalgs;
    iEvent.getByToken(m_gtAlgToken,hwalgs);

    Handle< BXVector<GlobalAlgBlk> > emulAlgs;
    iEvent.getByToken(m_emulGtAlgToken,emulAlgs);

       
    //for ( int ibx=hwalgs->getFirstBX(); ibx<=hwalgs->getLastBX(); ++ibx) {
    int ibx=0;

        auto itr = hwalgs->begin(ibx);
        auto itr_emul = emulAlgs->begin(ibx);        
   
    for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
          bool hw = itr->getAlgoDecisionFinal(algBit);
          bool em = itr_emul->getAlgoDecisionFinal(algBit);
      if(hw & em) {
        hAlgoBitsEmulGtVsHw_->Fill(algBit,algBit);
      }else if(hw & !em) {
            hAlgoBitsEmulGtVsHw_->Fill(algBit,-1.0);
        text << "WARNING:  HW Fnd Alg Bit " << algBit << " but emulation did not " << std::endl;
      }else if(!hw & em) {
            hAlgoBitsEmulGtVsHw_->Fill(-1.0,algBit);
        text << "WARNING:  Emul. Fnd Alg Bit " << algBit << " but hardware did not " << std::endl;
      }
        }
      
  // }

  }

  //Algorithm Bits (Emulation vs HW)
  if (m_doGtAlg && m_doEmulDxAlg) {
    Handle< BXVector<GlobalAlgBlk> > hwalgs;
    iEvent.getByToken(m_gtAlgToken,hwalgs);

    Handle< BXVector<GlobalAlgBlk> > emulAlgs;
    iEvent.getByToken(m_emulDxAlgToken,emulAlgs);

       
    //for ( int ibx=hwalgs->getFirstBX(); ibx<=hwalgs->getLastBX(); ++ibx) {
    int ibx=0;

        auto itr = hwalgs->begin(ibx);
        auto itr_emul = emulAlgs->begin(ibx);        
   
    for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
          bool hw = itr->getAlgoDecisionFinal(algBit);
          bool em = itr_emul->getAlgoDecisionFinal(algBit);
      if(hw & em) {
        hAlgoBitsEmulDxVsHw_->Fill(algBit,algBit);
      }else if(hw & !em) {
            hAlgoBitsEmulDxVsHw_->Fill(algBit,-1.0);
      }else if(!hw & em) {
            hAlgoBitsEmulDxVsHw_->Fill(-1.0,algBit);
      }
        }
      
  // }

  }  

  


  if (doText_) edm::LogInfo("L1TGlobalEvents") << text.str();

}

void L1TGlobalAnalyzer::beginJob ( void  )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 855 of file L1TGlobalAnalyzer.cc.

References algDir_, dirs_, DmxEG, DmxJet, DmxSum, DmxTau, dmxVGtDir_, EG, hAlgoBits_, hAlgoBitsEmulDxVsHw_, hAlgoBitsEmulGtVsHw_, hbx_, hDmxVsGTEGEt_, hDmxVsGTEGEta_, hDmxVsGTEGPhi_, hDmxVsGTJetEt_, hDmxVsGTJetEta_, hDmxVsGTJetPhi_, hDmxVsGTSumEt_ETM_, hDmxVsGTSumEt_ETT_, hDmxVsGTSumEt_HTM_, hDmxVsGTSumEt_HTT_, hDmxVsGTSumPhi_ETM_, hDmxVsGTSumPhi_HTM_, hDmxVsGTTauEt_, hDmxVsGTTauEta_, hDmxVsGTTauPhi_, hEmulDxAlgoBits_, hEmulGtAlgoBits_, het_, heta_, hetaphi_, hphi_, TFileDirectory::make(), TFileService::mkdir(), MU, Sum, types_, and typeStr_.

{

  edm::Service<TFileService> fs;

  auto itr = types_.cbegin();
  auto str = typeStr_.cbegin();

  for (; itr!=types_.end(); ++itr, ++str ) {
    
    if (*itr==Jet || *itr==DmxJet || *itr==Sum || *itr==DmxSum || *itr==DmxEG || *itr==EG || *itr==DmxTau || *itr==Tau) {
       double etmax=99.5;
       if (*itr==Jet || *itr==DmxJet || *itr==Sum || *itr==DmxSum) etmax=499.5;

       dirs_.insert( std::pair< ObjectType, TFileDirectory >(*itr, fs->mkdir(*str) ) );

       het_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("et", "", 500, -0.5, etmax) ));

       hbx_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("bx", "", 11, -5.5, 5.5) ));


       heta_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("eta", "", 229, -114.5, 114.5) ));
       hphi_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("phi", "", 144, -0.5, 143.5) ));
       hetaphi_.insert( std::pair< ObjectType, TH2F* >(*itr, dirs_.at(*itr).make<TH2F>("etaphi", "", 229, -114.5, 114.5, 144, -0.5, 143.5) ));
    } else if( *itr==MU) {
       double etmax = 511.5;
       dirs_.insert( std::pair< ObjectType, TFileDirectory >(*itr, fs->mkdir(*str) ) );

       het_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("et", "", 512, -0.5, etmax) ));

       hbx_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("bx", "", 11, -5.5, 5.5) ));


       heta_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("eta", "", 549, -224.5, 224.5) ));
       hphi_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("phi", "", 576, -0.5, 575.5) ));
       hetaphi_.insert( std::pair< ObjectType, TH2F* >(*itr, dirs_.at(*itr).make<TH2F>("etaphi", "", 549, -224.5, 224.5, 576, -0.5, 575.5) ));

    }



  }

  algDir_ = fs->mkdir("Algorithms");
  hAlgoBits_ = algDir_.make<TH1F>("hAlgoBits","Algorithm Bits",100, -0.5,99.5);
  hEmulGtAlgoBits_ = algDir_.make<TH1F>("hEmulGtAlgoBits","GT Emulated Algorithm Bits",100, -0.5,99.5);
  hAlgoBitsEmulGtVsHw_ = algDir_.make<TH2F>("hAlgoBitsEmulGtVsHw","Algorithm Bits (GT) Emulation vs Hardware",129, -1.5,127.5,129,-1.5,127.5);
  hEmulDxAlgoBits_ = algDir_.make<TH1F>("hEmulDxAlgoBits","Dx Emulated Algorithm Bits",100, -0.5,99.5);
  hAlgoBitsEmulDxVsHw_ = algDir_.make<TH2F>("hAlgoBitsEmulDxVsHw","Algorithm Bits (Dx) Emulation vs Hardware",129, -1.5,127.5,129,-1.5,127.5);
 
  dmxVGtDir_ = fs->mkdir("DmxVsGT");
  hDmxVsGTEGEt_  = dmxVGtDir_.make<TH2F>("hDmxVsGTEGEt","Dmx EG Et versus GT EG Et",   500,-0.5,499.5,500,-0.5,499.5);
  hDmxVsGTEGEta_ = dmxVGtDir_.make<TH2F>("hDmxVsGTEGEta","Dmx EG Eta versus GT EG Eta",229,-114.5,114.5,229,-114.5,114.5);
  hDmxVsGTEGPhi_ = dmxVGtDir_.make<TH2F>("hDmxVsGTEGPhi","Dmx EG Phi versus GT EG Phi",144,-0.5,143.5,144,-0.5,143.5);

  hDmxVsGTTauEt_  = dmxVGtDir_.make<TH2F>("hDmxVsGTTauEt","Dmx Tau Et versus GT Tau Et",   500,-0.5,499.5,500,-0.5,499.5);
  hDmxVsGTTauEta_ = dmxVGtDir_.make<TH2F>("hDmxVsGTTauEta","Dmx Tau Eta versus GT Tau Eta",229,-114.5,114.5,229,-114.5,114.5);
  hDmxVsGTTauPhi_ = dmxVGtDir_.make<TH2F>("hDmxVsGTTauPhi","Dmx Tau Phi versus GT Tau Phi",144,-0.5,143.5,144,-0.5,143.5);
 
  hDmxVsGTJetEt_  = dmxVGtDir_.make<TH2F>("hDmxVsGTJetEt","Dmx Jet Et versus GT Jet Et",   500,-0.5,499.5,500,-0.5,499.5);
  hDmxVsGTJetEta_ = dmxVGtDir_.make<TH2F>("hDmxVsGTJetEta","Dmx Jet Eta versus GT Jet Eta",229,-114.5,114.5,229,-114.5,114.5);
  hDmxVsGTJetPhi_ = dmxVGtDir_.make<TH2F>("hDmxVsGTJetPhi","Dmx Jet Phi versus GT Jet Phi",144,-0.5,143.5,144,-0.5,143.5);
 
  hDmxVsGTSumEt_ETT_  = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETT","Dmx ETT versus GT ETT",256,-0.5,2047.5,256,-0.5,2047.5);
  hDmxVsGTSumEt_HTT_  = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HTT","Dmx HTT versus GT HTT",256,-0.5,2047.5,256,-0.5,2047.5);
  hDmxVsGTSumEt_ETM_  = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETM","Dmx ETM versus GT ETM",500,-0.5,499.5,500,-0.5,499.5);
  hDmxVsGTSumPhi_ETM_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumPhi_ETM","Dmx ETM Phi versus GT ETM Phi",144,-0.5,143.5,144,-0.5,143.5);
  hDmxVsGTSumEt_HTM_  = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HTM","Dmx HTM versus GT HTM",500,-0.5,499.5,500,-0.5,499.5);
  hDmxVsGTSumPhi_HTM_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumPhi_HTM","Dmx HTM Phi versus GT HTM Phi",144,-0.5,143.5,144,-0.5,143.5);



}

void L1TGlobalAnalyzer::endJob ( void  )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 931 of file L1TGlobalAnalyzer.cc.

{
}

void L1TGlobalAnalyzer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 969 of file L1TGlobalAnalyzer.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                              {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

Member Data Documentation

TFileDirectory l1t::L1TGlobalAnalyzer::algDir_

private

Definition at line 130 of file L1TGlobalAnalyzer.cc.

Referenced by beginJob().

std::map< ObjectType, TFileDirectory > l1t::L1TGlobalAnalyzer::dirs_

private

Definition at line 122 of file L1TGlobalAnalyzer.cc.

Referenced by beginJob().

TFileDirectory l1t::L1TGlobalAnalyzer::dmxVGtDir_

private

Definition at line 131 of file L1TGlobalAnalyzer.cc.

Referenced by beginJob().

bool l1t::L1TGlobalAnalyzer::doHistos_

private

Definition at line 103 of file L1TGlobalAnalyzer.cc.

bool l1t::L1TGlobalAnalyzer::doText_

private

Definition at line 102 of file L1TGlobalAnalyzer.cc.

Referenced by analyze().

TFileDirectory l1t::L1TGlobalAnalyzer::evtDispDir_

private

Definition at line 129 of file L1TGlobalAnalyzer.cc.

TH1F* l1t::L1TGlobalAnalyzer::hAlgoBits_

private

Definition at line 132 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hAlgoBitsEmulDxVsHw_

private

Definition at line 136 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hAlgoBitsEmulGtVsHw_

private

Definition at line 135 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

std::map< ObjectType, TH1F* > l1t::L1TGlobalAnalyzer::hbx_

private

Definition at line 126 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTEGEt_

private

Definition at line 137 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTEGEta_

private

Definition at line 138 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTEGPhi_

private

Definition at line 139 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTJetEt_

private

Definition at line 143 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTJetEta_

private

Definition at line 144 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTJetPhi_

private

Definition at line 145 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTSumEt_ETM_

private

Definition at line 148 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTSumEt_ETT_

private

Definition at line 146 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTSumEt_HTM_

private

Definition at line 150 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTSumEt_HTT_

private

Definition at line 147 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTSumPhi_ETM_

private

Definition at line 149 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTSumPhi_HTM_

private

Definition at line 151 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTTauEt_

private

Definition at line 140 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTTauEta_

private

Definition at line 141 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH2F* l1t::L1TGlobalAnalyzer::hDmxVsGTTauPhi_

private

Definition at line 142 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH1F* l1t::L1TGlobalAnalyzer::hEmulDxAlgoBits_

private

Definition at line 134 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

TH1F* l1t::L1TGlobalAnalyzer::hEmulGtAlgoBits_

private

Definition at line 133 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

std::map< ObjectType, TH1F* > l1t::L1TGlobalAnalyzer::het_

private

Definition at line 123 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

std::map< ObjectType, TH1F* > l1t::L1TGlobalAnalyzer::heta_

private

Definition at line 124 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

std::map< ObjectType, TH2F* > l1t::L1TGlobalAnalyzer::hetaphi_

private

Definition at line 127 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

std::map< ObjectType, TH1F* > l1t::L1TGlobalAnalyzer::hphi_

private

Definition at line 125 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and beginJob().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_dmxEGToken

private

Definition at line 73 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_dmxJetToken

private

Definition at line 75 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_dmxSumToken

private

Definition at line 76 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_dmxTauToken

private

Definition at line 74 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doDmxEGs

private

Definition at line 88 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doDmxJets

private

Definition at line 90 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doDmxSums

private

Definition at line 91 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doDmxTaus

private

Definition at line 89 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doEGs

private

Definition at line 93 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doEmulDxAlg

private

Definition at line 100 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doEmulGtAlg

private

Definition at line 99 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doGtAlg

private

Definition at line 98 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doJets

private

Definition at line 95 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doMUs

private

Definition at line 92 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doSums

private

Definition at line 96 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

bool l1t::L1TGlobalAnalyzer::m_doTaus

private

Definition at line 94 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_egToken

private

Definition at line 78 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_emulDxAlgToken

private

Definition at line 85 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_emulGtAlgToken

private

Definition at line 84 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_gtAlgToken

private

Definition at line 83 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_jetToken

private

Definition at line 80 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_muToken

private

Definition at line 77 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_sumToken

private

Definition at line 81 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

edm::EDGetToken l1t::L1TGlobalAnalyzer::m_tauToken

private

Definition at line 79 of file L1TGlobalAnalyzer.cc.

Referenced by analyze(), and L1TGlobalAnalyzer().

std::vector< ObjectType > l1t::L1TGlobalAnalyzer::types_

private

Definition at line 119 of file L1TGlobalAnalyzer.cc.

Referenced by beginJob(), and L1TGlobalAnalyzer().

std::vector< std::string > l1t::L1TGlobalAnalyzer::typeStr_

private

Definition at line 120 of file L1TGlobalAnalyzer.cc.

Referenced by beginJob(), and L1TGlobalAnalyzer().