HbbAnalysis/plugins/HbbAnalyzer.cc

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/Common/interface/HLTenums.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/HLTReco/interface/TriggerEvent.h"

#include "DataFormats/PatCandidates/interface/Lepton.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/PatCandidates/interface/Electron.h"
#include "DataFormats/PatCandidates/interface/Tau.h"
#include "DataFormats/PatCandidates/interface/Jet.h"
#include "DataFormats/PatCandidates/interface/MET.h"

#include "FWCore/ServiceRegistry/interface/Service.h"

#include "CommonTools/UtilAlgos/interface/TFileService.h"


#include "UserCode/HbbAnalysis/plugins/HbbAnalyzer.hh"

using namespace HbbAnalysis;

HbbAnalyzer::HbbAnalyzer(const edm::ParameterSet & pset):
  debug_(pset.getParameter<int>("DEBUG")),
  flavour_(pset.getParameter<unsigned int>("JetFlavour")),
  jetLeptonIsolation_(pset.getParameter<double>("JetLeptonDeltaRCut")),
  doElectrons_(pset.getParameter<bool>("DoElectrons")),
  doMuons_(pset.getParameter<bool>("DoMuons")),
  doTaus_(pset.getParameter<bool>("DoTaus")),
  doJets_(pset.getParameter<bool>("DoJets")),
  doMETs_(pset.getParameter<bool>("DoMETs")),
  doPairs_(pset.getParameter<bool>("DoPairs")),
  //doLepLepPairs_(pset.getParameter<bool>("DoLepLepPairs")),
  genParticleSrc_(pset.getParameter<edm::InputTag>("GenParticles")),
  electronSrc_(pset.getParameter<edm::InputTag>("Electrons")),
  muonSrc_(pset.getParameter<edm::InputTag>("Muons")),
  //caloTauSrc_(pset.getParameter<edm::InputTag>("CaloTaus")),
  tauSrc_(pset.getParameter<edm::InputTag>("Taus")),
  jetSrc_(pset.getParameter<edm::InputTag>("Jets")),
  //jptjetSrc_(pset.getParameter<edm::InputTag>("JPTJets")),
  //pfjetSrc_(pset.getParameter<edm::InputTag>("PFJets")),
  metSrc_(pset.getParameter<edm::InputTag>("MET")),
  //tcMetSrc_(pset.getParameter<edm::InputTag>("TCMET")),
  //pfMetSrc_(pset.getParameter<edm::InputTag>("PFMET")),
  pairSrc_(pset.getParameter<edm::InputTag>("Pair")),
  //mmPairSrc_(pset.getParameter<edm::InputTag>("MuMuPair")),
  //etPairSrc_(pset.getParameter<edm::InputTag>("ETauPair")),
  //mtPairSrc_(pset.getParameter<edm::InputTag>("MuTauPair")),
  vertexSrc_(pset.getParameter<edm::InputTag>("Vertex")),
  triggerSrc_(pset.getParameter<edm::InputTag>("Trigger")),
  hltPaths_(pset.getParameter<std::vector<std::string> >("HLTPaths"))
  //file_(0),
  //processVec_(pset.getParameter<std::vector<std::string> >("ProcessVec"))
{//constructor

  //file_ = TFile::Open(pset.getUntrackedParameter<std::string>("OutputFile","MuTauAnalysis.root").c_str(),"RECREATE");
  //if (!file_) {
  //  std::cerr << "### Failed opening output file, please check configuration parameter. Exiting ..." << std::endl;
  //  exit(0);
  //}
  //else std::cout << "***** File : " << file_->GetName() << " successfully opened." << std::endl;


}//constructor

HbbAnalyzer::~HbbAnalyzer(){//destructor
  //file_->Close();
}//destructor


void HbbAnalyzer::beginJob(){//beginJob


  edm::Service<TFileService> lFileService;

  TFileDirectory lDir = lFileService->mkdir("Dummy");
  TFileDirectory lSubDir = lDir.mkdir("Dummy");
  TFileDirectory lSubSubDir = lSubDir.mkdir("Dummy");
  TFileDirectory lSubSubSubDir = lSubSubDir.mkdir("Dummy");

  if (doJets_){
    if (debug_) std::cout << "Initialising JetFlavour : " << std::endl;

    lDir = lFileService->mkdir("JetFlavours");

    jetFlav_.Initialise(lDir, debug_, flavour_);
  }

  if (doElectrons_){
    if (debug_) std::cout << "Initialising electrons histograms : " << std::endl;

    lDir = lFileService->mkdir("Electrons");

    lSubDir = lDir.mkdir("All");

    lSubSubDir = lSubDir.mkdir("Leading");
    ElecHistLead_.Initialise(lSubSubDir,"Electrons");
    lSubSubSubDir = lSubSubDir.mkdir( "GenMatched" );
    ElecHistLeadGenMatched_.Initialise(lSubSubSubDir,"Electrons",true);

    lSubSubDir = lSubDir.mkdir("NextToLeading");
    ElecHistNtoLead_.Initialise(lSubSubDir,"Electrons");
    lSubSubSubDir = lSubSubDir.mkdir( "GenMatched" );
    ElecHistNtoLeadGenMatched_.Initialise(lSubSubSubDir,"Electrons",true);

    lSubDir = lDir.mkdir("Barrel");
    
    lSubSubDir = lSubDir.mkdir("Leading");
    ElecHistBarrelLead_.Initialise(lSubSubDir,"Electrons");
    lSubSubSubDir = lSubSubDir.mkdir( "GenMatched" );
    ElecHistBarrelLeadGenMatched_.Initialise(lSubSubSubDir,"Electrons",true);

    lSubSubDir = lSubDir.mkdir("NextToLeading");
    ElecHistBarrelNtoLead_.Initialise(lSubSubDir,"Electrons");
    lSubSubSubDir = lSubSubDir.mkdir( "GenMatched" );
    ElecHistBarrelNtoLeadGenMatched_.Initialise(lSubSubSubDir,"Electrons",true);

    lSubDir = lDir.mkdir("EndCap");

    lSubSubDir = lSubDir.mkdir("Leading");
    ElecHistEndCapLead_.Initialise(lSubSubDir,"Electrons");
    lSubSubSubDir = lSubSubDir.mkdir( "GenMatched" );
    ElecHistEndCapLeadGenMatched_.Initialise(lSubSubSubDir,"Electrons",true);

    lSubSubDir = lSubDir.mkdir("NextToLeading");
    ElecHistEndCapNtoLead_.Initialise(lSubSubDir,"Electrons");
    lSubSubSubDir = lSubSubDir.mkdir( "GenMatched" );
    ElecHistEndCapNtoLeadGenMatched_.Initialise(lSubSubSubDir,"Electrons",true);
  }

  if (doMuons_){
    if (debug_) std::cout << "Initialising muons histograms : " << std::endl;

    lDir = lFileService->mkdir( "Muons" );

    lSubDir = lDir.mkdir("Leading");
    MuHistLead_.Initialise(lSubDir,"Muons");
    lSubSubDir = lSubDir.mkdir( "GenMatched" );
    MuHistLeadGenMatched_.Initialise(lSubSubDir,"Muons",true);

    lSubDir = lDir.mkdir("NextToLeading");
    MuHistNtoLead_.Initialise(lSubDir,"Muons");
    lSubSubDir = lSubDir.mkdir( "GenMatched" );
    MuHistNtoLeadGenMatched_.Initialise(lSubSubDir,"Muons",true);
  }

  if (doTaus_){
    if (debug_) std::cout << "Initialising taus histograms : " << std::endl;

    lDir = lFileService->mkdir( "Taus" );
    TauHist_.Initialise(lDir,"Taus");
    lSubDir = lDir.mkdir( "GenMatched" );
    TauHistGenMatched_.Initialise(lSubDir,"GenMatchedTaus",true);

//     lDir = lFileService->mkdir( "PFTaus" );
//     PFTauHist_.Initialise(lDir,"PFTaus");
//     lSubDir = lDir.mkdir( "GenMatched" );
//     PFTauHistGenMatched_.Initialise(lSubDir,"GenMatchedTaus",true);
  }

  if (doJets_){
    if (debug_) std::cout << "Initialising jets histograms : " << std::endl;

    lDir = lFileService->mkdir( "Jets" );

    lSubDir = lDir.mkdir("All");
    JetHist_.Initialise(lSubDir,"Jets",debug_);
    lSubDir = lDir.mkdir("Leading");
    JetHistLead_.Initialise(lSubDir,"Jets",debug_);
    //lSubSubDir = lSubDir.mkdir( "GenMatched" );
    //JetHistLeadGenMatched_.Initialise(lSubSubDir,"Jets",true);


    lSubDir = lDir.mkdir("NextToLeading");
    JetHistNtoLead_.Initialise(lSubDir,"Jets",debug_);
    //lSubSubDir = lSubDir.mkdir( "GenMatched" );
    //JetHistNtoLeadGenMatched_.Initialise(lSubSubDir,"Jets",true);


//     lDir = lFileService->mkdir( "PFJets" );
    
//     lSubDir = lDir.mkdir("All");
//     PFJetHist_.Initialise(lSubDir,"Jets",debug_);
//     lSubDir = lDir.mkdir("Leading");
//     PFJetHistLead_.Initialise(lSubDir,"PFJets",debug_);
//     lSubDir = lDir.mkdir("NextToLeading");
//     PFJetHistNtoLead_.Initialise(lSubDir,"PFJets",debug_);

//     lDir = lFileService->mkdir( "JPTJets" );

//     lSubDir = lDir.mkdir("All");
//     JPTJetHist_.Initialise(lSubDir,"Jets",debug_);
//     lSubDir = lDir.mkdir("Leading");
//     JPTJetHistLead_.Initialise(lSubDir,"JPTJets",debug_);
//     lSubDir = lDir.mkdir("NextToLeading");
//     JPTJetHistNtoLead_.Initialise(lSubDir,"JPTJets",debug_);
  }


  if (doPairs_){
    lDir = lFileService->mkdir("Pairs");
    if (debug_) std::cout << "Initialising pairs histograms : " << std::endl;

    lSubDir = lDir.mkdir("All");
    PairHist_.Initialise(lSubDir,"Pairs",debug_);

    lSubDir = lDir.mkdir("Leading");
    PairHistLead_.Initialise(lSubDir,"Pairs",debug_);
  }

//   if (doLepTauPairs_){
//     lSubDir = lDir.mkdir("etau");
//     ETPairHist_.Initialise(lSubDir,"Pairs",debug_);

//     lSubDir = lDir.mkdir("mutau");
//     MTPairHist_.Initialise(lSubDir,"Pairs",debug_);
//   }

  if (doMETs_){
    if (debug_) std::cout << "Initialising METs histograms : " << std::endl;

    lDir = lFileService->mkdir("MET");
    //lSubDir = lDir.mkdir("CaloMET");
    MetHist_.Initialise(lDir,"MET",debug_);

//     lSubDir = lDir.mkdir("PFMET");
//     PFMetHist_.Initialise(lSubDir,"MET",debug_);

//     lSubDir = lDir.mkdir("TcMET");
//     TcMetHist_.Initialise(lSubDir,"MET",debug_);
  }

}//beginJob

void HbbAnalyzer::endJob(){//endJob

  if (doElectrons_){
    ElecHistLead_.FillEffHistograms();
    ElecHistLeadGenMatched_.FillEffHistograms();

    ElecHistNtoLead_.FillEffHistograms();
    ElecHistNtoLeadGenMatched_.FillEffHistograms();

    ElecHistBarrelLead_.FillEffHistograms();
    ElecHistBarrelLeadGenMatched_.FillEffHistograms();

    ElecHistBarrelNtoLead_.FillEffHistograms();
    ElecHistBarrelNtoLeadGenMatched_.FillEffHistograms();

    ElecHistEndCapLead_.FillEffHistograms();
    ElecHistEndCapLeadGenMatched_.FillEffHistograms();

    ElecHistEndCapNtoLead_.FillEffHistograms();
    ElecHistEndCapNtoLeadGenMatched_.FillEffHistograms();
  }

  if (doMuons_){
    MuHistLead_.FillEffHistograms();
    MuHistLeadGenMatched_.FillEffHistograms();

    MuHistNtoLead_.FillEffHistograms();
    MuHistNtoLeadGenMatched_.FillEffHistograms();
  }

  if (doJets_){
    jetFlav_.printSummary();
    //JetHistLead_.FillEffHistograms();
    //JetHistLeadGenMatched_.FillEffHistograms();

    //JetHistNtoLead_.FillEffHistograms();
    //JetHistNtoLeadGenMatched_.FillEffHistograms();


  }

}//endJob

void HbbAnalyzer::analyze(const edm::Event& aEvt, const edm::EventSetup& aEvtSetup){//analyze

  //dumpContent(aEvt,"","MuTauPAT");

  static bool firstEvent = true;


  edm::Handle<reco::GenParticleCollection> lGenParticles;
  try {
    aEvt.getByLabel(genParticleSrc_,lGenParticles);  
    if (debug_) std::cout << "** ngenParticles = " << lGenParticles->size() << std::endl;
  } catch(cms::Exception& e)  {
    std::cout << "AMM: Collection genParticles not available! Exception : " << e.what() << ". " << std::endl;
  }

  unsigned int lNPartons = 0;

  if (doJets_){
    lNPartons = jetFlav_.fillPartons(lGenParticles);
  }

  if (debug_) std::cout << "--- Number of partons = " << lNPartons << " (doJets=" << doJets_ << ")." << std::endl;


  edm::Handle<std::vector<reco::Vertex> > lRecoVertices;
  try {
    aEvt.getByLabel(vertexSrc_, lRecoVertices);
    if (!lRecoVertices.isValid()){
      edm::LogInfo("ERROR")<< "Error! Can't get vertex by label. ";
    }
    if (debug_) std::cout << "** vertexcollection = " << lRecoVertices->size() << " elements." << std::endl;
  } catch(cms::Exception& e)  {
    std::cout << "AMM: Collection " << vertexSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
  }


  edm::Handle<std::vector<pat::Electron> > lElectronCollection;

  if (doElectrons_ || doJets_){
    try {
      aEvt.getByLabel(electronSrc_,lElectronCollection);
      if (!lElectronCollection.isValid()){
        edm::LogInfo("ERROR")<< "Error! Can't get electron by label. ";
      } 
      if (debug_) std::cout << "** electroncollection = " << lElectronCollection->size() << " elements." << std::endl;
    } catch(cms::Exception& e)  {
      std::cout << "AMM: Collection " << electronSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
    }
    if (lElectronCollection.isValid() && doElectrons_){

      ElecHistLead_.FillEventHistograms(lElectronCollection);
      ElecHistLeadGenMatched_.FillEventHistograms(lElectronCollection);

      ElecHistNtoLead_.FillEventHistograms(lElectronCollection);
      ElecHistNtoLeadGenMatched_.FillEventHistograms(lElectronCollection);

      if (lElectronCollection->size() > 0) {
        
        //std::vector<pat::Electron>::const_iterator iElectron = lElectronCollection->begin();
        unsigned int iEle = 0;
        for (std::vector<pat::Electron>::const_iterator iElectron = lElectronCollection->begin(); 
             iElectron != lElectronCollection->end(); 
             iElectron++) 
          {
            //if (debug_ > 1) std::cout << "pT,eta,phi =  " << (*iElectron).pt() << " " << (*iElectron).eta() << " " << (*iElectron).phi() << std::endl;
            if (iEle == 0) {
              ElecHistLead_.FillHistograms(*iElectron,lRecoVertices);
              ElecHistLeadGenMatched_.FillHistograms(*iElectron,lRecoVertices);
              if (fabs((*iElectron).eta())<1.47) {
                ElecHistBarrelLead_.FillHistograms(*iElectron,lRecoVertices);
                ElecHistBarrelLeadGenMatched_.FillHistograms(*iElectron,lRecoVertices);
              }
              else {
                ElecHistEndCapLead_.FillHistograms(*iElectron,lRecoVertices);
                ElecHistEndCapLeadGenMatched_.FillHistograms(*iElectron,lRecoVertices);
              }
            }
            else if (iEle == 1){
              ElecHistNtoLead_.FillHistograms(*iElectron,lRecoVertices);
              ElecHistNtoLeadGenMatched_.FillHistograms(*iElectron,lRecoVertices);
              if (fabs((*iElectron).eta())<1.47) {
                ElecHistBarrelNtoLead_.FillHistograms(*iElectron,lRecoVertices);
                ElecHistBarrelNtoLeadGenMatched_.FillHistograms(*iElectron,lRecoVertices);
              }
              else {
                ElecHistEndCapNtoLead_.FillHistograms(*iElectron,lRecoVertices);
                ElecHistEndCapNtoLeadGenMatched_.FillHistograms(*iElectron,lRecoVertices);
              }
            }
            iEle++;      
          }
      }
    }
  }//if doElec or doJets

  edm::Handle<std::vector<pat::Muon> > lMuonCollection;
  if (doMuons_ || doJets_){
    try {
      aEvt.getByLabel(muonSrc_,lMuonCollection);
      if (!lMuonCollection.isValid()){
        edm::LogInfo("ERROR")<< "Error! Can't get muon by label. ";
      } 
      if (debug_) std::cout << "** muoncollection = " << lMuonCollection->size() << " elements." << std::endl;
    } catch(cms::Exception& e)  {
      std::cout << "AMM: Collection " << muonSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
    }
    if (lMuonCollection.isValid() && doMuons_){

      MuHistLead_.FillEventHistograms(lMuonCollection);
      MuHistLeadGenMatched_.FillEventHistograms(lMuonCollection);

      MuHistNtoLead_.FillEventHistograms(lMuonCollection);
      MuHistNtoLeadGenMatched_.FillEventHistograms(lMuonCollection);

      if (lMuonCollection->size() > 0) {
        
        //std::vector<pat::Muon>::const_iterator iMuon = lMuonCollection->begin();
        unsigned int iMu = 0;
        for (std::vector<pat::Muon>::const_iterator iMuon = lMuonCollection->begin(); 
             iMuon != lMuonCollection->end(); 
             iMuon++) 
          {
            //if (debug_ > 1) std::cout << "pT,eta,phi =  " << (*iMuon).pt() << " " << (*iMuon).eta() << " " << (*iMuon).phi() << std::endl;
            if (iMu == 0) {
              MuHistLead_.FillHistograms(*iMuon,lRecoVertices);
              MuHistLeadGenMatched_.FillHistograms(*iMuon,lRecoVertices);
            }
            else if (iMu == 1){
              MuHistNtoLead_.FillHistograms(*iMuon,lRecoVertices);
              MuHistNtoLeadGenMatched_.FillHistograms(*iMuon,lRecoVertices);
            }
            iMu++;
          }
      }
    }
  }


  edm::Handle<std::vector<pat::Tau> > lTauCollection;
  if (doTaus_ || doJets_){
    try {
      aEvt.getByLabel(tauSrc_,lTauCollection);
      if (!lTauCollection.isValid()){
        edm::LogInfo("ERROR")<< "Error! Can't get Tau by label. ";
      } 
      if (debug_) std::cout << "** Taucollection = " << lTauCollection->size() << " elements." << std::endl;
    } catch(cms::Exception& e)  {
      std::cout << "AMM: Collection " << tauSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
    }
    if (lTauCollection.isValid() && doTaus_){

      TauHist_.FillEventHistograms(lTauCollection);
      TauHistGenMatched_.FillEventHistograms(lTauCollection);

      if (lTauCollection->size() > 0) {
        
        bool isLead = true;
        //std::vector<pat::Tau>::const_iterator iTau = lTauCollection->begin();
        for (std::vector<pat::Tau>::const_iterator iTau = lTauCollection->begin(); 
             iTau != lTauCollection->end(); 
             iTau++) 
          {
            //if (debug_ > 1) std::cout << "pT,eta,phi = " << (*iTau).pt() << " " << (*iTau).eta() << " " << (*iTau).phi() << std::endl;
            TauHist_.FillHistograms(*iTau,lRecoVertices,isLead);
            TauHistGenMatched_.FillHistograms(*iTau,lRecoVertices,isLead);
            isLead = false;
          }   
      }
    }
  }


  edm::Handle<std::vector<pat::Jet> > lJetCollection;
  
  if (doJets_){
    try {
      aEvt.getByLabel(jetSrc_,lJetCollection);
      if (!lJetCollection.isValid()){
        edm::LogInfo("ERROR")<< "Error! Can't get jet by label. ";
      } 
      if (debug_) std::cout << "** jetcollection = " << lJetCollection->size() << " elements." << std::endl;
    } catch(cms::Exception& e)  {
      std::cout << "AMM: Collection " << jetSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
    }
    if (lJetCollection.isValid()){

      JetHist_.FillEventHistograms(lJetCollection,jetFlav_);
      JetHistLead_.FillEventHistograms(lJetCollection,jetFlav_);
      JetHistNtoLead_.FillEventHistograms(lJetCollection,jetFlav_);
      //JetHistLeadGenMatched_.FillEventHistograms(lJetCollection,jetFlav_);
      //JetHistNtoLeadGenMatched_.FillEventHistograms(lJetCollection,jetFlav_);

      if (lJetCollection->size() > 0) {
        
        //std::vector<pat::Jet>::const_iterator iJet = lJetCollection->begin();
        unsigned int ij = 0;
        for (std::vector<pat::Jet>::const_iterator iJet = lJetCollection->begin(); 
             iJet != lJetCollection->end(); 
             iJet++) 
          {
            double lDeltaRele = deltaRwithLepton<pat::Electron>(*iJet,lElectronCollection);
            double lDeltaRmu = deltaRwithLepton<pat::Muon>(*iJet,lMuonCollection);
            double lDeltaRtau = deltaRwithLepton<pat::Tau>(*iJet,lTauCollection);
  
            JetHist_.FillIsolationHistograms(lDeltaRele,lDeltaRmu,lDeltaRtau);

            if (debug_ > 1) std::cout << "Jet #" << ij << ": pT,eta,phi =  " << (*iJet).pt() << " " << (*iJet).eta() << " " << (*iJet).phi() << std::endl;
            JetHist_.FillHistograms(*iJet,lGenParticles);
            if (ij == 0) {
              JetHistLead_.FillHistograms(*iJet,lGenParticles);
              //JetHistLeadGenMatched_.FillHistograms(*iJet,lGenParticles);
            }
            else if (ij == 1) {
              JetHistNtoLead_.FillHistograms(*iJet,lGenParticles);
              //JetHistNtoLeadGenMatched_.FillHistograms(*iJet,lGenParticles);
            }
            ij++;
          
          }
      }
    }

  }//if doJets_


//   edm::Handle<std::vector<CompositePtrCandidateT1T2MEt<reco::Candidate, reco::Candidate> > > lPair;
//   //edm::Handle<std::vector<CompositePtrCandidateT1T2MEt<reco::Candidate, reco::Candidate> > > lmmPair;

//   if (doPairs_){
//     try {
//       aEvt.getByLabel(pairSrc_,lPair);
//       if (!lPair.isValid()){
//      edm::LogInfo("ERROR")<< "Error! Can't get  pairs by label. ";
//       } 
//       if (debug_) std::cout << "** Pairs  = " << lPair->size() << " elements." << std::endl;
//     } catch(cms::Exception& e)  {
//       std::cout << "AMM: Collection " << pairSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
//     }
//     if (lPair.isValid()){

//       PairHist_.FillEventHistograms(lPair);
//       PairHistLead_.FillEventHistograms(lPair);

//       if (lPair->size() > 0) {
//      bool isLead = true;
//      for (std::vector<CompositePtrCandidateT1T2MEt<reco::Candidate, reco::Candidate> >::const_iterator iP = lPair->begin(); 
//           iP != lPair->end(); 
//           iP++) 
//        {
//          PairHist_.FillHistograms(*iP);
//          if (isLead) PairHistLead_.FillHistograms(*iP);
//          isLead = false;
//        }
//       }
//     }

//   }//if doPairs_


  edm::Handle<std::vector<pat::MET> > lMetCol;

  if (doMETs_){
    try {
      aEvt.getByLabel(metSrc_,lMetCol);
      if (!lMetCol.isValid()){
        edm::LogInfo("ERROR")<< "Error! Can't get Met by label. ";
      } 
      if (debug_) std::cout << "** Met  = " << lMetCol->size() << " elements." << std::endl;
    } catch(cms::Exception& e)  {
      std::cout << "AMM: Collection " << metSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
    }
    if (lMetCol.isValid()){

      MetHist_.FillEventHistograms(lMetCol);
    }

  }//if doMETs_


//   //triggers
//   edm::Handle<edm::TriggerResults> lTrigCol;
//   try {
//     aEvt.getByLabel(triggerSrc_,lTrigCol);
//     if (!lTrigCol.isValid()){
//       edm::LogInfo("ERROR")<< "Error! Can't get triggers by label. ";
//     } 
//     if (debug_) std::cout << "** triggers = " << lTrigCol->size() << std::endl;
//   } catch(cms::Exception& e)  {
//     std::cout << "AMM: Collection " << triggerSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
//   }
//   if (lTrigCol.isValid()){
//     edm::TriggerNames lNames;
//     lNames.init(*lTrigCol);

//     for (unsigned int j=0; j<hltPaths_.size(); j++) {
//       bool valid=false;
//       for (unsigned int i=0; i<lTrigCol->size(); i++){
//      std::string trueName = lNames_.triggerNames().at(i);
//      //if (debug_ && j==0) std::cout << " Trigger #" << i << ", name = " << trueName << std::endl;
//      if (trueName.find(hltPaths_.at(j)) != trueName.npos){
//        //HLTPathsByIndex_[j]=triggerNames_.triggerIndex(HLTPathsByName_[j]);
//        if (debug_) std::cout << "Trigger: " << trueName << " is valid. Index = " << i << std::endl;
//        //triggerCol->accept(HLTPathsByIndex_[j]);
//        valid=true;
//        break;
//      }
//       }
//       if (!valid) {
//      std::cout << "*WARNING* Trigger: " << hltPaths_.at(j) << " is invalid." << std::endl;
//       }
//     }

//   }

  firstEvent = false;

}//analyze


void HbbAnalyzer::dumpContent(const edm::Event& aEvt, 
                              std::string aName, 
                              std::string aProcess
                              )
{//dumpContent
  //to dump the content of the event

  typedef std::vector< edm::Provenance const*> Provenances;
  Provenances lProvenances;
  aEvt.getAllProvenance(lProvenances);

  for(Provenances::iterator itProv = lProvenances.begin(), itProvEnd = lProvenances.end();
      itProv != itProvEnd;
      ++itProv) {

    std::string lName = (*itProv)->friendlyClassName();
    std::string lModLabel = (*itProv)->moduleLabel();
    std::string lInstanceName = (*itProv)->productInstanceName();
    std::string lProcessName = (*itProv)->processName();

    //std::cout << " - friendlyName = " << lName << std::endl;
    if (lName.find(aName) != lName.npos && lProcessName.find(aProcess) != lProcessName.npos) {
      
      //if (debug_>1) {
      std::cout << " -- Object type = " << lName << std::endl
                << " ----- Module = " << lModLabel << std::endl
                << " ----- Instance = " << lInstanceName << std::endl;
      //<< " ----- Process = " << lProcessName << std::endl;
      //}
    }
  }
}//dumpContent


#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(HbbAnalyzer);


Revision:	1.15
Committed:	Thu Mar 4 15:17:42 2010 UTC (15 years, 2 months ago) by amagnan
Content type:	text/plain
Branch:	MAIN
CVS Tags:	v00-05-00, HbbAnaFor35X, v00-04-02, v00-04-01, v00-04-00
Changes since 1.14:	+3 -2 lines
Log Message:	update beginJob and TFileService from CommonTools