/data/refman/pasoursint/CMSSW_5_2_9/src/RecoEgamma/Examples/plugins/PatPhotonSimpleAnalyzer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    PatPhotonSimpleAnalyzer
// Class:      PatPhotonSimpleAnalyzer
//
//
// Original Author:  M.B. Anderson
//   based on simple photon analyzer by:  J. Stilley, A. Askew
//
//         Created:  Wed Sep 23 12:00:01 CDT 2008
//
//                    header file for this analyzer                  //
#include "RecoEgamma/Examples/plugins/PatPhotonSimpleAnalyzer.h"

//                        CMSSW includes                             //
#include "DataFormats/Common/interface/View.h"
#include "DataFormats/PatCandidates/interface/Photon.h"

//                      Root include files                           //
#include "TH1.h"
#include "TFile.h"
#include "TMath.h"
#include "TTree.h"

using namespace std;

//                           Constructor                             //
PatPhotonSimpleAnalyzer::PatPhotonSimpleAnalyzer(const edm::ParameterSet& ps)
{
  // Read Parameters from configuration file

  // output filename
  outputFile_   = ps.getParameter<std::string>("outputFile");
  // Read variables that must be passed to allow a
  //  supercluster to be placed in histograms as a photon.
  minPhotonEt_     = ps.getParameter<double>("minPhotonEt");
  minPhotonAbsEta_ = ps.getParameter<double>("minPhotonAbsEta");
  maxPhotonAbsEta_ = ps.getParameter<double>("maxPhotonAbsEta");
  minPhotonR9_     = ps.getParameter<double>("minPhotonR9");
  maxPhotonHoverE_ = ps.getParameter<double>("maxPhotonHoverE");

  // Read variable to that decidedes whether
  // a TTree of photons is created or not
  createPhotonTTree_ = ps.getParameter<bool>("createPhotonTTree");

  // open output file to store histograms
  rootFile_ = TFile::Open(outputFile_.c_str(),"RECREATE");
}

//                            Destructor                             //
PatPhotonSimpleAnalyzer::~PatPhotonSimpleAnalyzer()
{

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

  delete rootFile_;

}

//    method called once each job just before starting event loop    //
void
PatPhotonSimpleAnalyzer::beginJob()
{

  // go to *OUR* rootfile
  rootFile_->cd();

  // Book Histograms
  // PhotonID Histograms
  h_isoEcalRecHit_ = new TH1F("photonEcalIso",          "Ecal Rec Hit Isolation", 100, 0, 100);
  h_isoHcalRecHit_ = new TH1F("photonHcalIso",          "Hcal Rec Hit Isolation", 100, 0, 100);
  h_trk_pt_solid_  = new TH1F("photonTrackSolidIso",    "Sum of track pT in a cone of #DeltaR" , 100, 0, 100);
  h_trk_pt_hollow_ = new TH1F("photonTrackHollowIso",   "Sum of track pT in a hollow cone" ,     100, 0, 100);
  h_ntrk_solid_    = new TH1F("photonTrackCountSolid",  "Number of tracks in a cone of #DeltaR", 100, 0, 100);
  h_ntrk_hollow_   = new TH1F("photonTrackCountHollow", "Number of tracks in a hollow cone",     100, 0, 100);
  h_ebgap_         = new TH1F("photonInEBgap",          "Ecal Barrel gap flag",  2, -0.5, 1.5);
  h_eeGap_         = new TH1F("photonInEEgap",          "Ecal Endcap gap flag",  2, -0.5, 1.5);
  h_ebeeGap_       = new TH1F("photonInEEgap",          "Ecal Barrel/Endcap gap flag",  2, -0.5, 1.5);
  h_r9_            = new TH1F("photonR9",               "R9 = E(3x3) / E(SuperCluster)", 300, 0, 3);

  // Photon Histograms
  h_photonEt_      = new TH1F("photonEt",     "Photon E_{T}",  200,  0, 200);
  h_photonEta_     = new TH1F("photonEta",    "Photon #eta",   200, -4,   4);
  h_photonPhi_     = new TH1F("photonPhi",    "Photon #phi",   200, -1.*TMath::Pi(), TMath::Pi());
  h_hadoverem_     = new TH1F("photonHoverE", "Hadronic over EM", 200, 0, 1);

  // Photon's SuperCluster Histograms
  h_photonScEt_       = new TH1F("photonScEt",  "Photon SuperCluster E_{T}", 200,  0, 200);
  h_photonScEta_      = new TH1F("photonScEta", "Photon #eta",               200, -4,   4);
  h_photonScPhi_      = new TH1F("photonScPhi", "Photon #phi", 200, -1.*TMath::Pi(), TMath::Pi());
  h_photonScEtaWidth_ = new TH1F("photonScEtaWidth","#eta-width",            100,  0,  .1);

  // Composite or Other Histograms
  h_photonInAnyGap_   = new TH1F("photonInAnyGap",     "Photon in any gap flag",  2, -0.5, 1.5);
  h_nPassingPho_      = new TH1F("photonPassingCount", "Total number photons (0=NotPassing, 1=Passing)", 2, -0.5, 1.5);
  h_nPho_             = new TH1F("photonCount",        "Number of photons passing cuts in event",  10,  0,  10);

  // Create a TTree of photons if set to 'True' in config file
  if ( createPhotonTTree_ ) {
    tree_PhotonAll_     = new TTree("TreePhotonAll", "Reconstructed Photon");
    tree_PhotonAll_->Branch("recPhoton", &recPhoton.isolationEcalRecHit, "isolationEcalRecHit/F:isolationHcalRecHit:isolationSolidTrkCone:isolationHollowTrkCone:nTrkSolidCone:nTrkHollowCone:isEBGap:isEEGap:isEBEEGap:r9:et:eta:phi:hadronicOverEm:ecalIso:hcalIso:trackIso");
  }
}

//                method called to for each event                    //
void
PatPhotonSimpleAnalyzer::analyze(const edm::Event& evt, const edm::EventSetup& es)
{

  using namespace std;
  using namespace edm;

  // Grab pat::Photon
  Handle< View<pat::Photon> >  photonHandle;
  evt.getByLabel("selectedLayer1Photons", photonHandle);
  View<pat::Photon> photons = *photonHandle;

  int photonCounter = 0;

  for (int i=0; i<int(photons.size()); i++)
  {

    pat::Photon currentPhoton = photons.at(i);

    float photonEt       = currentPhoton.et();
    float superClusterEt = (currentPhoton.superCluster()->energy())/(cosh(currentPhoton.superCluster()->position().eta()));

    // Only store photon candidates (SuperClusters) that pass some simple cuts
    bool passCuts = (              photonEt > minPhotonEt_     ) &&
                    (      fabs(currentPhoton.eta()) > minPhotonAbsEta_ ) &&
                    (      fabs(currentPhoton.eta()) < maxPhotonAbsEta_ ) &&
                    (          currentPhoton.r9() > minPhotonR9_     ) &&
                    ( currentPhoton.hadronicOverEm() < maxPhotonHoverE_ ) ;

    if ( passCuts )
    {
      //                fill histograms                    //
      // PhotonID Variables
      h_isoEcalRecHit_->Fill(currentPhoton.ecalRecHitSumEtConeDR04());
      h_isoHcalRecHit_->Fill(currentPhoton.hcalTowerSumEtConeDR04());
      h_trk_pt_solid_ ->Fill(currentPhoton.trkSumPtSolidConeDR04());
      h_trk_pt_hollow_->Fill(currentPhoton.trkSumPtHollowConeDR04());
      h_ntrk_solid_->   Fill(currentPhoton.nTrkSolidConeDR04());
      h_ntrk_hollow_->  Fill(currentPhoton.nTrkHollowConeDR04());
      h_ebgap_->        Fill(currentPhoton.isEBGap());
      h_eeGap_->        Fill(currentPhoton.isEEGap());
      h_ebeeGap_->      Fill(currentPhoton.isEBEEGap());
      h_r9_->           Fill(currentPhoton.r9());

      // Photon Variables
      h_photonEt_->  Fill(photonEt);
      h_photonEta_-> Fill(currentPhoton.eta());
      h_photonPhi_-> Fill(currentPhoton.phi());
      h_hadoverem_-> Fill(currentPhoton.hadronicOverEm());

      // Photon's SuperCluster Variables
      // eta is with respect to detector (not physics) vertex,
      // thus Et and eta are different from photon.
      h_photonScEt_->      Fill(superClusterEt);
      h_photonScEta_->     Fill(currentPhoton.superCluster()->position().eta());
      h_photonScPhi_->     Fill(currentPhoton.superCluster()->position().phi());
      h_photonScEtaWidth_->Fill(currentPhoton.superCluster()->etaWidth());

      // It passed photon cuts, mark it
      h_nPassingPho_->Fill(1.0);

      //                fill TTree (optional)              //
      if ( createPhotonTTree_ ) {
        recPhoton.isolationEcalRecHit    = currentPhoton.ecalRecHitSumEtConeDR04();
        recPhoton.isolationHcalRecHit    = currentPhoton.hcalTowerSumEtConeDR04();
        recPhoton.isolationSolidTrkCone  = currentPhoton.trkSumPtSolidConeDR04();
        recPhoton.isolationHollowTrkCone = currentPhoton.trkSumPtHollowConeDR04();
        recPhoton.nTrkSolidCone          = currentPhoton.nTrkSolidConeDR04();
        recPhoton.nTrkHollowCone         = currentPhoton.nTrkHollowConeDR04();
        recPhoton.isEBGap                = currentPhoton.isEBGap();
        recPhoton.isEEGap                = currentPhoton.isEEGap();
        recPhoton.isEBEEGap              = currentPhoton.isEBEEGap();
        recPhoton.r9                     = currentPhoton.r9();
        recPhoton.et                     = currentPhoton.et();
        recPhoton.eta                    = currentPhoton.eta();
        recPhoton.phi                    = currentPhoton.phi();
        recPhoton.hadronicOverEm         = currentPhoton.hadronicOverEm();
        recPhoton.ecalIso                = currentPhoton.ecalIso();
        recPhoton.hcalIso                = currentPhoton.hcalIso();
        recPhoton.trackIso               = currentPhoton.trackIso();

        // Fill the tree (this records all the recPhoton.* since
        // tree_PhotonAll_ was set to point at that.
        tree_PhotonAll_->Fill();
      }

      // Record whether it was near any module gap.
      // Very convoluted at the moment.
      bool inAnyGap = currentPhoton.isEBEEGap() || (currentPhoton.isEB()&&currentPhoton.isEBGap()) || (currentPhoton.isEE()&&currentPhoton.isEEGap());
      if (inAnyGap) {
        h_photonInAnyGap_->Fill(1.0);
      } else {
        h_photonInAnyGap_->Fill(0.0);
      }

      photonCounter++;
    }
    else
    {
      // This didn't pass photon cuts, mark it
      h_nPassingPho_->Fill(0.0);
    }

  } // End Loop over photons
  h_nPho_->Fill(photonCounter);

}

//    method called once each job just after ending the event loop   //
void
PatPhotonSimpleAnalyzer::endJob()
{

  // go to *OUR* root file and store histograms
  rootFile_->cd();

  // PhotonID Histograms
  h_isoEcalRecHit_->Write();
  h_isoHcalRecHit_->Write();
  h_trk_pt_solid_-> Write();
  h_trk_pt_hollow_->Write();
  h_ntrk_solid_->   Write();
  h_ntrk_hollow_->  Write();
  h_ebgap_->     Write();
  h_eeGap_->     Write();
  h_ebeeGap_->   Write();
  h_r9_->        Write();

  // Photon Histograms
  h_photonEt_->  Write();
  h_photonEta_-> Write();
  h_photonPhi_-> Write();
  h_hadoverem_-> Write();

  // Photon's SuperCluster Histograms
  h_photonScEt_->      Write();
  h_photonScEta_->     Write();
  h_photonScPhi_->     Write();
  h_photonScEtaWidth_->Write();

  // Composite or Other Histograms
  h_photonInAnyGap_->Write();
  h_nPassingPho_->   Write();
  h_nPho_->          Write();

  // Write the root file (really writes the TTree)
  rootFile_->Write();
  rootFile_->Close();

}

//define this as a plug-in
// DEFINE_FWK_MODULE(PatPhotonSimpleAnalyzer);