text: /*
   * \file L1TCompare.cc
   * \author P. Wittich
   * \brief Compare different parts of the trigger chain (e.g., RCT-GCT )
   *
   *
   * organized message logger
   *
   * Revision 1.12  2008/03/14 20:35:46  berryhil
   *
   *
   * stripped out obsolete parameter settings
   *
   * rpc tpg restored with correct dn access and dbe handling
   *
   * Revision 1.11  2008/03/12 17:24:24  berryhil
   *
   *
   * eliminated log files, truncated HCALTPGXana histo output
   *
   * Revision 1.10  2008/03/01 00:40:00  lat
   * DQM core migration.
   *
   * Revision 1.9  2008/01/22 18:56:01  muzaffar
   * include cleanup. Only for cc/cpp files
   *
   * Revision 1.8  2007/12/21 20:04:50  wsun
   * Migrated L1EtMissParticle -> L1EtMissParticleCollection.
   *
   * Revision 1.7  2007/12/21 17:41:20  berryhil
   *
   *
   * try/catch removal
   *
   * Revision 1.6  2007/11/19 15:08:22  lorenzo
   * changed top folder name
   *
   * Revision 1.5  2007/09/27 22:58:15  ratnik
   * QA campaign: fixes to compensate includes cleanup in  DataFormats/L1Trigger
   *
   * Revision 1.4  2007/07/19 18:05:06  berryhil
   *
   *
   * L1CaloRegionDetId dataformat migration for L1TCompare
   *
   * Revision 1.3  2007/06/13 11:33:39  wittich
   * add axis titles
   *
   * Revision 1.2  2007/06/08 08:37:43  wittich
   * Add ECAL TP - RCT comparisons. Lingering problems with
   * mismatches right now - still needs work.
   *
   * Revision 1.1  2007/06/06 14:55:51  wittich
   * compare within trigger subsystems
   *
   */
  
  #include "DQM/L1TMonitor/interface/L1TCompare.h"
  
  // stl
  #include <algorithm>
  
  using namespace l1extra;
  using namespace edm;
  
  const unsigned int PHIBINS = 18;
  const float PHIMIN = -0.5;
  const float PHIMAX = 17.5;
  
  // Ranks 6, 10 and 12 bits
  const unsigned int R6BINS = 64;
  const float R6MIN = -0.5;
  const float R6MAX = 63.5;
  
  // For GCT this should be 15 bins, -14.5 to 14.5
  //
  const unsigned int ETABINS = 22;
  const float ETAMIN = -0.5;
  const float ETAMAX = 21.5;
  
  // TPG
  const unsigned int TPPHIBINS = 72;
  const float TPPHIMIN = 0.5;
  const float TPPHIMAX = 72.5;
  
  const unsigned int TPETABINS = 65;
  const float TPETAMIN = -32.5;
  const float TPETAMAX = 32.5;
  
  
  L1TCompare::L1TCompare(const ParameterSet & ps) :
     rctSourceEm_token_( consumes<L1CaloEmCollection>(ps.getParameter< InputTag >("rctSource") ))
    ,rctSourceRctEmRgn_token_( consumes<L1CaloRegionCollection>(ps.getParameter< InputTag >("rctSource") ))
    ,rctSource_( ps.getParameter< InputTag >("rctSource") )
    ,gctSource_( ps.getParameter< InputTag >("gctSource") )
    ,ecalTpgSource_(ps.getParameter<edm::InputTag>("ecalTpgSource"))
    ,ecalTpgSource_token_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTpgSource")))
  
  {
  
    // verbosity switch
    verbose_ = ps.getUntrackedParameter < bool > ("verbose", false);
  
    if (verbose())
      std::cout << "L1TCompare: constructor...." << std::endl;
  
    outputFile_ =
        ps.getUntrackedParameter < std::string > ("outputFile", "");
    if (!outputFile_.empty()) {
      std::
  	cout << "L1T Monitoring histograms will be saved to " <<
  	outputFile_.c_str() << std::endl;
    }
  
    bool disable =
        ps.getUntrackedParameter < bool > ("disableROOToutput", false);
    if (disable) {
      outputFile_ = "";
    }
  
    //set Token(-s)
    edm::InputTag gctCenJetsTag_(gctSource_.label(),"cenJets");
    edm::InputTag gctIsoEmCandsTag_(gctSource_.label(), "isoEm");
    edm::InputTag gctNonIsoEmCandsTag_(gctSource_.label(), "nonIsoEm");
  
    gctCenJetsToken_ = consumes<L1GctJetCandCollection>(gctCenJetsTag_);
    gctIsoEmCandsToken_ = consumes<L1GctEmCandCollection>(gctIsoEmCandsTag_);
    gctNonIsoEmCandsToken_ = consumes<L1GctEmCandCollection>(gctNonIsoEmCandsTag_);
  }
  
  L1TCompare::~L1TCompare()
  {
  }
  
  void L1TCompare::dqmBeginRun(edm::Run const&, edm::EventSetup const&){
    //
  }
  
  void L1TCompare::bookHistograms(DQMStore::IBooker &ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) 
  {
    nev_ = 0;
    
    ibooker.setCurrentFolder("L1T/Compare");
      
      // -------------------------------------------
      // RCT-GCT
      // -------------------------------------------
      // Isolated
    rctGctLeadingIsoEmRank_ = ibooker.book2D("rctGctLeadingIsoEmRank",
  				       "RCT-GCT: rank", R6BINS, R6MIN, R6MAX,
  				       R6BINS, R6MIN, R6MAX);
    rctGctLeadingIsoEmRank_->setAxisTitle(std::string("gct"), 1);
    rctGctLeadingIsoEmRank_->setAxisTitle(std::string("rct"), 2);
    rctGctLeadingIsoEmEta_ = ibooker.book2D("rctGctLeadingIsoEmEta",
  				      "RCT-GCT: #eta", ETABINS, ETAMIN, ETAMAX,
  				       ETABINS, ETAMIN, ETAMAX);
    rctGctLeadingIsoEmEta_->setAxisTitle(std::string("gct"), 1);
    rctGctLeadingIsoEmEta_->setAxisTitle(std::string("rct"), 2);
  
    rctGctLeadingIsoEmPhi_ = ibooker.book2D("rctGctLeadingIsoEmPhi",
  				      "RCT-GCT: #phi", PHIBINS, PHIMIN, PHIMAX,
  				       PHIBINS, PHIMIN, PHIMAX);
    rctGctLeadingIsoEmPhi_->setAxisTitle(std::string("gct"), 1);
    rctGctLeadingIsoEmPhi_->setAxisTitle(std::string("rct"), 2);
      // non-Isolated
    rctGctLeadingNonIsoEmRank_ = ibooker.book2D("rctGctLeadingNonIsoEmRank",
  				       "RCT-GCT: rank", R6BINS, R6MIN, R6MAX,
  				       R6BINS, R6MIN, R6MAX);
    rctGctLeadingNonIsoEmRank_->setAxisTitle(std::string("gct"), 1);
    rctGctLeadingNonIsoEmRank_->setAxisTitle(std::string("rct"), 2);
  
    rctGctLeadingNonIsoEmEta_ = ibooker.book2D("rctGctLeadingNonIsoEmEta",
  				      "RCT-GCT: #eta", ETABINS, ETAMIN, ETAMAX,
  				       ETABINS, ETAMIN, ETAMAX);
    rctGctLeadingNonIsoEmEta_->setAxisTitle(std::string("gct"), 1);
    rctGctLeadingNonIsoEmEta_->setAxisTitle(std::string("rct"), 2);
  
    rctGctLeadingNonIsoEmPhi_ = ibooker.book2D("rctGctLeadingNonIsoEmPhi",
  				      "RCT-GCT: #phi", PHIBINS, PHIMIN, PHIMAX,
  				       PHIBINS, PHIMIN, PHIMAX);
    rctGctLeadingNonIsoEmPhi_->setAxisTitle(std::string("gct"), 1);
    rctGctLeadingNonIsoEmPhi_->setAxisTitle(std::string("rct"), 2);
      // -------------------------------------------
      // ECAL TPG - RCT
      // -------------------------------------------
    ecalTpgRctLeadingEmRank_ = ibooker.book2D("ecalTpgRctLeadingEmRank",
  					   "ECAL TPG-RCT: rank", 
  					   R6BINS, R6MIN, R6MAX,
  					   R6BINS, R6MIN, R6MAX);
    ecalTpgRctLeadingEmRank_->setAxisTitle(std::string("rct"), 1);
    ecalTpgRctLeadingEmRank_->setAxisTitle(std::string("ecal tp"), 2);
  
    ecalTpgRctLeadingEmEta_ = ibooker.book2D("ecalTpgRctLeadingEmEta",
  					  "ECAL TPG-RCT: #eta", 
  					  15, -0.5, 14.5,
  					  TPETABINS, TPETAMIN, TPETAMAX);
    ecalTpgRctLeadingEmEta_->setAxisTitle(std::string("rct"), 1);
    ecalTpgRctLeadingEmEta_->setAxisTitle(std::string("ecal tp"), 2);
    ecalTpgRctLeadingEmEta2_ = ibooker.book2D("ecalTpgRctLeadingEmEta2",
  					   "ECAL TPG-RCT: #eta (2)", 
  					   13, -6.5, 6.5,
  					   TPETABINS, TPETAMIN, TPETAMAX);
    ecalTpgRctLeadingEmEta2_->setAxisTitle(std::string("rct"), 1);
    ecalTpgRctLeadingEmEta2_->setAxisTitle(std::string("ecal tp"), 2);
    ecalTpgRctLeadingEmPhi_ = ibooker.book2D("ecalTpgRctLeadingEmPhi",
  					  "ECAL TPG-RCT: #phi", 
  					  PHIBINS, PHIMIN, PHIMAX,
  					  TPPHIBINS, TPPHIMIN, TPPHIMAX);
    ecalTpgRctLeadingEmPhi_->setAxisTitle(std::string("rct"), 1);
    ecalTpgRctLeadingEmPhi_->setAxisTitle(std::string("ecal tp"), 2);
    //}
  }
  
  void L1TCompare::analyze(const Event & e, const EventSetup & c)
  {
    ++nev_;
    if (verbose()) {
      std::cout << "L1TCompare: analyze...." << std::endl;
    }
  
    // L1E 
    edm::Handle < L1EmParticleCollection > l1eIsoEm;
    edm::Handle < L1EmParticleCollection > l1eNonIsoEm;
    edm::Handle < L1JetParticleCollection > l1eCenJets;
    edm::Handle < L1JetParticleCollection > l1eForJets;
    edm::Handle < L1JetParticleCollection > l1eTauJets;
    //  edm::Handle < L1EtMissParticle > l1eEtMiss;
    edm::Handle < L1EtMissParticleCollection > l1eEtMiss;
    // RCT
    edm::Handle < L1CaloEmCollection > em; // collection of L1CaloEmCands
    edm::Handle < L1CaloRegionCollection > rctEmRgn;
  
    // GCT
    edm::Handle <L1GctJetCandCollection> gctCenJets;
    edm::Handle <L1GctEmCandCollection> gctIsoEmCands;
    edm::Handle <L1GctEmCandCollection> gctNonIsoEmCands;
  
    
    e.getByToken(rctSourceEm_token_,em);
    
    if (!em.isValid()) {
      edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection with label "
  			       << rctSource_.label() ;
      return;
    }
  
    
    e.getByToken(rctSourceRctEmRgn_token_,rctEmRgn);
    
    if (!rctEmRgn.isValid()) {
      edm::LogInfo("DataNotFound") << "can't find "
  			       << "L1CaloRegionCollection with label "
  			       << rctSource_.label() ;
      return;
    }
  
    e.getByToken(gctCenJetsToken_, gctCenJets);
    e.getByToken(gctIsoEmCandsToken_, gctIsoEmCands);
    e.getByToken(gctNonIsoEmCandsToken_, gctNonIsoEmCands);
    
    if (!gctCenJets.isValid()) {
      std::cerr << "L1TGCT: could not find one of the classes?" << std::endl;
      return;
    }
   if (!gctIsoEmCands.isValid()) {
      std::cerr << "L1TGCT: could not find one of the classes?" << std::endl;
      return;
    }
   if (!gctNonIsoEmCands.isValid()) {
      std::cerr << "L1TGCT: could not find one of the classes?" << std::endl;
      return;
    }
   
  
    // GCT
    if ( verbose() ) {
      for ( L1GctEmCandCollection::const_iterator iem = gctIsoEmCands->begin();
  	  iem != gctIsoEmCands->end(); ++iem) {
        if ( !iem->empty() ) 
  	std::cout << "GCT EM: " << iem->rank() 
  		  << ", " 
  		  << iem->etaIndex() << "("
  	  //<< int(iem->etaIndex()&0x3)*((iem->etaIndex()&0x4)?1:-1)
  		  << "), " 
  		  << iem->phiIndex()
  		  << std::endl;
      }
    }
    // rct phi: 0-17
    // rct eta: 0-21
  
  
    // Fill the RCT histograms
  
    // Regions
    RctObjectCollection rcj, rcj_iso, rcj_non_iso;
    for (L1CaloEmCollection::const_iterator iem = em->begin();
         iem != em->end(); ++iem) { 
      //   L1CaloRegionDetId id(false, iem->rctCrate(), iem->rctCard(), 
      //			 iem->rctRegion());
         L1CaloRegionDetId id(iem->rctCrate(), iem->rctCard(), 
      			 iem->rctRegion());
  
         // RctObject h(id.gctEta(), id.gctPhi(), iem->rank());
      RctObject h(id.rctEta(), id.rctPhi(), iem->rank());
      if ( !iem->isolated() ) 
        rcj_non_iso.push_back(h);
      else 
        rcj_iso.push_back(h);
      rcj.push_back(h);
    }
    // not so smart but ...
    std::sort(rcj.begin(), rcj.end(), RctObjectComp());
    std::sort(rcj_non_iso.begin(), rcj_non_iso.end(), RctObjectComp());
    std::sort(rcj_iso.begin(), rcj_iso.end(), RctObjectComp());
    if ( verbose() ) {
      for (RctObjectCollection::reverse_iterator ij = rcj_iso.rbegin();
  	 ij != rcj_iso.rend() && ij != rcj_iso.rbegin()+8; ++ij) {
        std::cout << "RCT cj: " 
  		<< ij->rank_ << ", " << ij->eta_ << ", " << ij->phi_
  		<< std::endl;
      }
    }
    L1GctEmCandCollection::const_iterator lead_em = gctIsoEmCands->begin();
    if ( !lead_em->empty() ) { // equivalent to rank == 0
      rctGctLeadingIsoEmEta_->Fill(lead_em->etaIndex(), rcj_iso.rbegin()->eta_);
      rctGctLeadingIsoEmPhi_->Fill(lead_em->phiIndex(), rcj_iso.rbegin()->phi_);
      rctGctLeadingIsoEmRank_->Fill(lead_em->rank(), rcj_iso.rbegin()->rank_);
    }
  
    // non-isolated
    if ( verbose() ) {
      for ( L1GctEmCandCollection::const_iterator iem 
  	    = gctNonIsoEmCands->begin(); iem != gctNonIsoEmCands->end(); 
  	  ++iem) {
        if ( ! iem->empty() ) 
  	std::cout << "GCT EM non: " << iem->rank() 
  		  << ", " 
  		  << iem->etaIndex() //<< "("
  	  //<< int(iem->etaIndex()&0x3)*((iem->etaIndex()&0x4)?1:-1)
  		  //<< ")" 
  		  << ", " 
  		  << iem->phiIndex()
  		  << std::endl;
      }
    }
    if ( verbose() ) {
      for (RctObjectCollection::reverse_iterator ij = rcj_non_iso.rbegin();
  	 ij != rcj_non_iso.rend() && ij != rcj_non_iso.rbegin()+8; ++ij) {
        std::cout << "RCT cj non: " 
  		<< ij->rank_ << ", " << ij->eta_ << ", " << ij->phi_
  		<< std::endl;
      }
    }
    lead_em = gctNonIsoEmCands->begin();
    if ( !lead_em->empty() ) { // equivalent to rank != 0
      rctGctLeadingNonIsoEmEta_->Fill(lead_em->etaIndex(), 
  				    rcj_non_iso.rbegin()->eta_);
      rctGctLeadingNonIsoEmPhi_->Fill(lead_em->phiIndex(), 
  				    rcj_non_iso.rbegin()->phi_);
      rctGctLeadingNonIsoEmRank_->Fill(lead_em->rank(), 
  				     rcj_non_iso.rbegin()->rank_);
    }
  
    // ECAL TPG's to RCT EM 
    edm::Handle < EcalTrigPrimDigiCollection > eTP;
    e.getByToken(ecalTpgSource_token_,eTP);
    
    if (!eTP.isValid()) {
      edm::LogInfo("DataNotFound") 
        << "can't find EcalTrigPrimCollection with label "
        << ecalTpgSource_.label() ;
      return;
    }
    RctObjectCollection ecalobs;
    for (EcalTrigPrimDigiCollection::const_iterator ieTP = eTP->begin();
         ieTP != eTP->end(); ieTP++) {
      ecalobs.push_back(RctObject(ieTP->id().ieta(),
  				 ieTP->id().iphi(), 
  				 ieTP->compressedEt()));
    }
    std::sort(ecalobs.begin(), ecalobs.end(), RctObjectComp());
    if ( verbose() ) {
      for (RctObjectCollection::reverse_iterator ij = ecalobs.rbegin();
  	 ij != ecalobs.rend() && ij != ecalobs.rbegin()+8; ++ij) {
        std::cout << "ECAL cj : " 
  		<< ij->rank_ << ", " << ij->eta_ << ", " << ij->phi_
  		<< std::endl;
      }
    }
    // abritrary cut
    if ( rcj.rbegin()->rank_ > 4 ) {
      ecalTpgRctLeadingEmEta_->Fill(rcj.rbegin()->eta_,
  				  ecalobs.rbegin()->eta_);
      int e2 = (rcj.rbegin()->eta_&0x7UL)* ((rcj.rbegin()->eta_&0x8UL)?1:-1);
      ecalTpgRctLeadingEmEta2_->Fill(e2, ecalobs.rbegin()->eta_);
      ecalTpgRctLeadingEmPhi_->Fill(rcj.rbegin()->phi_, ecalobs.rbegin()->phi_);
      ecalTpgRctLeadingEmRank_->Fill(rcj.rbegin()->rank_,
  				   ecalobs.rbegin()->rank_);
    }
    if ( verbose() ) {
      int seta = rcj.rbegin()->eta_;
      seta = (seta&0x7UL)*(seta&0x8?-1:1);
      std::cout << "ZZ: " 
  	      << rcj.rbegin()->eta_ << " "
  	      << rcj.rbegin()->phi_ << " "
  	      << rcj.rbegin()->rank_ << " "
  	      << (++rcj.rbegin())->rank_<< " "
  	      << ecalobs.rbegin()->eta_ << " "
  	      << ecalobs.rbegin()->phi_ << " "
  	      << ecalobs.rbegin()->rank_ << " "
  	      << (++ecalobs.rbegin())->rank_<< " "
  	      << seta << " "
  	      << std::endl;
    }
  
  
  
  }
  