Reference Manual

Go to the documentation of this file.
00001 #include "Validation/RecoMET/interface/METTester.h"
00002 // author: Mike Schmitt, University of Florida
00003 // first version 8/24/2006
00004 // modification: Bobby Scurlock
00005 // date:  03.11.2006
00006 // note:  added RMS(METx) vs SumET capability
00007 // modification: Rick Cavanaugh
00008 // date:  05.11.2006
00009 // note:  cleaned up constructor and beginJob, removed int conv. warning
00010 //        added configuration params
00011 // modification: Mike Schmitt
00012 // date:  02.28.2007
00013 // note:  code rewrite. Now uses STL map for monitoring element container. 
00014 // modification: Bobby Scurlock
00015 // date:  04.03.2007
00016 // note:  Eliminated automated resolution fitting. This is now done in a ROOT script.
00017 
00018 // date:  02.04.2009 
00019 // note:  Added option to use fine binning or course binning for histos
00020 
00021 #include "FWCore/PluginManager/interface/ModuleDef.h"
00022 #include "FWCore/Framework/interface/MakerMacros.h"
00023 
00024 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00025 #include "FWCore/ServiceRegistry/interface/Service.h"
00026 
00027 #include "FWCore/Framework/interface/Event.h"
00028 #include "DataFormats/Common/interface/Handle.h"
00029 #include "FWCore/Framework/interface/ESHandle.h"
00030 
00031 #include "DataFormats/METReco/interface/CaloMET.h"
00032 #include "DataFormats/METReco/interface/CaloMETCollection.h"
00033 #include "DataFormats/METReco/interface/GenMET.h"
00034 #include "DataFormats/METReco/interface/GenMETCollection.h"
00035 #include "DataFormats/METReco/interface/MET.h"
00036 #include "DataFormats/METReco/interface/METFwd.h"
00037 #include "DataFormats/METReco/interface/PFMET.h"
00038 #include "DataFormats/METReco/interface/PFMETCollection.h"
00039 #include "DataFormats/MuonReco/interface/MuonMETCorrectionData.h"
00040 #include "DataFormats/Common/interface/ValueMap.h"  
00041 #include "DataFormats/MuonReco/interface/Muon.h"
00042 #include "DataFormats/MuonReco/interface/MuonFwd.h"
00043 #include "DataFormats/MuonReco/interface/MuonMETCorrectionData.h"
00044 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
00045 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
00046 #include "DataFormats/TrackReco/interface/Track.h"
00047 
00048 #include <vector>
00049 #include <utility>
00050 #include <ostream>
00051 #include <fstream>
00052 #include <iostream>
00053 #include <algorithm>
00054 #include <cmath>
00055 #include <memory>
00056 #include "DQMServices/Core/interface/DQMStore.h"
00057 #include "TMath.h"
00058 
00059 METTester::METTester(const edm::ParameterSet& iConfig)
00060 {
00061   METType_                 = iConfig.getUntrackedParameter<std::string>("METType");
00062   inputMETLabel_           = iConfig.getParameter<edm::InputTag>("InputMETLabel");
00063   if(METType_ == "TCMET") {
00064        inputCaloMETLabel_       = iConfig.getParameter<edm::InputTag>("InputCaloMETLabel");     
00065   inputTrackLabel_         = iConfig.getParameter<edm::InputTag>("InputTrackLabel");    
00066   inputMuonLabel_          = iConfig.getParameter<edm::InputTag>("InputMuonLabel");
00067   inputElectronLabel_      = iConfig.getParameter<edm::InputTag>("InputElectronLabel");
00068   inputBeamSpotLabel_      = iConfig.getParameter<edm::InputTag>("InputBeamSpotLabel");
00069   minhits_                 = iConfig.getParameter<int>("minhits");
00070   maxd0_                   = iConfig.getParameter<double>("maxd0");
00071   maxchi2_                 = iConfig.getParameter<double>("maxchi2");
00072   maxeta_                  = iConfig.getParameter<double>("maxeta");
00073   maxpt_                   = iConfig.getParameter<double>("maxpt");
00074   maxPtErr_                = iConfig.getParameter<double>("maxPtErr");
00075   trkQuality_              = iConfig.getParameter<std::vector<int> >("trkQuality");
00076   trkAlgos_                = iConfig.getParameter<std::vector<int> >("trkAlgos");
00077   sample_                  = iConfig.getUntrackedParameter<std::string>("sample");
00078   }
00079   finebinning_             = iConfig.getUntrackedParameter<bool>("FineBinning");
00080   FolderName_              = iConfig.getUntrackedParameter<std::string>("FolderName");
00081 }
00082 
00083 
00084 void METTester::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
00085 {
00086   // get ahold of back-end interface
00087   dbe_ = edm::Service<DQMStore>().operator->();
00088   
00089   if (dbe_) {
00090     //    TString dirName = "RecoMETV/METTask/MET/";
00091     //TString dirName = "JetMET/EventInfo/CertificationSummary/MET_Global/";
00092     //    TString dirName = "RecoMETV/MET_Global/";
00093     TString dirName(FolderName_.c_str()); 
00094     TString label(inputMETLabel_.label());
00095     dirName += label;
00096     dbe_->setCurrentFolder((std::string)dirName);
00097     
00098     if (METType_ == "CaloMET")
00099       { 
00100         // CaloMET Histograms
00101         if(!finebinning_)
00102           {
00103             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,-0.5,1); 
00104             me["hCaloMEx"]                = dbe_->book1D("METTask_CaloMEx","METTask_CaloMEx",500,-999.5,499.5); 
00105             me["hCaloMEy"]                = dbe_->book1D("METTask_CaloMEy","METTask_CaloMEy",500,-999.5,499.5);
00106             //        me["hCaloEz"]                 = dbe_->book1D("METTask_CaloEz","METTask_CaloEz",2001,-500,501);
00107             me["hCaloMETSig"]             = dbe_->book1D("METTask_CaloMETSig","METTask_CaloMETSig",25,-0.5,24.5);
00108             me["hCaloMET"]                = dbe_->book1D("METTask_CaloMET","METTask_CaloMET",1000,-0.5,1999.5);
00109             me["hCaloMETPhi"]             = dbe_->book1D("METTask_CaloMETPhi","METTask_CaloMETPhi",40,-4,4);
00110             me["hCaloSumET"]              = dbe_->book1D("METTask_CaloSumET","METTask_CaloSumET",800,-0.5,7999.5);   //10GeV
00111             me["hCaloMaxEtInEmTowers"]    = dbe_->book1D("METTask_CaloMaxEtInEmTowers","METTask_CaloMaxEtInEmTowers",600,-0.5,2999.5);   //5GeV
00112             me["hCaloMaxEtInHadTowers"]   = dbe_->book1D("METTask_CaloMaxEtInHadTowers","METTask_CaloMaxEtInHadTowers",600,-.05,2999.5);  //5GeV
00113             me["hCaloEtFractionHadronic"] = dbe_->book1D("METTask_CaloEtFractionHadronic","METTask_CaloEtFractionHadronic",100,0,1);
00114             me["hCaloEmEtFraction"]       = dbe_->book1D("METTask_CaloEmEtFraction","METTask_CaloEmEtFraction",100,0,1);
00115             me["hCaloHadEtInHB"]          = dbe_->book1D("METTask_CaloHadEtInHB","METTask_CaloHadEtInHB",1000, -0.5, 4999.5);  //5GeV  
00116             me["hCaloHadEtInHO"]          = dbe_->book1D("METTask_CaloHadEtInHO","METTask_CaloHadEtInHO",250, -0.5, 499.5);  //5GeV
00117             me["hCaloHadEtInHE"]          = dbe_->book1D("METTask_CaloHadEtInHE","METTask_CaloHadEtInHE",200, -0.5, 399.5);  //5GeV
00118             me["hCaloHadEtInHF"]          = dbe_->book1D("METTask_CaloHadEtInHF","METTask_CaloHadEtInHF",100, -0.5, 199.5);  //5GeV
00119             me["hCaloEmEtInHF"]           = dbe_->book1D("METTask_CaloEmEtInHF","METTask_CaloEmEtInHF",100, -0.5, 99.5);   //5GeV
00120             me["hCaloEmEtInEE"]           = dbe_->book1D("METTask_CaloEmEtInEE","METTask_CaloEmEtInEE",100,0,199.5);    //5GeV
00121             me["hCaloEmEtInEB"]           = dbe_->book1D("METTask_CaloEmEtInEB","METTask_CaloEmEtInEB",1200,0, 5999.5);   //5GeV
00122 
00123 
00124             
00125             me["hCaloMETResolution_GenMETTrue"]      = dbe_->book1D("METTask_CaloMETResolution_GenMETTrue","METTask_CaloMETResolution_GenMETTrue", 500,-500,500); 
00126             me["hCaloMETResolution_GenMETCalo"]      = dbe_->book1D("METTask_CaloMETResolution_GenMETCalo","METTask_CaloMETResolution_GenMETCalo", 500,-500,500); 
00127 
00128             me["hCaloMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETTrue","METTask_CaloMETPhiResolution_GenMETTrue", 80,0,4); 
00129             me["hCaloMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETCalo","METTask_CaloMETPhiResolution_GenMETCalo", 80,0,4); 
00130             
00131           }
00132         else
00133           {
00134             //FineBinnning
00135             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,-0.5,1);
00136             me["hCaloMEx"]                = dbe_->book1D("METTask_CaloMEx","METTask_CaloMEx",4001,-1000,1001);
00137             me["hCaloMEy"]                = dbe_->book1D("METTask_CaloMEy","METTask_CaloMEy",4001,-1000,1001);
00138             //me["hCaloEz"]                 = dbe_->book1D("METTask_CaloEz","METTask_CaloEz",2001,-500,501);
00139             me["hCaloMETSig"]             = dbe_->book1D("METTask_CaloMETSig","METTask_CaloMETSig",51,0,51);
00140             me["hCaloMET"]                = dbe_->book1D("METTask_CaloMET","METTask_CaloMET",2001,0,2001);
00141             me["hCaloMETPhi"]             = dbe_->book1D("METTask_CaloMETPhi","METTask_CaloMETPhi",40,-4,4);
00142             me["hCaloSumET"]              = dbe_->book1D("METTask_CaloSumET","METTask_CaloSumET",10001,0,10001);
00143             me["hCaloMaxEtInEmTowers"]    = dbe_->book1D("METTask_CaloMaxEtInEmTowers","METTask_CaloMaxEtInEmTowers",4001,0,4001);
00144             me["hCaloMaxEtInHadTowers"]   = dbe_->book1D("METTask_CaloMaxEtInHadTowers","METTask_CaloMaxEtInHadTowers",4001,0,4001);
00145             me["hCaloEtFractionHadronic"] = dbe_->book1D("METTask_CaloEtFractionHadronic","METTask_CaloEtFractionHadronic",100,0,1);
00146             me["hCaloEmEtFraction"]       = dbe_->book1D("METTask_CaloEmEtFraction","METTask_CaloEmEtFraction",100,0,1);
00147             me["hCaloHadEtInHB"]          = dbe_->book1D("METTask_CaloHadEtInHB","METTask_CaloHadEtInHB",8001,0,8001);
00148             me["hCaloHadEtInHO"]          = dbe_->book1D("METTask_CaloHadEtInHO","METTask_CaloHadEtInHO",4001,0,4001);
00149             me["hCaloHadEtInHE"]          = dbe_->book1D("METTask_CaloHadEtInHE","METTask_CaloHadEtInHE",4001,0,4001);
00150             me["hCaloHadEtInHF"]          = dbe_->book1D("METTask_CaloHadEtInHF","METTask_CaloHadEtInHF",4001,0,4001);
00151             me["hCaloHadEtInEB"]          = dbe_->book1D("METTask_CaloHadEtInEB","METTask_CaloHadEtInEB",8001,0,8001);
00152             me["hCaloHadEtInEE"]          = dbe_->book1D("METTask_CaloHadEtInEE","METTask_CaloHadEtInEE",4001,0,4001);
00153             me["hCaloEmEtInHF"]           = dbe_->book1D("METTask_CaloEmEtInHF","METTask_CaloEmEtInHF",4001,0,4001);
00154             me["hCaloEmEtInEE"]           = dbe_->book1D("METTask_CaloEmEtInEE","METTask_CaloEmEtInEE",4001,0,4001);
00155             me["hCaloEmEtInEB"]           = dbe_->book1D("METTask_CaloEmEtInEB","METTask_CaloEmEtInEB",8001,0,8001);
00156 
00157             me["hCaloMETResolution_GenMETTrue"]      = dbe_->book1D("METTask_CaloMETResolution_GenMETTrue","METTask_CaloMETResolution_GenMETTrue", 2000,-1000,1000); 
00158             me["hCaloMETResolution_GenMETCalo"]      = dbe_->book1D("METTask_CaloMETResolution_GenMETCalo","METTask_CaloMETResolution_GenMETCalo", 2000,-1000,1000); 
00159             
00160             me["hCaloMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETTrue","METTask_CaloMETPhiResolution_GenMETTrue", 80,0,4); 
00161             me["hCaloMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETCalo","METTask_CaloMETPhiResolution_GenMETCalo", 80,0,4); 
00162           }
00163       }
00164     
00165     else if (METType_ == "GenMET")
00166       {
00167         // GenMET Histograms
00168         
00169         if(!finebinning_)
00170           {
00171             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1); 
00172             me["hGenMEx"]                 = dbe_->book1D("METTask_GenMEx","METTask_GenMEx",1000,-999.5,999.5);
00173             me["hGenMEy"]                 = dbe_->book1D("METTask_GenMEy","METTask_GenMEy",1000,-999.5,999.5);
00174             //        me["hGenEz"]                  = dbe_->book1D("METTask_GenEz","METTask_GenEz",2001,-500,501);
00175             me["hGenMETSig"]              = dbe_->book1D("METTask_GenMETSig","METTask_GenMETSig",51,0,51);
00176             me["hGenMET"]                 = dbe_->book1D("METTask_GenMET","METTask_GenMET", 2000,-0.5,1999.5);
00177             me["hGenMETPhi"]              = dbe_->book1D("METTask_GenMETPhi","METTask_GenMETPhi",40,-4,4);
00178             me["hGenSumET"]               = dbe_->book1D("METTask_GenSumET","METTask_GenSumET",1000,-0.5,9999.5);
00179 
00180             me["hNeutralEMEtFraction"]    = dbe_->book1D("METTask_GenNeutralEMEtFraction", "METTask_GenNeutralEMEtFraction", 120, 0.0, 1.2 );
00181             me["hNeutralHadEtFraction"]   = dbe_->book1D("METTask_GenNeutralHadEtFraction", "METTask_GenNeutralHadEtFraction", 120, 0.0, 1.2 );
00182             me["hChargedEMEtFraction"]    = dbe_->book1D("METTask_GenChargedEMEtFraction", "METTask_GenChargedEMEtFraction", 120, 0.0, 1.2);
00183             me["hChargedHadEtFraction"]   = dbe_->book1D("METTask_GenChargedHadEtFraction", "METTask_GenChargedHadEtFraction", 120, 0.0,1.2);
00184             me["hMuonEtFraction"]         = dbe_->book1D("METTask_GenMuonEtFraction", "METTask_GenMuonEtFraction", 120, 0.0, 1.2 );
00185             me["hInvisibleEtFraction"]    = dbe_->book1D("METTask_GenInvisibleEtFraction", "METTask_GenInvisibleEtFraction", 120, 0.0, 1.2 );
00186             
00187           }
00188         else
00189           {
00190                me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
00191                me["hGenMEx"]                 = dbe_->book1D("METTask_GenMEx","METTask_GenMEx",4001,-1000,1001);
00192                me["hGenMEy"]                 = dbe_->book1D("METTask_GenMEy","METTask_GenMEy",4001,-1000,1001);
00193                //me["hGenEz"]                  = dbe_->book1D("METTask_GenEz","METTask_GenEz",2001,-500,501);
00194                me["hGenMETSig"]              = dbe_->book1D("METTask_GenMETSig","METTask_GenMETSig",51,0,51);
00195                me["hGenMET"]                 = dbe_->book1D("METTask_GenMET","METTask_GenMET",2001,0,2001);
00196                me["hGenMETPhi"]              = dbe_->book1D("METTask_GenMETPhi","METTask_GenMETPhi",40,-4,4);
00197                me["hGenSumET"]               = dbe_->book1D("METTask_GenSumET","METTask_GenSumET",10001,0,10001);
00198                me["hNeutralEMEtFraction"]    = dbe_->book1D("METTask_GenNeutralEMEtFraction", "METTask_GenNeutralEMEtFraction", 120, 0.0, 1.2 );
00199                me["hNeutralHadEtFraction"]   = dbe_->book1D("METTask_GenNeutralHadEtFraction", "METTask_GenNeutralHadEtFraction", 120, 0.0, 1.2 );
00200                me["hChargedEMEtFraction"]    = dbe_->book1D("METTask_GenChargedEMEtFraction", "METTask_GenChargedEMEtFraction", 120, 0.0, 1.2);
00201                me["hChargedHadEtFraction"]   = dbe_->book1D("METTask_GenChargedHadEtFraction", "METTask_GenChargedHadEtFraction", 120, 0.0,1.2);
00202                me["hMuonEtFraction"]         = dbe_->book1D("METTask_GenMuonEtFraction", "METTask_GenMuonEtFraction", 120, 0.0, 1.2 );
00203                me["hInvisibleEtFraction"]    = dbe_->book1D("METTask_GenInvisibleEtFraction", "METTask_GenInvisibleEtFraction", 120, 0.0, 1.2 );
00204 
00205           }
00206       }
00207     else if (METType_ == "MET")
00208       {
00209         // MET Histograms
00210         if(!finebinning_)
00211           {
00212             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1); 
00213             me["hMEx"]                = dbe_->book1D("METTask_MEx","METTask_MEx",1000,-999.5,999.5);
00214             me["hMEy"]                = dbe_->book1D("METTask_MEy","METTask_MEy",1000,-999.5,999.5);
00215             //me["hEz"]                 = dbe_->book1D("METTask_Ez","METTask_Ez",1000,-999.5,999.5);
00216             me["hMETSig"]             = dbe_->book1D("METTask_METSig","METTask_METSig",50,-0.5,49.5);
00217             me["hMET"]                = dbe_->book1D("METTask_MET","METTask_MET",1000,-0.5,1999.5);
00218             me["hMETPhi"]             = dbe_->book1D("METTask_METPhi","METTask_METPhi",40,-4,4);
00219             me["hSumET"]              = dbe_->book1D("METTask_SumET","METTask_SumET",1000,0,9999.5);   
00220             
00221           }
00222         else
00223           {
00224             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
00225             me["hMEx"]                = dbe_->book1D("METTask_MEx","METTask_MEx",2001,-500,501);
00226             me["hMEy"]                = dbe_->book1D("METTask_MEy","METTask_MEy",2001,-500,501);
00227             //me["hEz"]                 = dbe_->book1D("METTask_Ez","METTask_Ez",2001,-500,501);
00228             me["hMETSig"]             = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
00229             me["hMET"]                = dbe_->book1D("METTask_MET","METTask_MET",2001,0,2001);
00230             me["hMETPhi"]             = dbe_->book1D("METTask_METPhi","METTask_METPhi",40,-4,4);
00231             me["hSumET"]              = dbe_->book1D("METTask_SumET","METTask_SumET",4001,0,4001);
00232 
00233           }
00234       }
00235     else if (METType_ == "PFMET")
00236       {
00237         // PFMET Histograms                                                                                                                  
00238         if(!finebinning_)
00239           {
00240             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);   
00241             me["hMEx"]                = dbe_->book1D("METTask_MEx","METTask_MEx",1000,-999.5,999.5);
00242             me["hMEy"]                = dbe_->book1D("METTask_MEy","METTask_MEy",1000,-999.5,999.5);
00243             //        me["hEz"]                 = dbe_->book1D("METTask_Ez","METTask_Ez",2001,-500,501);
00244             me["hMETSig"]             = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
00245             me["hMET"]                = dbe_->book1D("METTask_MET","METTask_MET",1000,-0.5,1999.5);
00246             me["hMETPhi"]             = dbe_->book1D("METTask_METPhi","METTask_METPhi",40,-4,4);
00247             me["hSumET"]              = dbe_->book1D("METTask_SumET","METTask_SumET",1000,-0.50,9999.5);     
00248             
00249             me["hMETResolution_GenMETTrue"]      = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue", 500,-500,500); 
00250             me["hMETResolution_GenMETCalo"]      = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo", 500,-500,500); 
00251 
00252             me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4); 
00253             me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4); 
00254 
00255            }
00256         else
00257           {
00258             //FineBin
00259             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
00260             me["hMEx"]                = dbe_->book1D("METTask_MEx","METTask_MEx",2001,-500,501);
00261             me["hMEy"]                = dbe_->book1D("METTask_MEy","METTask_MEy",2001,-500,501);
00262             //me["hEz"]                 = dbe_->book1D("METTask_Ez","METTask_Ez",2001,-500,501);
00263             me["hMETSig"]             = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
00264             me["hMET"]                = dbe_->book1D("METTask_MET","METTask_MET",2001,0,2001);
00265             me["hMETPhi"]             = dbe_->book1D("METTask_METPhi","METTask_METPhi",40,-4,4);
00266             me["hSumET"]              = dbe_->book1D("METTask_SumET","METTask_SumET",4001,0,4001);
00267 
00268             me["hMETResolution_GenMETTrue"]      = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue",2000,-1000,1000);
00269             me["hMETResolution_GenMETCalo"]      = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo",2000,-1000,1000);
00270 
00271             me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4); 
00272             me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4); 
00273 
00274             
00275           }
00276       }
00277     else if (METType_ == "TCMET" || inputMETLabel_.label() == "corMetGlobalMuons")
00278       {
00279         //TCMET or MuonCorrectedCaloMET Histograms                                                                                                                  
00280         if(!finebinning_)
00281           {
00282             me["hNevents"]                = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);   
00283             me["hMEx"]                = dbe_->book1D("METTask_MEx","METTask_MEx",1000,-999.5,999.5);
00284             me["hMEy"]                = dbe_->book1D("METTask_MEy","METTask_MEy",1000,-999.5,999.5);
00285             me["hMETSig"]             = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
00286             me["hMET"]                = dbe_->book1D("METTask_MET","METTask_MET",1000,-0.5,1999.5);
00287             me["hMETPhi"]             = dbe_->book1D("METTask_METPhi","METTask_METPhi",40,-4,4);
00288             me["hSumET"]              = dbe_->book1D("METTask_SumET","METTask_SumET",1000,-0.50,9999.5);     
00289            
00290             me["hMExCorrection"]       = dbe_->book1D("METTask_MExCorrection","METTask_MExCorrection", 1000, -500.0,500.0);
00291             me["hMEyCorrection"]       = dbe_->book1D("METTask_MEyCorrection","METTask_MEyCorrection", 1000, -500.0,500.0);
00292             me["hMuonCorrectionFlag"]      = dbe_->book1D("METTask_CorrectionFlag", "METTask_CorrectionFlag", 6, -0.5, 5.5);
00293 
00294             me["hMETResolution_GenMETTrue"]      = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue", 500,-500,500); 
00295             me["hMETResolution_GenMETCalo"]      = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo", 500,-500,500); 
00296 
00297             me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4); 
00298             me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4); 
00299 
00300             if( METType_ == "TCMET" ) {
00301               me["htrkPt"] = dbe_->book1D("METTask_trackPt", "METTask_trackPt", 50, 0, 500);
00302               me["htrkEta"] = dbe_->book1D("METTask_trackEta", "METTask_trackEta", 50, -2.5, 2.5);
00303               me["htrkNhits"] = dbe_->book1D("METTask_trackNhits", "METTask_trackNhits", 50, 0, 50);
00304               me["htrkChi2"] = dbe_->book1D("METTask_trackNormalizedChi2", "METTask_trackNormalizedChi2", 20, 0, 20);
00305               me["htrkD0"] = dbe_->book1D("METTask_trackD0", "METTask_trackd0", 50, -1, 1);
00306               me["htrkQuality"] = dbe_->book1D("METTask_trackQuality", "METTask_trackQuality", 30, -0.5, 29.5);
00307               me["htrkAlgo"] = dbe_->book1D("METTask_trackAlgo", "METTask_trackAlgo", 6, 3.5, 9.5);
00308               me["htrkPtErr"] = dbe_->book1D("METTask_trackPtErr", "METTask_trackPtErr", 200, 0, 2);
00309               me["helePt"] = dbe_->book1D("METTask_electronPt", "METTask_electronPt", 50, 0, 500);
00310               me["heleEta"] = dbe_->book1D("METTask_electronEta", "METTask_electronEta", 50, -2.5, 2.5);
00311               me["heleHoE"] = dbe_->book1D("METTask_electronHoverE", "METTask_electronHoverE", 25, 0, 0.5);
00312               me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 50, 0, 500);
00313               me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 50, -2.5, 2.5);
00314               me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
00315               me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 20, 0, 20);
00316               me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 50, -1, 1);
00317               me["hnMus"] = dbe_->book1D("METTask_nMus", "METTask_nMus", 5, -0.5, 4.5);
00318               me["hnMusPis"] = dbe_->book1D("METTask_nMusAsPis", "METTask_nMusAsPis", 5, -0.5, 4.5);
00319               me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
00320               me["hnEls"] = dbe_->book1D("METTask_nEls", "METTask_nEls", 5, -0.5, 4.5);
00321               me["hfracTrks"] = dbe_->book1D("METTask_fracTracks", "METTask_fracTracks", 100, 0, 1);
00322               me["hdMETx"] = dbe_->book1D("METTask_dMETx", "METTask_dMETx", 500, -250, 250);
00323               me["hdMETy"] = dbe_->book1D("METTask_dMETy", "METTask_dMETy", 500, -250, 250);
00324               me["hdMET"] = dbe_->book1D("METTask_dMET", "METTask_dMET", 500, -250, 250);
00325               me["hdMUx"] = dbe_->book1D("METTask_dMUx", "METTask_dMUx", 500, -250, 250);
00326               me["hdMUy"] = dbe_->book1D("METTask_dMUy", "METTask_dMUy", 500, -250, 250);
00327             }
00328             else if( inputMETLabel_.label() == "corMetGlobalMuons" ) {
00329               me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 50, 0, 500);
00330               me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 50, -2.5, 2.5);
00331               me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
00332               me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 20, 0, 20);
00333               me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 50, -1, 1);
00334               me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
00335             }
00336           }
00337         else
00338           {
00339             //FineBin
00340             me["hNevents"]            = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
00341             me["hMEx"]                = dbe_->book1D("METTask_MEx","METTask_MEx",2001,-500,501);
00342             me["hMEy"]                = dbe_->book1D("METTask_MEy","METTask_MEy",2001,-500,501);
00343             me["hMETSig"]             = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
00344             me["hMET"]                = dbe_->book1D("METTask_MET","METTask_MET",2001,0,2001);
00345             me["hMETPhi"]             = dbe_->book1D("METTask_METPhi","METTask_METPhi",40,-4,4);
00346             me["hSumET"]              = dbe_->book1D("METTask_SumET","METTask_SumET",4001,0,4001);
00347             me["hMExCorrection"]      = dbe_->book1D("METTask_MExCorrection","METTask_MExCorrection", 2000, -500.0,500.0);
00348             me["hMEyCorrection"]      = dbe_->book1D("METTask_MEyCorrection","METTask_MEyCorrection", 2000, -500.0,500.0);
00349             me["hMuonCorrectionFlag"]     = dbe_->book1D("METTask_CorrectionFlag", "METTask_CorrectionFlag", 6, -0.5, 5.5);                
00350 
00351             me["hMETResolution_GenMETTrue"]      = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue",2000,-1000,1000);
00352             me["hMETResolution_GenMETCalo"]      = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo",2000,-1000,1000);
00353             
00354             me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4); 
00355             me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4); 
00356 
00357             if( METType_ == "TCMET" ) {
00358               me["htrkPt"] = dbe_->book1D("METTask_trackPt", "METTask_trackPt", 250, 0, 500);
00359               me["htrkEta"] = dbe_->book1D("METTask_trackEta", "METTask_trackEta", 250, -2.5, 2.5);
00360               me["htrkNhits"] = dbe_->book1D("METTask_trackNhits", "METTask_trackNhits", 50, 0, 50);
00361               me["htrkChi2"] = dbe_->book1D("METTask_trackNormalizedChi2", "METTask_trackNormalizedChi2", 100, 0, 20);
00362               me["htrkD0"] = dbe_->book1D("METTask_trackD0", "METTask_trackd0", 200, -1, 1);
00363               me["htrkQuality"] = dbe_->book1D("METTask_trackQuality", "METTask_trackQuality", 30, -0.5, 29.5);
00364               me["htrkAlgo"] = dbe_->book1D("METTask_trackAlgo", "METTask_trackAlgo", 6, 3.5, 9.5);
00365               me["htrkPtErr"] = dbe_->book1D("METTask_trackPtErr", "METTask_trackPtErr", 200, 0, 2);
00366               me["helePt"] = dbe_->book1D("METTask_electronPt", "METTask_electronPt", 250, 0, 500);
00367               me["heleEta"] = dbe_->book1D("METTask_electronEta", "METTask_electronEta", 250, -2.5, 2.5);
00368               me["heleHoE"] = dbe_->book1D("METTask_electronHoverE", "METTask_electronHoverE", 100, 0, 0.5);
00369               me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 250, 0, 500);
00370               me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 250, -2.5, 2.5);
00371               me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
00372               me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 100, 0, 20);
00373               me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 200, -1, 1);
00374               me["hnMus"] = dbe_->book1D("METTask_nMus", "METTask_nMus", 5, -0.5, 4.5);
00375               me["hnMusPis"] = dbe_->book1D("METTask_nMusAsPis", "METTask_nMusAsPis", 5, -0.5, 4.5);
00376               me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
00377               me["hnEls"] = dbe_->book1D("METTask_nEls", "METTask_nEls", 5, -0.5, 4.5);
00378               me["hfracTrks"] = dbe_->book1D("METTask_fracTracks", "METTask_fracTracks", 100, 0, 1);
00379               me["hdMETx"] = dbe_->book1D("METTask_dMETx", "METTask_dMETx", 500, -250, 250);
00380               me["hdMETy"] = dbe_->book1D("METTask_dMETy", "METTask_dMETy", 500, -250, 250);
00381               me["hdMET"] = dbe_->book1D("METTask_dMET", "METTask_dMET", 500, -250, 250);
00382               me["hdMUx"] = dbe_->book1D("METTask_dMUx", "METTask_dMUx", 500, -250, 250);
00383               me["hdMUy"] = dbe_->book1D("METTask_dMUy", "METTask_dMUy", 500, -250, 250);
00384             }
00385             else if( inputMETLabel_.label() == "corMetGlobalMuons" ) {
00386               me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 250, 0, 500);
00387               me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 250, -2.5, 2.5);
00388               me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
00389               me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 100, 0, 20);
00390               me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 200, -1, 1);
00391               me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
00392             }
00393           }
00394         
00395         if(METType_ == "TCMET")
00396           {
00397             me["hMuonCorrectionFlag"]->setBinLabel(1,"Not Corrected");
00398             me["hMuonCorrectionFlag"]->setBinLabel(2,"Global Fit");
00399             me["hMuonCorrectionFlag"]->setBinLabel(3,"Tracker Fit");
00400             me["hMuonCorrectionFlag"]->setBinLabel(4,"SA Fit");
00401             me["hMuonCorrectionFlag"]->setBinLabel(5,"Treated as Pion");
00402             me["hMuonCorrectionFlag"]->setBinLabel(6,"Default fit");
00403           }
00404         else if( inputMETLabel_.label() == "corMetGlobalMuons") 
00405           {
00406             me["hMuonCorrectionFlag"]->setBinLabel(1,"Not Corrected");
00407             me["hMuonCorrectionFlag"]->setBinLabel(2,"Global Fit");
00408             me["hMuonCorrectionFlag"]->setBinLabel(3,"Tracker Fit");
00409             me["hMuonCorrectionFlag"]->setBinLabel(4,"SA Fit");
00410             me["hMuonCorrectionFlag"]->setBinLabel(5,"Treated as Pion");
00411             me["hMuonCorrectionFlag"]->setBinLabel(6,"Default fit");
00412           }
00413       }
00414     else
00415       {
00416         edm::LogInfo("OutputInfo") << " METType not correctly specified!'";// << outputFile_.c_str();
00417       }
00418   }
00419 }
00420 
00421 void METTester::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
00422 {
00423     using namespace reco;
00424     if (METType_ == "CaloMET")
00425     { 
00426       const CaloMET *calomet;
00427       // Get CaloMET
00428       edm::Handle<CaloMETCollection> calo;
00429       iEvent.getByLabel(inputMETLabel_, calo);
00430       if (!calo.isValid()) {
00431         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task";
00432         edm::LogInfo("OutputInfo") << " MET Task cannot continue...!";
00433         return;
00434       } else {
00435         const CaloMETCollection *calometcol = calo.product();
00436         calomet = &(calometcol->front());
00437       }
00438 
00439 
00440       // ==========================================================
00441       // Reconstructed MET Information
00442       double caloSumET = calomet->sumEt();
00443       double caloMETSig = calomet->mEtSig();
00444       double caloMET = calomet->pt();
00445       double caloMEx = calomet->px();
00446       double caloMEy = calomet->py();
00447       double caloMETPhi = calomet->phi();
00448       double caloMaxEtInEMTowers = calomet->maxEtInEmTowers();
00449       double caloMaxEtInHadTowers = calomet->maxEtInHadTowers();
00450       double caloEtFractionHadronic = calomet->etFractionHadronic();
00451       double caloEmEtFraction = calomet->emEtFraction();
00452       double caloHadEtInHB = calomet->hadEtInHB();
00453       double caloHadEtInHO = calomet->hadEtInHO();
00454       double caloHadEtInHE = calomet->hadEtInHE();
00455       double caloHadEtInHF = calomet->hadEtInHF();
00456       double caloEmEtInEB = calomet->emEtInEB();
00457       double caloEmEtInEE = calomet->emEtInEE();
00458       double caloEmEtInHF = calomet->emEtInHF();
00459 
00460       edm::LogInfo("OutputInfo") << caloMET << " " << caloSumET << std::endl;
00461       me["hNevents"]->Fill(0.5);
00462       me["hCaloMEx"]->Fill(caloMEx);
00463       me["hCaloMEy"]->Fill(caloMEy);
00464       me["hCaloMET"]->Fill(caloMET);
00465       me["hCaloMETPhi"]->Fill(caloMETPhi);
00466       me["hCaloSumET"]->Fill(caloSumET);
00467       me["hCaloMETSig"]->Fill(caloMETSig);
00468       me["hCaloMaxEtInEmTowers"]->Fill(caloMaxEtInEMTowers);
00469       me["hCaloMaxEtInHadTowers"]->Fill(caloMaxEtInHadTowers);
00470       me["hCaloEtFractionHadronic"]->Fill(caloEtFractionHadronic);
00471       me["hCaloEmEtFraction"]->Fill(caloEmEtFraction);
00472       me["hCaloHadEtInHB"]->Fill(caloHadEtInHB);
00473       me["hCaloHadEtInHO"]->Fill(caloHadEtInHO);
00474       me["hCaloHadEtInHE"]->Fill(caloHadEtInHE);
00475       me["hCaloHadEtInHF"]->Fill(caloHadEtInHF);
00476       me["hCaloEmEtInEB"]->Fill(caloEmEtInEB);
00477       me["hCaloEmEtInEE"]->Fill(caloEmEtInEE);
00478       me["hCaloEmEtInHF"]->Fill(caloEmEtInHF);
00479 
00480       
00481       // Get Generated MET for Resolution plots
00482 
00483       edm::Handle<GenMETCollection> genTrue;
00484       iEvent.getByLabel("genMetTrue", genTrue);
00485       if (genTrue.isValid()) {
00486         const GenMETCollection *genmetcol = genTrue.product();
00487         const GenMET *genMetTrue = &(genmetcol->front());
00488         double genMET = genMetTrue->pt();
00489         double genMETPhi = genMetTrue->phi();
00490         
00491         me["hCaloMETResolution_GenMETTrue"]->Fill( caloMET - genMET );
00492         me["hCaloMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( caloMETPhi - genMETPhi ) ) );
00493       } else {
00494         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetTrue";
00495       }    
00496 
00497 
00498       edm::Handle<GenMETCollection> genCalo;
00499       iEvent.getByLabel("genMetCalo", genCalo);
00500       if (genCalo.isValid()) {
00501         const GenMETCollection *genmetcol = genCalo.product();
00502         const GenMET  *genMetCalo = &(genmetcol->front());
00503         double genMET = genMetCalo->pt();
00504         double genMETPhi = genMetCalo->phi();
00505         
00506         me["hCaloMETResolution_GenMETCalo"]->Fill( caloMET - genMET );
00507         me["hCaloMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( caloMETPhi - genMETPhi ) ) );
00508       } else {
00509         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetCalo";
00510       }    
00511 
00512 
00513     }
00514 
00515   
00516   else if (METType_ == "GenMET")
00517     {
00518       const GenMET *genmet;
00519       // Get Generated MET
00520       edm::Handle<GenMETCollection> gen;
00521       iEvent.getByLabel(inputMETLabel_, gen);
00522       if (!gen.isValid()) {
00523         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task";
00524         edm::LogInfo("OutputInfo") << " MET Task cannot continue...!";
00525         return;
00526       } else {
00527         const GenMETCollection *genmetcol = gen.product();
00528         genmet = &(genmetcol->front());
00529       }    
00530       
00531       // ==========================================================
00532       // Genenerated MET Information  
00533       double genSumET = genmet->sumEt();
00534       double genMET = genmet->pt();
00535       double genMEx = genmet->px();
00536       double genMEy = genmet->py();
00537       double genMETPhi = genmet->phi();
00538       double genMETSig = genmet->mEtSig();
00539       /*
00540       double genEmEnergy = genmet->emEnergy();
00541       double genHadEnergy = genmet->hadEnergy();
00542       double genInvisibleEnergy= genmet->invisibleEnergy();
00543       double genAuxiliaryEnergy= genmet->auxiliaryEnergy();
00544       */
00545 
00546       double NeutralEMEtFraction = genmet->NeutralEMEtFraction() ;
00547       double NeutralHadEtFraction = genmet->NeutralHadEtFraction() ;
00548       double ChargedEMEtFraction = genmet->ChargedEMEtFraction () ;
00549       double ChargedHadEtFraction = genmet->ChargedHadEtFraction();
00550       double MuonEtFraction = genmet->MuonEtFraction() ;
00551       double InvisibleEtFraction = genmet->InvisibleEtFraction() ;
00552 
00553       me["hNevents"]->Fill(0);
00554       me["hGenMEx"]->Fill(genMEx);
00555       me["hGenMEy"]->Fill(genMEy);
00556       me["hGenMET"]->Fill(genMET);
00557       me["hGenMETPhi"]->Fill(genMETPhi);
00558       me["hGenSumET"]->Fill(genSumET);
00559       me["hGenMETSig"]->Fill(genMETSig);
00560       //me["hGenEz"]->Fill(genEz);
00561 
00562       me["hNeutralEMEtFraction"]->Fill( NeutralEMEtFraction );
00563       me["hNeutralHadEtFraction"]->Fill( NeutralHadEtFraction );
00564       me["hChargedEMEtFraction"]->Fill( ChargedEMEtFraction );
00565       me["hChargedHadEtFraction"]->Fill( ChargedHadEtFraction );
00566       me["hMuonEtFraction"]->Fill( MuonEtFraction );
00567       me["hInvisibleEtFraction"]->Fill( InvisibleEtFraction );
00568 
00569       me["hNevents"]->Fill(0.5);
00570     }
00571   else if( METType_ == "PFMET")
00572     {
00573       const PFMET *pfmet;
00574       edm::Handle<PFMETCollection> hpfmetcol;
00575       iEvent.getByLabel(inputMETLabel_,hpfmetcol);
00576       if(!hpfmetcol.isValid()){
00577         edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
00578         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00579         return;
00580       }
00581       else
00582         {
00583           const PFMETCollection *pfmetcol = hpfmetcol.product();
00584           pfmet = &(pfmetcol->front());
00585         }
00586       // Reconstructed MET Information                                                                                                     
00587       double SumET = pfmet->sumEt();
00588       double MET = pfmet->pt();
00589       double MEx = pfmet->px();
00590       double MEy = pfmet->py();
00591       double METPhi = pfmet->phi();
00592       double METSig = pfmet->mEtSig();
00593       me["hMEx"]->Fill(MEx);
00594       me["hMEy"]->Fill(MEy);
00595       me["hMET"]->Fill(MET);
00596       me["hMETPhi"]->Fill(METPhi);
00597       me["hSumET"]->Fill(SumET);
00598       me["hMETSig"]->Fill(METSig);
00599       me["hNevents"]->Fill(0.5);
00600 
00601       edm::Handle<GenMETCollection> genTrue;
00602       iEvent.getByLabel("genMetTrue", genTrue);
00603       if (genTrue.isValid()) {
00604         const GenMETCollection *genmetcol = genTrue.product();
00605         const GenMET *genMetTrue = &(genmetcol->front());
00606         double genMET = genMetTrue->pt();
00607         double genMETPhi = genMetTrue->phi();
00608         
00609         me["hMETResolution_GenMETTrue"]->Fill( MET - genMET );
00610         me["hMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
00611       } else {
00612         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetTrue";
00613       }    
00614 
00615 
00616       edm::Handle<GenMETCollection> genCalo;
00617       iEvent.getByLabel("genMetCalo", genCalo);
00618       if (genCalo.isValid()) {
00619         const GenMETCollection *genmetcol = genCalo.product();
00620         const GenMET  *genMetCalo = &(genmetcol->front());
00621         double genMET = genMetCalo->pt();
00622         double genMETPhi = genMetCalo->phi();
00623         
00624         me["hMETResolution_GenMETCalo"]->Fill( MET - genMET );
00625         me["hMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
00626       } else {
00627         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetCalo";
00628       }    
00629       
00630 
00631 
00632     }
00633   else if (METType_ == "MET")
00634     {
00635       const MET *met;
00636       // Get Generated MET
00637       edm::Handle<METCollection> hmetcol;
00638       iEvent.getByLabel(inputMETLabel_, hmetcol);
00639       if (!hmetcol.isValid()) {
00640         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task";
00641         edm::LogInfo("OutputInfo") << " MET Task cannot continue...!";
00642         return;
00643       } else {
00644         const METCollection *metcol = hmetcol.product();
00645         met = &(metcol->front());
00646       }   
00647 
00648       // Reconstructed MET Information
00649       double SumET = met->sumEt();
00650       double MET = met->pt();
00651       double MEx = met->px();
00652       double MEy = met->py();
00653       double METPhi = met->phi();
00654       double METSig = met->mEtSig();
00655 
00656       me["hMEx"]->Fill(MEx);
00657       me["hMEy"]->Fill(MEy);
00658       me["hMET"]->Fill(MET);
00659       me["hMETPhi"]->Fill(METPhi);
00660       me["hSumET"]->Fill(SumET);
00661       me["hMETSig"]->Fill(METSig);
00662       me["hNevents"]->Fill(0.5);
00663 
00664     }
00665   else if( METType_ == "TCMET" )
00666     {
00667       const MET *tcMet;
00668       edm::Handle<METCollection> htcMetcol;
00669       iEvent.getByLabel(inputMETLabel_, htcMetcol);
00670 
00671       const CaloMET *caloMet;
00672       edm::Handle<CaloMETCollection> hcaloMetcol;
00673       iEvent.getByLabel(inputCaloMETLabel_, hcaloMetcol);
00674 
00675       edm::Handle< reco::MuonCollection > muon_h;
00676       iEvent.getByLabel(inputMuonLabel_, muon_h);
00677       
00678 //      edm::Handle< edm::View<reco::Track> > track_h;
00679       edm::Handle<reco::TrackCollection> track_h;
00680       iEvent.getByLabel(inputTrackLabel_, track_h);
00681       
00682       edm::Handle< edm::View<reco::GsfElectron > > electron_h;
00683       iEvent.getByLabel(inputElectronLabel_, electron_h);
00684       
00685       edm::Handle< reco::BeamSpot > beamSpot_h;
00686       iEvent.getByLabel(inputBeamSpotLabel_, beamSpot_h);
00687       
00688       if(!htcMetcol.isValid()){
00689         edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
00690         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00691         return;
00692       }
00693       else
00694         {
00695           const METCollection *tcMetcol = htcMetcol.product();
00696           tcMet = &(tcMetcol->front());
00697         }
00698 
00699       if(!hcaloMetcol.isValid()){
00700         edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
00701         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00702         return;
00703       }
00704       else
00705         {
00706           const CaloMETCollection *caloMetcol = hcaloMetcol.product();
00707           caloMet = &(caloMetcol->front());
00708         }
00709       
00710       if(!muon_h.isValid()){
00711         edm::LogInfo("OutputInfo") << "falied to retrieve muon data require by MET Task";
00712         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00713         return;
00714       }
00715       
00716       if(!track_h.isValid()){
00717         edm::LogInfo("OutputInfo") << "falied to retrieve track data require by MET Task";
00718         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00719         return;
00720       }
00721       
00722       if(!electron_h.isValid()){
00723         edm::LogInfo("OutputInfo") << "falied to retrieve electron data require by MET Task";
00724         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00725         return;
00726       }
00727       
00728       if(!beamSpot_h.isValid()){
00729         edm::LogInfo("OutputInfo") << "falied to retrieve beam spot data require by MET Task";
00730         edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
00731         return;
00732       }
00733 
00734       math::XYZPoint bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
00735       
00736       //Event selection-----------------------------------------------------------------------
00737 
00738       edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > tcMet_ValueMap_Handle;
00739       iEvent.getByLabel("muonTCMETValueMapProducer" , "muCorrData", tcMet_ValueMap_Handle);
00740 
00741       //count muons
00742       int nM = 0;
00743 
00744       for( unsigned int mus = 0; mus < muon_h->size() ; mus++ ) {
00745         
00746         reco::MuonRef muref( muon_h, mus);
00747         if( muref->pt() < 20 ) continue;
00748 
00749         reco::MuonMETCorrectionData muCorrData = (*tcMet_ValueMap_Handle)[muref];
00750         int type = muCorrData.type();
00751         
00752         if( type == 1 || type == 2 || type == 5 )  ++nM;
00753       }
00754 
00755       //count electrons
00756       int nE = 0;
00757 
00758       for( edm::View<reco::GsfElectron>::const_iterator eleit = electron_h->begin(); eleit != electron_h->end(); eleit++ ) {
00759         if( eleit->p4().pt() < 20 ) continue;  
00760         ++nE;
00761       }
00762       
00763       if( strcmp( sample_.c_str() , "zmm" ) == 0 && nM != 2 ) return;
00764 
00765       if( strcmp( sample_.c_str() , "zee" ) == 0 && nE != 2 ) return;
00766 
00767       if( strcmp( sample_.c_str() , "ttbar" ) == 0 && ( nE + nM ) == 0 ) return;
00768 
00769       // Reconstructed TCMET Information                                                                                                     
00770       double SumET = tcMet->sumEt();
00771       double MET = tcMet->pt();
00772       double MEx = tcMet->px();
00773       double MEy = tcMet->py();
00774       double METPhi = tcMet->phi();
00775       double METSig = tcMet->mEtSig();
00776 
00777       me["hMEx"]->Fill(MEx);
00778       me["hMEy"]->Fill(MEy);
00779       me["hMET"]->Fill(MET);
00780       me["hMETPhi"]->Fill(METPhi);
00781       me["hSumET"]->Fill(SumET);
00782       me["hMETSig"]->Fill(METSig);
00783       me["hNevents"]->Fill(0.5);
00784 
00785       double caloMET = caloMet->pt();
00786       double caloMEx = caloMet->px();
00787       double caloMEy = caloMet->py();
00788 
00789       me["hdMETx"]->Fill(caloMEx-MEx);
00790       me["hdMETy"]->Fill(caloMEy-MEy);
00791       me["hdMET"]->Fill(caloMET-MET);
00792       
00793       unsigned int nTracks = track_h->size();
00794       unsigned int nCorrTracks = 0;
00795       unsigned int trackCount = 0;
00796 //      for( edm::View<reco::Track>::const_iterator trkit = track_h->begin(); trkit != track_h->end(); trkit++ ) {
00797       for( reco::TrackCollection::const_iterator trkit = track_h->begin(); trkit != track_h->end(); trkit++ ) {
00798            ++trackCount;
00799         me["htrkPt"]->Fill( trkit->pt() );
00800         me["htrkEta"]->Fill( trkit->eta() );
00801         me["htrkNhits"]->Fill( trkit->numberOfValidHits() );
00802         me["htrkChi2"]->Fill( trkit->chi2() / trkit->ndof() );
00803 
00804         double d0 = -1 * trkit->dxy( bspot );
00805  
00806         me["htrkD0"]->Fill( d0 );
00807 
00808         me["htrkQuality"]->Fill( trkit->qualityMask() );
00809         me["htrkAlgo"]->Fill( trkit->algo() );
00810         me["htrkPtErr"]->Fill( trkit->ptError() / trkit->pt() );
00811 
00812         reco::TrackRef trkref( track_h, trackCount );
00813 
00814         if( isGoodTrack( trkref, d0) ) ++nCorrTracks;
00815       }
00816 
00817       float frac = (float)nCorrTracks / (float)nTracks;
00818       me["hfracTrks"]->Fill(frac);
00819 
00820       int nEls = 0;
00821       for( edm::View<reco::GsfElectron>::const_iterator eleit = electron_h->begin(); eleit != electron_h->end(); eleit++ ) {
00822         me["helePt"]->Fill( eleit->p4().pt() );  
00823         me["heleEta"]->Fill( eleit->p4().eta() );
00824         me["heleHoE"]->Fill( eleit->hadronicOverEm() );
00825 
00826         reco::TrackRef el_track = eleit->closestCtfTrackRef();
00827 
00828         unsigned int ele_idx = el_track.isNonnull() ? el_track.key() : 99999;
00829 
00830         if( eleit->hadronicOverEm() < 0.1 && ele_idx < nTracks )
00831              ++nEls;
00832       }
00833       
00834       me["hnEls"]->Fill(nEls);
00835 
00836       for( reco::MuonCollection::const_iterator muonit = muon_h->begin(); muonit != muon_h->end(); muonit++ ) {
00837 
00838         const reco::TrackRef siTrack = muonit->innerTrack();
00839 
00840         me["hmuPt"]->Fill( muonit->p4().pt() );
00841         me["hmuEta"]->Fill( muonit->p4().eta() );
00842         me["hmuNhits"]->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
00843         me["hmuChi2"]->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
00844 
00845         double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
00846 
00847         me["hmuD0"]->Fill( d0 );
00848       }
00849 
00850       //edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > tcMet_ValueMap_Handle;
00851       //iEvent.getByLabel("muonTCMETValueMapProducer" , "muCorrData", tcMet_ValueMap_Handle);
00852 
00853       edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > muon_ValueMap_Handle;
00854       iEvent.getByLabel("muonMETValueMapProducer" , "muCorrData", muon_ValueMap_Handle);
00855       
00856       const unsigned int nMuons = muon_h->size();      
00857 
00858       int nMus = 0;
00859       int nMusPis = 0;
00860       double muDx = 0;
00861       double muDy = 0;
00862       for( unsigned int mus = 0; mus < nMuons; mus++ ) 
00863         {
00864           reco::MuonRef muref( muon_h, mus);
00865           reco::MuonMETCorrectionData muCorrData = (*tcMet_ValueMap_Handle)[muref];
00866           reco::MuonMETCorrectionData muonCorrData = (*muon_ValueMap_Handle)[muref];
00867 
00868           me["hMExCorrection"] -> Fill(muCorrData.corrX());
00869           me["hMEyCorrection"] -> Fill(muCorrData.corrY());
00870 
00871           int type = muCorrData.type();
00872           me["hMuonCorrectionFlag"]-> Fill(type);
00873 
00874           if( type == 1 || type == 2 || type == 5 ) {
00875                ++nMus;
00876                
00877                if( type == 1 ) {
00878                     muDx += muonCorrData.corrX() - muref->globalTrack()->px();
00879                     muDy += muonCorrData.corrY() - muref->globalTrack()->py();
00880                }
00881                else if( type == 2 ) {
00882                     muDx += muonCorrData.corrX() - muref->innerTrack()->px();
00883                     muDy += muonCorrData.corrY() - muref->innerTrack()->py();
00884                }
00885                else if( type == 5 ) {
00886                     muDx += muonCorrData.corrX() - muref->px();
00887                     muDy += muonCorrData.corrY() - muref->py();
00888                }
00889           }
00890           else if( type == 4 )
00891                ++nMusPis;
00892         }
00893 
00894       me["hnMus"]->Fill(nMus);
00895       me["hnMusPis"]->Fill(nMusPis);
00896       me["hdMUx"]->Fill(muDx);
00897       me["hdMUy"]->Fill(muDy);
00898 
00899       edm::Handle<GenMETCollection> genTrue;
00900       iEvent.getByLabel("genMetTrue", genTrue);
00901       if (genTrue.isValid()) {
00902         const GenMETCollection *genmetcol = genTrue.product();
00903         const GenMET *genMetTrue = &(genmetcol->front());
00904         double genMET = genMetTrue->pt();
00905         double genMETPhi = genMetTrue->phi();
00906         
00907         me["hMETResolution_GenMETTrue"]->Fill( MET - genMET );
00908         me["hMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
00909       } else {
00910         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetTrue";
00911       }    
00912 
00913 
00914       edm::Handle<GenMETCollection> genCalo;
00915       iEvent.getByLabel("genMetCalo", genCalo);
00916       if (genCalo.isValid()) {
00917         const GenMETCollection *genmetcol = genCalo.product();
00918         const GenMET  *genMetCalo = &(genmetcol->front());
00919         double genMET = genMetCalo->pt();
00920         double genMETPhi = genMetCalo->phi();
00921         
00922         me["hMETResolution_GenMETCalo"]->Fill( MET - genMET );
00923         me["hMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
00924       } else {
00925         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetCalo";
00926       }          
00927     }
00928 
00929   else if( inputMETLabel_.label() == "corMetGlobalMuons" )
00930     {
00931       const CaloMET *corMetGlobalMuons = 0;
00932       edm::Handle<CaloMETCollection> hcorMetGlobalMuonscol;
00933       iEvent.getByLabel(inputMETLabel_, hcorMetGlobalMuonscol );
00934       if(! hcorMetGlobalMuonscol.isValid()){
00935         edm::LogInfo("OutputInfo") << "hcorMetGlobalMuonscol is NOT Valid";
00936         edm::LogInfo("OutputInfo") << "MET Taks continues anyway...!";
00937       }
00938       else
00939         {        
00940           const CaloMETCollection *corMetGlobalMuonscol = hcorMetGlobalMuonscol.product();
00941           corMetGlobalMuons = &(corMetGlobalMuonscol->front());
00942         }
00943 
00944       // Reconstructed TCMET Information                                                                                                     
00945       double SumET = corMetGlobalMuons->sumEt();
00946       double MET = corMetGlobalMuons->pt();
00947       double MEx = corMetGlobalMuons->px();
00948       double MEy = corMetGlobalMuons->py();
00949       double METPhi = corMetGlobalMuons->phi();
00950       double METSig = corMetGlobalMuons->mEtSig();
00951       me["hMEx"]->Fill(MEx);
00952       me["hMEy"]->Fill(MEy);
00953       me["hMET"]->Fill(MET);
00954       me["hMETPhi"]->Fill(METPhi);
00955       me["hSumET"]->Fill(SumET);
00956       me["hMETSig"]->Fill(METSig);
00957       me["hNevents"]->Fill(0.5);
00958 
00959       edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > corMetGlobalMuons_ValueMap_Handle;
00960       iEvent.getByLabel("muonMETValueMapProducer" , "muCorrData", corMetGlobalMuons_ValueMap_Handle);
00961       
00962       edm::Handle< reco::MuonCollection > muon_Handle;
00963       iEvent.getByLabel("muons", muon_Handle);
00964 
00965       edm::Handle< reco::BeamSpot > beamSpot_h;
00966       iEvent.getByLabel(inputBeamSpotLabel_, beamSpot_h);
00967 
00968       if(!beamSpot_h.isValid()){
00969         edm::LogInfo("OutputInfo") << "beamSpot is NOT Valid";
00970         edm::LogInfo("OutputInfo") << "MET Taks continues anyway...!";
00971       }
00972 
00973       math::XYZPoint bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
00974 
00975       for( reco::MuonCollection::const_iterator muonit = muon_Handle->begin(); muonit != muon_Handle->end(); muonit++ ) {
00976 
00977         const reco::TrackRef siTrack = muonit->innerTrack();
00978         const reco::TrackRef globalTrack = muonit->globalTrack();
00979 
00980         me["hmuPt"]->Fill( muonit->p4().pt() );
00981         me["hmuEta"]->Fill( muonit->p4().eta() );
00982         me["hmuNhits"]->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
00983         me["hmuChi2"]->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
00984 
00985         double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
00986 
00987         me["hmuD0"]->Fill( d0 );
00988 
00989         int nHits = globalTrack.isNonnull() ? globalTrack->hitPattern().numberOfValidMuonHits() : -999;
00990 
00991         me["hmuSAhits"]->Fill( nHits );
00992       }
00993 
00994       const unsigned int nMuons = muon_Handle->size();      
00995       for( unsigned int mus = 0; mus < nMuons; mus++ ) 
00996         {
00997           reco::MuonRef muref( muon_Handle, mus);
00998           reco::MuonMETCorrectionData muCorrData = (*corMetGlobalMuons_ValueMap_Handle)[muref];
00999           
01000           me["hMExCorrection"] -> Fill(muCorrData.corrY());
01001           me["hMEyCorrection"] -> Fill(muCorrData.corrX());
01002           me["hMuonCorrectionFlag"]-> Fill(muCorrData.type());
01003         }
01004 
01005            edm::Handle<GenMETCollection> genTrue;
01006       iEvent.getByLabel("genMetTrue", genTrue);
01007       if (genTrue.isValid()) {
01008         const GenMETCollection *genmetcol = genTrue.product();
01009         const GenMET *genMetTrue = &(genmetcol->front());
01010         double genMET = genMetTrue->pt();
01011         double genMETPhi = genMetTrue->phi();
01012         
01013         me["hMETResolution_GenMETTrue"]->Fill( MET - genMET );
01014         me["hMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
01015       } else {
01016         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetTrue";
01017       }    
01018 
01019 
01020       edm::Handle<GenMETCollection> genCalo;
01021       iEvent.getByLabel("genMetCalo", genCalo);
01022       if (genCalo.isValid()) {
01023         const GenMETCollection *genmetcol = genCalo.product();
01024         const GenMET  *genMetCalo = &(genmetcol->front());
01025         double genMET = genMetCalo->pt();
01026         double genMETPhi = genMetCalo->phi();
01027         
01028         me["hMETResolution_GenMETCalo"]->Fill( MET - genMET );
01029         me["hMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
01030       } else {
01031         edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetCalo";
01032       }    
01033       
01034 
01035 
01036     }
01037 
01038 }
01039 
01040 void METTester::endJob() 
01041 { 
01042 }
01043 
01044 //determines if track is "good" - i.e. passes quality and kinematic cuts
01045 bool METTester::isGoodTrack( const reco::TrackRef track, float d0corr ) {
01046 
01047      if( fabs( d0corr ) > maxd0_ ) return false;
01048      if( track->numberOfValidHits() < minhits_ ) return false;
01049      if( track->normalizedChi2() > maxchi2_ ) return false;
01050      if( fabs( track->eta() ) > maxeta_ ) return false;
01051      if( track->pt() > maxpt_ ) return false;
01052      if( (track->ptError() / track->pt()) > maxPtErr_ ) return false;
01053 
01054      int cut = 0;
01055      for( unsigned int i = 0; i < trkQuality_.size(); i++ ) {
01056        
01057           cut |= (1 << trkQuality_.at(i));
01058      }
01059 
01060      if( !( ( track->qualityMask() & cut ) == cut ) ) return false;
01061 
01062      bool isGoodAlgo = false;
01063      if( trkAlgos_.size() == 0 ) isGoodAlgo = true;
01064      for( unsigned int i = 0; i < trkAlgos_.size(); i++ ) {
01065        
01066           if( track->algo() == trkAlgos_.at(i) ) isGoodAlgo = true;
01067      }
01068 
01069      if( !isGoodAlgo ) return false;
01070 
01071      return true;
01072 }
CMSSW_4_4_3_patch1/src/Validation/RecoMET/src/METTester.cc
