/*****************************************************************************
 * @Package: AZAnalysis/AZUtils
 * @class HLTJetMET
 *****************************************************************************/
#include "AZCore/Config.h"

// Local includes
#include "AZUser/HLTJetMET.h"
#include "AZCore/DataStore.h"

#include "TrigDecisionTool/TrigDecisionToolARA.h"
#include "TrigDecisionTool/TDTUtilities.h"
#include "TrigDecisionTool/FeatureContainer.h"
#include "TrigDecisionTool/Feature.h"
#include "TrigObjectMatching/TrigMatchToolARA.h"

#include "AnalysisTriggerEvent/LVL1_ROI.h"
#include "TrigCaloEvent/TrigT2JetContainer.h"
#include "TrigMissingEtEvent/TrigMissingETContainer.h"
#include "TrigMuonEvent/MuonFeature.h"

// both for ef and reco
#include "JetEvent/JetCollection.h"
#include "MissingETEvent/MissingET.h"
#include "MissingETEvent/MissingEtCalo.h"
#include "muonEvent/MuonContainer.h"
#include "egammaEvent/ElectronContainer.h"
#include "EventInfo/EventID.h"
#include "EventInfo/EventInfo.h"


// ROOT includes
#include "TString.h"

// STL includes
#include <iterator>

// namespaces
using namespace std;

using TrigDec::TrigDecision;

/** Default constructor */
HLTJetMET::HLTJetMET(const std::string& name) : 
  logme(name)
{

  Config config(name);

  m_jetsFromName    = config.get( "JetsFrom", "Cone4H1TowerJets" );
  m_muonsFromName    = config.get( "MuonsFrom", "StacoMuonCollection" );
  m_electronsFromName    = config.get( "ElectronsFrom", "ElectronCollection" );
  m_metcalibFromName    = config.get( "METCalibFrom", "MET_Calib" );

  m_seljetsFromName = config.get( "SelectedJetsFrom", "myLooseJets" );
  m_selmuonsFromName = config.get( "SelectedMuonsFrom", "myLooseMuons" );
  m_selelectronsFromName = config.get( "SelectedElectronsFrom", "myLooseElectrons" );

  m_trigl1roisFromName = config.get( "L1ROIsFrom", "LVL1_ROI" );
  m_trigl2jetsFromName = config.get( "L2JetsFrom", "HLT_TrigT2CaloJet" );
  m_trigefjetsFromName = config.get( "EFJetsFrom", "HLT_TrigJetRec" );
  m_trigl2metFromName = config.get( "L2METFrom", "HLT_T2MissingET" );
  m_trigefmetFromName = config.get( "EFMETFrom", "HLT_TrigEFMissingET" );

  
  m_L1Names         = config.getVString("L1Names", " ,");
  m_L2Names         = config.getVString("L2Names", " ,");
  m_EFNames         = config.getVString("EFNames", " ,");

  m_passAnyTrig     = config.get("PassAnyTrigger", true);
  m_passAnyLevel    = config.get("PassAnyLevel", true);
  m_reqLevel1       = config.get("RequireL1", false);
  m_reqLevel2       = config.get("RequireL2", false);
  m_reqLevel3       = config.get("RequireEF", true);

  m_chainGrp        = config.get("ChainGroup", "EF_mu.*");

  // hists here for now
  m_l1_jet_et = new TH1F("m_l1_jet_et","l1 jet et",50,0.,100.);
  m_l2_jet_et = new TH1F("m_l2_jet_et","l2 jet et",50,0.,100.);
  m_ef_jet_et = new TH1F("m_ef_jet_et","ef jet et",50,0.,100.);
  m_reco_jet_pt = new TH1F("m_reco_jet_pt","reco jet pt",50,0.,100.);
  m_reco_seljet_pt = new TH1F("m_reco_seljet_pt","reco sel jet pt",50,0.,100.);

  m_reco_jet_eta = new TH1F("m_reco_jet_eta","reco jet eta",50,-2.5,2.5);
  m_reco_jet_phi = new TH1F("m_reco_jet_phi","reco jet phi",60,0.,360.);


  m_l1_jet_n = new TH1F("m_l1_jet_n","l1 jet n",20,0.,20.); 
  m_l2_jet_n = new TH1F("m_l2_jet_n","l2 jet n",20,0.,20.); 
  m_ef_jet_n = new TH1F("m_ef_jet_n","ef jet n",20,0.,20.); 
  m_reco_jet_n = new TH1F("m_reco_jet_n","reco jet n",20,0.,20.);
  m_reco_seljet_n = new TH1F("m_reco_seljet_n","reco sel jet n",20,0.,20.);

  m_l1_met_et = new TH1F("m_l1_met_et","l1 met et",50,0.,100.);
  m_l2_met_et = new TH1F("m_l2_met_et","l2 met et",50,0.,100.);
  m_ef_met_et = new TH1F("m_ef_met_et","ef met et",50,0.,100.);
  m_calib_met_et = new TH1F("m_calib_met_et","calib met et",50,0.,100.);

  m_reco_jet_emfrac = new TH1F("m_reco_jet_emfrac","reco jet emfrac",50,0.,1.);
  m_reco_jet_em1frac = new TH1F("m_reco_jet_em1frac","reco jet em1frac",50,0.,1.);
  m_reco_jet_em2frac = new TH1F("m_reco_jet_em2frac","reco jet em2frac",50,0.,1.);
  m_reco_jet_em3frac = new TH1F("m_reco_jet_em3frac","reco jet em3frac",50,0.,1.);

  m_reco_jet_l1_jet_dr = new TH1F("m_reco_jet_l1_jet_dr","reco jet l1 jet dr",50,0.,0.5);
  m_reco_jet_l2_jet_dr = new TH1F("m_reco_jet_l2_jet_dr","reco jet l2 jet dr",50,0.,0.5);
  m_reco_jet_ef_jet_dr = new TH1F("m_reco_jet_ef_jet_dr","reco jet ef jet dr",50,0.,0.5);
 
  m_reco_jet_pt_den =  new TH1F("m_reco_jet_pt_den","reco jet pt den",50,0.,100.); 
  m_reco_jet_pt_l1_num =  new TH1F("m_reco_jet_pt_l1_num","reco jet pt l1 num",50,0.,100.); 
  m_reco_jet_pt_l2_num =  new TH1F("m_reco_jet_pt_l2_num","reco jet pt l2 num",50,0.,100.); 
  m_reco_jet_pt_ef_num =  new TH1F("m_reco_jet_pt_ef_num","reco jet pt ef num",50,0.,100.);
  m_reco_jet_pt_den->Sumw2();
  m_reco_jet_pt_l1_num->Sumw2();
  m_reco_jet_pt_l2_num->Sumw2();
  m_reco_jet_pt_ef_num->Sumw2();

  m_reco_jet_eta_den =  new TH1F("m_reco_jet_eta_den","reco jet eta den",50,-2.5,2.5);  
  m_reco_jet_eta_l1_num =  new TH1F("m_reco_jet_eta_l1_num","reco jet eta l1 num",50,-2.5,2.5);  
  m_reco_jet_eta_l2_num =  new TH1F("m_reco_jet_eta_l2_num","reco jet eta l2 num",50,-2.5,2.5);  
  m_reco_jet_eta_ef_num =  new TH1F("m_reco_jet_eta_ef_num","reco jet eta ef num",50,-2.5,2.5);  
  m_reco_jet_eta_den->Sumw2();
  m_reco_jet_eta_l1_num->Sumw2();
  m_reco_jet_eta_l2_num->Sumw2();
  m_reco_jet_eta_ef_num->Sumw2();

  m_reco_jet_phi_den =  new TH1F("m_reco_jet_phi_den","reco jet phi den",60,0.,360.);  
  m_reco_jet_phi_l1_num =  new TH1F("m_reco_jet_phi_l1_num","reco jet phi l1 num",60,0.,360.);  
  m_reco_jet_phi_l2_num =  new TH1F("m_reco_jet_phi_l2_num","reco jet phi l2 num",60,0.,360.);  
  m_reco_jet_phi_ef_num =  new TH1F("m_reco_jet_phi_ef_num","reco jet phi ef num",60,0.,360.);  
  m_reco_jet_phi_den->Sumw2();
  m_reco_jet_phi_l1_num->Sumw2();
  m_reco_jet_phi_l2_num->Sumw2();
  m_reco_jet_phi_ef_num->Sumw2();

  m_reco_jet_pt_l1_eff =  new TH1F("m_reco_jet_pt_l1_eff","reco jet pt l1 eff",50,0.,100.); 
  m_reco_jet_pt_l2_eff =  new TH1F("m_reco_jet_pt_l2_eff","reco jet pt l2 eff",50,0.,100.); 
  m_reco_jet_pt_ef_eff =  new TH1F("m_reco_jet_pt_ef_eff","reco jet pt ef eff",50,0.,100.);
  m_reco_jet_eta_l1_eff =  new TH1F("m_reco_jet_eta_l1_eff","reco jet eta l1 eff",50,-2.5,2.5); 
  m_reco_jet_eta_l2_eff =  new TH1F("m_reco_jet_eta_l2_eff","reco jet eta l2 eff",50,-2.5,2.5); 
  m_reco_jet_eta_ef_eff =  new TH1F("m_reco_jet_eta_ef_eff","reco jet eta ef eff",50,-2.5,2.5);
  m_reco_jet_phi_l1_eff =  new TH1F("m_reco_jet_phi_l1_eff","reco jet phi l1 eff",60,0.,360.); 
  m_reco_jet_phi_l2_eff =  new TH1F("m_reco_jet_phi_l2_eff","reco jet phi l2 eff",60,0.,360.); 
  m_reco_jet_phi_ef_eff =  new TH1F("m_reco_jet_phi_ef_eff","reco jet phi ef eff",60,0.,360.);

	}

/** Default destructor */
HLTJetMET::~HLTJetMET() {
}


/** Process this event */
bool HLTJetMET::ProcessEvent(DataStore& dataStore) {

  // retrieve pointer to trigger decision tool from dataStore
  Trig::TrigDecisionToolARA *tdt = NULL;
  //dataStore.retrieve(tdt, "TrigDecisionTool");
  tdt = dataStore.getTDT(); 

  if (tdt)
    logme << INFO << "tdt is found!" << SLogger::endmsg;
    
  // retrieve pointer to trigger matching tool
  TrigMatchToolARA *tmt(0);
  tmt = dataStore.getTMT();

  if (tmt)
    logme << INFO << "tmt is found!" << SLogger::endmsg;

  logme << INFO << "start!" << SLogger::endmsg;

  if (tdt) {
    const Trig::ChainGroup* m_EF_j5 = tdt->getChainGroup(m_EFNames[0].c_str()); 
    logme << INFO << " " << m_EF_j5->isPassed() << SLogger::endmsg;
    const Trig::ChainGroup* m_EF_e10_loose = tdt->getChainGroup(m_EFNames[1].c_str());
    logme << INFO << " " << m_EF_e10_loose->isPassed() << SLogger::endmsg;
    const Trig::ChainGroup* m_EF_mu = tdt->getChainGroup("EF_mu.*"); 
    logme << INFO << "EF_mu* " << m_EF_mu->isPassed() << SLogger::endmsg;
    const Trig::ChainGroup* m_EF_all = tdt->getChainGroup("EF_.*");  
    logme << INFO << "EF_* " << m_EF_all->isPassed() << SLogger::endmsg; 
   
  }

  // get l1, l2, ef jet and met info

  LVL1_ROI *trigl1roisbr(0);
  dataStore.retrieve(trigl1roisbr,m_trigl1roisFromName);
  if (trigl1roisbr)  logme << INFO << "l1 rois are found!" << SLogger::endmsg;

  TrigT2JetContainer *trigl2jetsbr(0);
  dataStore.retrieve(trigl2jetsbr,m_trigl2jetsFromName);
  if (trigl2jetsbr)  logme << INFO << "l2 jets are found!" << SLogger::endmsg;
  JetCollection *trigefjetsbr(0);
  dataStore.retrieve(trigefjetsbr,m_trigefjetsFromName);
  if (trigefjetsbr)  logme << INFO << "ef jets are found!" << SLogger::endmsg;

  TrigMissingETContainer *trigl2metbr(0);
  dataStore.retrieve(trigl2metbr,m_trigl2metFromName);
  if (trigl2metbr)  logme << INFO << "l2 met is found!" << SLogger::endmsg;
  TrigMissingETContainer *trigefmetbr(0);
  dataStore.retrieve(trigefmetbr,m_trigefmetFromName);
  if (trigefmetbr)  logme << INFO << "ef met is found!" << SLogger::endmsg;

  // get reco muon, ele, jet, met info
  JetCollection *jetsbr(0);
  dataStore.retrieve(jetsbr,m_jetsFromName);
  if (jetsbr)  logme << INFO << "reco jets are found!" << SLogger::endmsg;
  ElectronContainer *elesbr(0);
  dataStore.retrieve(elesbr,m_electronsFromName);
  if (elesbr)  logme << INFO << "reco eles are found!" << SLogger::endmsg;
  Analysis::MuonContainer *muonsbr(0);
  dataStore.retrieve(muonsbr,m_muonsFromName);
  if (muonsbr)  logme << INFO << "reco muons are found!" << SLogger::endmsg;
  MissingEtCalo *metcalibbr(0);
  dataStore.retrieve(metcalibbr,m_metcalibFromName);
  if (metcalibbr)  logme << INFO << "reco met calib is found!" << SLogger::endmsg;
  JetCollection *seljetsbr(0);
  dataStore.retrieve(seljetsbr,m_seljetsFromName);
  if (seljetsbr)  logme << INFO << "selected jets are found!" << SLogger::endmsg;


  if (trigl1roisbr) {
    LVL1_ROI::jets_type L1JetROI;
    L1JetROI = trigl1roisbr->getJetROIs();
    if (L1JetROI.size() > 0) logme << INFO << "l1 jet rois found!" << SLogger::endmsg;
    int n_jet = 0;
    for(LVL1_ROI::jets_type::const_iterator iter = L1JetROI.begin(); 
        iter != L1JetROI.end(); ++iter) {
      double et = iter->getET4x4(); 
      m_l1_jet_et->Fill(et/GeV);
      double eta = iter->getEta();
      double phi = iter->getPhi();
      n_jet++;
    }
    m_l1_jet_n->Fill(n_jet);
  }
   
  if (trigl1roisbr) {
    LVL1_ROI::energysums_type L1METROI;
    L1METROI = trigl1roisbr->getEnergySumROIs();
    if (L1METROI.size() > 0) logme << INFO << "l1 met rois found!" << SLogger::endmsg;
    for(LVL1_ROI::energysums_type::const_iterator iter = L1METROI.begin(); 
        iter != L1METROI.end(); ++iter) {
    double ex = iter->getEnergyX();
    double ey = iter->getEnergyY();
    double et = sqrt(ex*ex + ey*ey);
    m_l1_met_et->Fill(et/GeV);
    double phi = atan2(ey,ex);
    phi = phi / degree;  
    if (phi < 0) phi = phi + 360.;
    double sumet = iter->getEnergyT();
    }
  }
 
  if (trigl2jetsbr) { 
    //logme << INFO << "in l2 jets" << SLogger::endmsg;
    int n_jet = 0;
    for(TrigT2JetContainer::const_iterator iter = trigl2jetsbr->begin(); 
        iter != trigl2jetsbr->end(); ++iter) {
      double e = (*iter)->e();
      double eta = (*iter)->eta(); 
      double et = e/cosh(eta);
      m_l2_jet_et->Fill(et/GeV);
      double phi = (*iter)->phi();
      phi = phi / degree;  
      if (phi < 0) phi = phi + 360.;
      double eem0 = (*iter)->eem0();
      double ehad0 = (*iter)->ehad0(); 
      n_jet++;
    }
    m_l2_jet_n->Fill(n_jet); 
  }
  if (trigefjetsbr) { 
    int n_jet = 0;
    for(JetCollection::const_iterator iter = trigefjetsbr->begin();  
        iter != trigefjetsbr->end(); ++iter) { 
      double e = (*iter)->e(); 
      double et = (*iter)->et(); 
      m_ef_jet_et->Fill(et/GeV); 
      double eta = (*iter)->eta();
      double phi = (*iter)->phi(); 
      phi = phi / degree;   
      if (phi < 0) phi = phi + 360.;

       n_jet++;
    } 
    m_ef_jet_n->Fill(n_jet);
  }

  if (trigl2metbr) { 
    const TrigMissingET *trigMET = 0; 
    TrigMissingETContainer::const_iterator iter_begin = trigl2metbr->begin();
    TrigMissingETContainer::const_iterator iter_end = trigl2metbr->end();
    if (iter_begin != iter_end) {
      trigMET = *iter_begin;  
    }
    if (trigMET) {
      double ex = trigMET->ex();
      double ey = trigMET->ey();
      double et = trigMET->et();
      m_l2_met_et->Fill(et/GeV); 
      double phi = atan2(ey,ex);
      phi = phi /degree;  
      if (phi < 0) phi = phi + 360.;
    }
  }
  if (trigefmetbr) { 
    const TrigMissingET *trigMET = 0;  
    TrigMissingETContainer::const_iterator iter_begin = trigefmetbr->begin(); 
    TrigMissingETContainer::const_iterator iter_end = trigefmetbr->end(); 
    if (iter_begin != iter_end) { 
      trigMET = *iter_begin;   
    }
    if (trigMET) {
      double ex = trigMET->ex(); 
      double ey = trigMET->ey(); 
      double et = trigMET->et();
      m_ef_met_et->Fill(et/GeV);  
      double phi = atan2(ey,ex); 
      phi = phi / degree;   
      if (phi < 0) phi = phi + 360.;
    } 
  }
      
  if(jetsbr) {
    int n_jet = 0; 
    for(JetCollection::const_iterator iter = jetsbr->begin();
	iter != jetsbr->end(); ++iter) {
      double p = (*iter)->p();
      double pt = (*iter)->pt();
      m_reco_jet_pt->Fill(pt/GeV);
      double eta = (*iter)->eta(); 
      m_reco_jet_eta->Fill(eta);
      double phi = (*iter)->phi();
      phi = phi / degree;  
      if (phi < 0) phi = phi + 360.;
      m_reco_jet_phi->Fill(phi);
      double energyInLayers = (*iter)->getMoment("energy_PreSamplerE")+(*iter)->getMoment("energy_PreSamplerB")+
	(*iter)->getMoment("energy_EMB1")+(*iter)->getMoment("energy_EMB2")+(*iter)->getMoment("energy_EMB3")+
	(*iter)->getMoment("energy_TileBar0")+(*iter)->getMoment("energy_TileBar1")+(*iter)->getMoment("energy_TileBar2")+
	(*iter)->getMoment("energy_EME1")+(*iter)->getMoment("energy_EME2")+(*iter)->getMoment("energy_EME3")+
	(*iter)->getMoment("energy_TileGap1")+(*iter)->getMoment("energy_TileGap2")+(*iter)->getMoment("energy_TileGap3")+
	(*iter)->getMoment("energy_HEC0")+(*iter)->getMoment("energy_HEC1")+(*iter)->getMoment("energy_HEC2")+
	(*iter)->getMoment("energy_HEC3")+(*iter)->getMoment("energy_TileExt0")+(*iter)->getMoment("energy_TileExt1")+
	(*iter)->getMoment("energy_TileExt2");
       double EMPreFrac = ( (*iter)->getMoment("energy_PreSamplerB")+(*iter)->getMoment("energy_PreSamplerE") )/energyInLayers;
       double EM1Frac = ( (*iter)->getMoment("energy_EMB1") )/energyInLayers;
       double EM2Frac = ( (*iter)->getMoment("energy_EMB2") )/energyInLayers;
       double EM3Frac = ( (*iter)->getMoment("energy_EMB3") )/energyInLayers;
       logme << VERBOSE << "fractions!"  << energyInLayers << " " << EM1Frac << " " << EM2Frac << SLogger::endmsg;

       double EMECFrac = ((*iter)->getMoment("energy_EME1")
			  + (*iter)->getMoment("energy_EME2")
			  + (*iter)->getMoment("energy_EME3"))/energyInLayers;
       
       double TileGapFrac = ((*iter)->getMoment("energy_TileGap1")
			     + (*iter)->getMoment("energy_TileGap2")
			     + (*iter)->getMoment("energy_TileGap3"))/energyInLayers;
 
       double HECFrac = ((*iter)->getMoment("energy_HEC0")
			 + (*iter)->getMoment("energy_HEC1")
			 + (*iter)->getMoment("energy_HEC2")
			 + (*iter)->getMoment("energy_HEC3"))/energyInLayers;
       m_reco_jet_em1frac->Fill(EM1Frac);
       m_reco_jet_em2frac->Fill(EM2Frac);
       m_reco_jet_em3frac->Fill(EM3Frac);
       double EMFrac = ( (*iter)->getMoment("energy_PreSamplerB")+(*iter)->getMoment("energy_PreSamplerE") 
			 + (*iter)->getMoment("energy_EMB1") + (*iter)->getMoment("energy_EMB2") 
			 + (*iter)->getMoment("energy_EMB3") + (*iter)->getMoment("energy_EME1")
			 + (*iter)->getMoment("energy_EME2") + (*iter)->getMoment("energy_EME3") )/energyInLayers;
       m_reco_jet_emfrac->Fill(EMFrac);
      n_jet++;
      }
    m_reco_jet_n->Fill(n_jet);
  }
  if(muonsbr) {
    for(Analysis::MuonContainer::const_iterator iter = muonsbr->begin();
        iter != muonsbr->end(); ++iter) {
      double p = (*iter)->p();
      double pt = (*iter)->pt();
      double eta = (*iter)->eta(); 
      double phi = (*iter)->phi();
      phi = phi / degree;  
      if (phi < 0) phi = phi + 360.; 
      }
  }
  if(elesbr) {
    for(ElectronContainer::const_iterator iter = elesbr->begin();
	iter != elesbr->end(); ++iter) {
      double p = (*iter)->p();
      double pt = (*iter)->pt();
      double eta = (*iter)->eta(); 
      double phi = (*iter)->phi();
      phi = phi / degree;  
      if (phi < 0) phi = phi + 360.; 
    }
  }
  if (metcalibbr) {
    double ex = metcalibbr->etx(); 
    double ey = metcalibbr->ety(); 
    double et = metcalibbr->et();
    m_calib_met_et->Fill(et);
    double phi = metcalibbr->phi();
    phi = phi / degree;   
    if (phi < 0) phi = phi + 360.;
  }

  
  // this is an example of the trigger matching tool
  if (tmt) {
    if (trigefjetsbr) { 
      for (JetCollection::const_iterator iter = trigefjetsbr->begin(); iter != trigefjetsbr->end(); ++iter) { 
	logme << VERBOSE << "have ef jet" << SLogger::endmsg;
	logme << VERBOSE << "pt,eta,phi " << (*iter)->pt() << " " << (*iter)->eta() 
	      << " " << (*iter)->phi() << SLogger::endmsg;
	//
	//	std::vector<std::string> matchingChains = 
	//  m_matchTool->chainsPassedByObject<TrigMatch::TrigJetL1>(*iter);

	std::vector<std::string> matchingChains = 
	  tmt->chainsPassedByObject<TrigT2Jet>(*iter);
	bool hasMatch = false;
	//if(matchingChains && matchingChains.size() > 0) {
	  for(std::vector<std::string>::const_iterator chainIter = matchingChains.begin();
	      chainIter != matchingChains.end(); ++chainIter) {
	    logme << VERBOSE << "chain is" << *chainIter << SLogger::endmsg;
	    // we're only interested in L2 items, so lets skip the others
	    if(chainIter->find("L2_") == std::string::npos)
	      continue;
	  
	    const TrigT2Jet *match = 
	      tmt->matchToTriggerObject<TrigT2Jet>(*iter, *chainIter, true);
	    if (match) {
	      hasMatch = true;
	      logme << VERBOSE << "we have an l2 match to ef jet!" << SLogger::endmsg;
	      logme << VERBOSE << "l2 match in item " << *chainIter << " with eta, phi, pt " 
		    << match->eta() << " " << match->phi() << " " 
		    << match->pt() << SLogger::endmsg;
	    }
	  }
	  //}
      }
    }
  }
  // this is an example of the tmt tool used to calculate efficiencies
  // lookhere

  if (tdt) {
    //const Trig::ChainGroup* m_EF_mu = tdt->getChainGroup("EF_mu.*"); 
    const Trig::ChainGroup* m_EF_mu = tdt->getChainGroup("EF_Jet_V2"); 
    logme << INFO << "EF_mu* " << m_EF_mu->isPassed() << SLogger::endmsg;
    if (m_EF_mu->isPassed()) {
  
      if (tmt) { 
 
	if(jetsbr) { 
	  int n_jet = 0;  
	  for(JetCollection::const_iterator iter = jetsbr->begin(); 
	      iter != jetsbr->end(); ++iter) { 
	    logme << INFO << "have reco jet" << SLogger::endmsg; 
	    logme << INFO << "pt,eta,phi " << (*iter)->pt() << " " << (*iter)->eta()  
		  << " " << (*iter)->phi() << SLogger::endmsg;
	    m_reco_jet_pt_den->Fill(((*iter)->pt())/GeV);
	    m_reco_jet_eta_den->Fill((*iter)->eta());
	    double phi = (*iter)->phi(); 
	    phi = phi / degree;   
	    if (phi < 0) phi = phi + 360.;
	    m_reco_jet_phi_den->Fill(phi);		    
			     
        // 
        //      std::vector<std::string> matchingChains =  
        //  m_matchTool->chainsPassedByObject<TrigMatch::TrigJetL1>(*iter); 
 
	    std::vector<std::string> matchingChains =  
	      tmt->chainsPassedByObject<Jet_ROI>(*iter, 0.4);
	    bool hasMatch = false; 
	    //if(matchingChains && matchingChains.size() > 0) { 
	      for(std::vector<std::string>::const_iterator chainIter = matchingChains.begin(); 
		  chainIter != matchingChains.end(); ++chainIter) { 
		logme << INFO << "my chain is " << *chainIter << SLogger::endmsg; 
		// we're only interested in L1 items, so lets skip the others 
		if(chainIter->find("L1_") == std::string::npos) 
		  continue; 
		
		const Jet_ROI *match =  
		  tmt->matchToTriggerObject<Jet_ROI>(*iter, *chainIter, 0.4, true); 
		if (match && !hasMatch) {  
		  logme << INFO << "we have a match!" << SLogger::endmsg; 
		  logme << INFO << "l1 match in item " << *chainIter << " with eta, phi, pt "  
			<< match->eta() << " " << match->phi() << " "  
			<< match->pt() << SLogger::endmsg; 
		} 
		if (match && !hasMatch && (*chainIter == "L1_J5_EMPTY")) {
		  logme << INFO << "we have a match with L1_J5_EMPTY! " << match->eta() << SLogger::endmsg;
		  hasMatch = true;
		  m_reco_jet_pt_l1_num->Fill(((*iter)->pt())/GeV);
		  m_reco_jet_eta_l1_num->Fill((*iter)->eta());
		  double phi = (*iter)->phi(); 
		  phi = phi / degree;   
		  if (phi < 0) phi = phi + 360.;
		  m_reco_jet_phi_l1_num->Fill(phi);
		  m_reco_jet_l1_jet_dr->Fill(tmt->distance(*iter, match)); 
		}
	      }
	      //}
	  }
	}

	if(jetsbr) { 
	  int n_jet = 0;  
	  for(JetCollection::const_iterator iter = jetsbr->begin(); 
	      iter != jetsbr->end(); ++iter) { 
	    logme << INFO << "have reco jet" << SLogger::endmsg; 
	    logme << INFO << "pt,eta,phi " << (*iter)->pt() << " " << (*iter)->eta()  
		  << " " << (*iter)->phi() << SLogger::endmsg;
	    m_reco_jet_pt_den->Fill(((*iter)->pt())/GeV);
	    m_reco_jet_eta_den->Fill((*iter)->eta());
	    double phi = (*iter)->phi(); 
	    phi = phi / degree;   
	    if (phi < 0) phi = phi + 360.;
	    m_reco_jet_phi_den->Fill(phi);		    
			     
        // 
        //      std::vector<std::string> matchingChains =  
        //  m_matchTool->chainsPassedByObject<TrigMatch::TrigJetL1>(*iter); 
 
	    std::vector<std::string> matchingChains =  
	      tmt->chainsPassedByObject<TrigT2Jet>(*iter, 0.4);
	    bool hasMatch = false; 
	    //if(matchingChains && matchingChains.size() > 0) { 
	      for(std::vector<std::string>::const_iterator chainIter = matchingChains.begin(); 
		  chainIter != matchingChains.end(); ++chainIter) { 
		logme << INFO << "chain is " << *chainIter << SLogger::endmsg; 
		// we're only interested in L2 items, so lets skip the others 
		if(chainIter->find("L2_") == std::string::npos) 
		  continue; 
		
		const TrigT2Jet *match =  
		  tmt->matchToTriggerObject<TrigT2Jet>(*iter, *chainIter, 0.4, true); 
		if (match && !hasMatch) {  
		  logme << INFO << "we have a match!" << SLogger::endmsg; 
		  logme << INFO << "l2 match in item " << *chainIter << " with eta, phi, pt "  
			<< match->eta() << " " << match->phi() << " "  
			<< match->pt() << SLogger::endmsg; 
		} 
		if (match && !hasMatch && (*chainIter == "L2_Jet_V2")) {
		  logme << INFO << "we have a match with L2_Jet_V2! " << match->eta() << SLogger::endmsg;
		  hasMatch = true;
		  m_reco_jet_pt_l2_num->Fill(((*iter)->pt())/GeV);
		  m_reco_jet_eta_l2_num->Fill((*iter)->eta());
		  double phi = (*iter)->phi(); 
		  phi = phi / degree;   
		  if (phi < 0) phi = phi + 360.;
		  m_reco_jet_phi_l2_num->Fill(phi);
		  m_reco_jet_l2_jet_dr->Fill(tmt->distance(*iter, match)); 
		}
	      }
	      //}
	  }
	}

	if(jetsbr) { 
	  int n_jet = 0;  
	  for(JetCollection::const_iterator iter = jetsbr->begin(); 
	      iter != jetsbr->end(); ++iter) { 
	    logme << INFO << "have reco jet" << SLogger::endmsg; 
	    logme << INFO << "pt,eta,phi " << (*iter)->pt() << " " << (*iter)->eta()  
		  << " " << (*iter)->phi() << SLogger::endmsg;

        // 
        //      std::vector<std::string> matchingChains =  
        //  m_matchTool->chainsPassedByObject<TrigMatch::TrigJetL1>(*iter); 
 
	    std::vector<std::string> matchingChains =  
	      tmt->chainsPassedByObject<Jet>(*iter, 0.4);
	    bool hasMatch = false; 
	    //if(matchingChains && matchingChains.size() > 0) { 
	      for(std::vector<std::string>::const_iterator chainIter = matchingChains.begin(); 
		  chainIter != matchingChains.end(); ++chainIter) { 
		logme << INFO << "chain is " << *chainIter << SLogger::endmsg; 
		// we're only interested in EF items, so lets skip the others 
		if(chainIter->find("EF_") == std::string::npos) 
		  continue; 
		
		const Jet *match =  
		  tmt->matchToTriggerObject<Jet>(*iter, *chainIter, 0.4, true); 
		if (match && !hasMatch) {  
		  logme << INFO << "we have a match!" << SLogger::endmsg; 
		  logme << INFO << "ef match in item " << *chainIter << " with eta, phi, pt "  
			<< match->eta() << " " << match->phi() << " "  
			<< match->pt() << SLogger::endmsg; 
		} 
		if (match && !hasMatch && (*chainIter == "EF_Jet_V2")) {
		  logme << INFO << "we have a match with EF_Jet_V2! " << match->eta() << SLogger::endmsg;
		  hasMatch = true;
		  m_reco_jet_pt_ef_num->Fill(((*iter)->pt())/GeV);
		  m_reco_jet_eta_ef_num->Fill((*iter)->eta());
		  double phi = (*iter)->phi(); 
		  phi = phi / degree;   
		  if (phi < 0) phi = phi + 360.;
		  m_reco_jet_phi_ef_num->Fill(phi);
		  m_reco_jet_ef_jet_dr->Fill(tmt->distance(*iter, match)); 
		}
	      }
	      //}
	  }
	}
      }
    }
  }
	/*
	std::vector<std::string> *matchingChains =  
          tmt->chainsPassedByObject<JetCollection>(*iter); 
        bool hasMatch = false; 
        if(matchingChains && matchingChains->size() > 0) { 
          for(std::vector<std::string>::const_iterator chainIter = matchingChains->begin(); 
              chainIter != matchingChains->end(); ++chainIter) { 
            logme << INFO << "chain is " << *chainIter << SLogger::endmsg; 
            // we're only interested in EF items, so lets skip the others 
            if(chainIter->find("EF_") == std::string::npos) 
	      continue; 

            const JetCollection *match =  
              tmt->matchToTriggerObject<JetCollection>(*iter, *chainIter, true); 
            if (match) { 
              hasMatch = true; 
              logme << INFO << "we have a match!!!" << SLogger::endmsg;
	      
              logme << INFO << "ef match in item " << *chainIter << " with eta, phi, pt "  
                    << match->eta() << " " << match->phi() << " "  
                    << match->pt() << SLogger::endmsg; 
            } 
	      
	      if (match && (*chainIter == "EF_Jet_V2")) {
	      logme << INFO << "we have a match with EF_Jet_V2!" << SLogger::endmsg;
	      }
	    }
	  }
	}
      }
    }
  }
	*/

  /*
  if(tmt) {
    
    //Retrieve jets and electrons
    const Analysis::MuonContainer *muonsbr(0);
    dataStore.retrieve(muonsbr,m_muonsFromName);
    
    if(muonsbr) {
    // loop through reconstructed muons, and print out trigger information
    for(Analysis::MuonContainer::const_iterator iter = muonsbr->begin();
        iter != muonsbr->end(); ++iter) {

      // print the info for the muon
      logme << INFO << SLogger::endmsg;
      logme << INFO << "Have reconstructed muon with eta, phi, pt: "
        << (*iter)->eta() << ", " << (*iter)->phi() << ", " << (*iter)->pt() << SLogger::endmsg;

      // print the matching chains
      std::vector<std::string> *matchingChains = tmt->chainsPassedByObject<MuonFeature>(*iter);

      if(matchingChains && matchingChains->size() > 0) {
        logme << INFO << "Matches to objects:" << SLogger::endmsg;
        for(std::vector<std::string>::const_iterator chainIter = matchingChains->begin();
            chainIter != matchingChains->end(); ++chainIter) {
          const MuonFeature *match = tmt->matchToTriggerObject<MuonFeature>(*iter, *chainIter, true);
          // Note that if we would like the distance to the best match, we can simply call
          // float dist = m_matchTool->distance(*iter, match);
          logme << INFO << "L2 match in chain " << *chainIter << " with eta, phi, pt: "
            << match->eta() << ", " << match->phi() << ", " << match->pt() << SLogger::endmsg;
        }
      }
      else
        logme << INFO << "Does not match to trigger" << SLogger::endmsg;

      delete matchingChains;
    }

    }

    //Retrieve jets
  //    JetCollection *jetsbr(0);
  //  dataStore.retrieve(jetsbr,m_jetsFromName);

    if(jetsbr) {
      // loop through reconstructed jets, and print out trigger information
      for(JetCollection::const_iterator iter = jetsbr->begin();
          iter != jetsbr->end(); ++iter) {

        // print the info for the jet
        //logme << INFO << SLogger::endmsg;
        logme << VERBOSE << "Have reconstructed jet with eta, phi, pt: "
          << (*iter)->eta() << ", " << (*iter)->phi() << ", " << (*iter)->pt() << SLogger::endmsg;
      }
    }	
        // print the matching chains
        std::vector<std::string> *matchingChains
          = tmt->chainsPassedByObject<TrigT2Jet>(*iter);

        if(matchingChains && matchingChains->size() > 0) {
          logme << VERBOSE << "Matches to objects:" << SLogger::endmsg;
          for(std::vector<std::string>::const_iterator chainIter = matchingChains->begin();
              chainIter != matchingChains->end(); ++chainIter) {
            const TrigT2Jet *match = tmt->matchToTriggerObject<TrigT2Jet>(*iter, *chainIter, true);
            // Note that if we would like the distance to the best match, we can simply call
            // float dist = tmt->distance(*iter, match);
            logme << INFO << "L2 match in chain " << *chainIter << " with eta, phi, et: "
              << match->eta() << ", " << match->phi() << ", " << match->et() << SLogger::endmsg;
          }
        }
        else
          logme << VERBOSE << "Does not match to trigger" << SLogger::endmsg;

        if(matchingChains) { delete matchingChains; }
      } // for
    } // if jetsbr
  } // if tmt

	*/
  bool retval = false;

  
  // how to use trigger decision and call methods
  if(tdt) {  
    
    // use of isPassed()
    logme << VERBOSE << " tdt->isPassed( " << m_EFNames[0] << ") = \t" << tdt->isPassed(m_EFNames[0]) << SLogger::endmsg; 

    // use of chains
    const Trig::ChainGroup* m_allEFMuons = tdt->getChainGroup(m_chainGrp.c_str());
    if(m_allEFMuons) {
      std::vector<std::string> tnVec = m_allEFMuons->getListOfTriggers();
      std::vector<std::string>::iterator tnItr = tnVec.begin();
      logme << INFO << " Got all chains matching " << m_chainGrp << SLogger::endmsg;
      for (; tnItr!=tnVec.end(); ++tnItr) {
        bool isPassed = tdt->isPassed(*tnItr);
        logme << INFO << *tnItr << " passed ? " << isPassed << SLogger::endmsg; 
      }
    }
    bool hasPassed = false;
    if(m_allEFMuons) hasPassed = m_allEFMuons->isPassed();

    // this is the actual stuff for top analysis
    bool m_passL12EF = true, m_L1Pass = false, m_L2Pass = false, m_L3Pass = false;

    if(m_reqLevel1) { m_L1Pass = TrigFired(m_L1Names, tdt, m_passAnyTrig); m_passL12EF = m_passL12EF && m_L1Pass; }
    if(m_reqLevel2) { m_L2Pass = TrigFired(m_L2Names, tdt, m_passAnyTrig); m_passL12EF = m_passL12EF && m_L2Pass; }
    if(m_reqLevel3) { m_L3Pass = TrigFired(m_EFNames, tdt, m_passAnyTrig); m_passL12EF = m_passL12EF && m_L3Pass; }


    if(m_passAnyLevel && ( (m_L3Pass && m_reqLevel3) || 
          (m_L2Pass && m_reqLevel2) || (m_L1Pass && m_reqLevel1)) ) retval = true; 
    else if(!m_passAnyLevel && m_passL12EF) retval = true;
    else retval = false;
    
  }  
  else {
    logme << DEBUG << "Could not retrieve trigger decision tool " << SLogger::endmsg;
  }
  return retval;
}

void HLTJetMET::MakeEfficiencyHists() 
{
  // h1611->Divide(h1511,h205,1.,1.,"B");
  m_reco_jet_pt_l2_eff->Divide(m_reco_jet_pt_l2_num,m_reco_jet_pt_den,1.,1.,"B");
  m_reco_jet_eta_l2_eff->Divide(m_reco_jet_eta_l2_num,m_reco_jet_eta_den,1.,1.,"B");
  m_reco_jet_phi_l2_eff->Divide(m_reco_jet_phi_l2_num,m_reco_jet_phi_den,1.,1.,"B");

}

bool HLTJetMET::TrigFired(std::vector<std::string>& trigger_names, Trig::TrigDecisionToolARA *tdt, bool m_anytrig) {

  for (std::vector<std::string>::iterator trigname = trigger_names.begin(); trigname != trigger_names.end(); ++trigname) {
    bool m_hasPassed = tdt->isPassed(*trigname);
    if (m_hasPassed) {
      if(m_anytrig) return true;
    } else {
      if(!m_anytrig) return false;
    }
  }
  return m_anytrig ? false : true;
}