Reference Manual

Go to the documentation of this file.
00001 /*
00002  *  See header file for a description of this class.
00003  *
00004  *  $Date: 2011/08/12 15:29:49 $
00005  *  $Revision: 1.54.6.3 $
00006  *  \author F. Chlebana - Fermilab
00007  *          K. Hatakeyama - Rockefeller University
00008  */
00009 
00010 #include "DQMOffline/JetMET/interface/CaloMETAnalyzer.h"
00011 #include "DataFormats/Common/interface/Handle.h"
00012 
00013 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00014 #include "FWCore/Common/interface/TriggerNames.h"
00015 
00016 #include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
00017 #include "DataFormats/CaloTowers/interface/CaloTowerDetId.h"
00018 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
00019 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
00020 
00021 #include "DataFormats/Math/interface/LorentzVector.h"
00022 
00023 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
00024 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
00025 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
00026 
00027 #include "TLorentzVector.h"
00028 
00029 #include <string>
00030 using namespace edm;
00031 
00032 // ***********************************************************
00033 CaloMETAnalyzer::CaloMETAnalyzer(const edm::ParameterSet& pSet) {
00034 
00035   parameters = pSet;
00036 
00037   edm::ParameterSet highptjetparms = parameters.getParameter<edm::ParameterSet>("highPtJetTrigger");
00038   edm::ParameterSet lowptjetparms  = parameters.getParameter<edm::ParameterSet>("lowPtJetTrigger" );
00039   edm::ParameterSet minbiasparms   = parameters.getParameter<edm::ParameterSet>("minBiasTrigger"  );
00040   edm::ParameterSet highmetparms   = parameters.getParameter<edm::ParameterSet>("highMETTrigger"  );
00041   edm::ParameterSet lowmetparms    = parameters.getParameter<edm::ParameterSet>("lowMETTrigger"   );
00042   edm::ParameterSet eleparms       = parameters.getParameter<edm::ParameterSet>("eleTrigger"      );
00043   edm::ParameterSet muonparms      = parameters.getParameter<edm::ParameterSet>("muonTrigger"     );
00044   
00045   _HighPtJetEventFlag = new GenericTriggerEventFlag( highptjetparms );
00046   _LowPtJetEventFlag  = new GenericTriggerEventFlag( lowptjetparms  );
00047   _MinBiasEventFlag   = new GenericTriggerEventFlag( minbiasparms   );
00048   _HighMETEventFlag   = new GenericTriggerEventFlag( highmetparms   );
00049   _LowMETEventFlag    = new GenericTriggerEventFlag( lowmetparms    );
00050   _EleEventFlag       = new GenericTriggerEventFlag( eleparms       );
00051   _MuonEventFlag      = new GenericTriggerEventFlag( muonparms      );
00052 
00053 }
00054 
00055 // ***********************************************************
00056 CaloMETAnalyzer::~CaloMETAnalyzer() { 
00057 
00058   delete _HighPtJetEventFlag;
00059   delete _LowPtJetEventFlag;
00060   delete _MinBiasEventFlag;
00061   delete _HighMETEventFlag;
00062   delete _LowMETEventFlag;
00063   delete _EleEventFlag;
00064   delete _MuonEventFlag;
00065 
00066 }
00067 
00068 // ***********************************************************
00069 void CaloMETAnalyzer::beginJob(DQMStore * dbe) {
00070 
00071   evtCounter = 0;
00072   metname = "caloMETAnalyzer";
00073 
00074   // trigger information
00075   HLTPathsJetMBByName_ = parameters.getParameter<std::vector<std::string > >("HLTPathsJetMB");
00076   
00077   theCleaningParameters = parameters.getParameter<ParameterSet>("CleaningParameters"),
00078 
00079   //Trigger parameters
00080   gtTag          = theCleaningParameters.getParameter<edm::InputTag>("gtLabel");
00081   _techTrigsAND  = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsAND");
00082   _techTrigsOR   = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsOR");
00083   _techTrigsNOT  = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsNOT");
00084 
00085   _doHLTPhysicsOn = theCleaningParameters.getParameter<bool>("doHLTPhysicsOn");
00086   _hlt_PhysDec    = theCleaningParameters.getParameter<std::string>("HLT_PhysDec");
00087 
00088   _tightBHFiltering     = theCleaningParameters.getParameter<bool>("tightBHFiltering");
00089   _tightJetIDFiltering  = theCleaningParameters.getParameter<int>("tightJetIDFiltering");
00090   _tightHcalFiltering   = theCleaningParameters.getParameter<bool>("tightHcalFiltering");
00091 
00092   // ==========================================================
00093   //DCS information
00094   // ==========================================================
00095   DCSFilter = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilter"));
00096 
00097   //Vertex requirements
00098   _doPVCheck          = theCleaningParameters.getParameter<bool>("doPrimaryVertexCheck");
00099   vertexTag  = theCleaningParameters.getParameter<edm::InputTag>("vertexLabel");
00100 
00101   if (_doPVCheck) {
00102     _nvtx_min        = theCleaningParameters.getParameter<int>("nvtx_min");
00103     _nvtxtrks_min    = theCleaningParameters.getParameter<int>("nvtxtrks_min");
00104     _vtxndof_min     = theCleaningParameters.getParameter<int>("vtxndof_min");
00105     _vtxchi2_max     = theCleaningParameters.getParameter<double>("vtxchi2_max");
00106     _vtxz_max        = theCleaningParameters.getParameter<double>("vtxz_max");
00107   }
00108 
00109 
00110   // CaloMET information
00111   theCaloMETCollectionLabel       = parameters.getParameter<edm::InputTag>("METCollectionLabel");
00112   _source                         = parameters.getParameter<std::string>("Source");
00113 
00114   if (theCaloMETCollectionLabel.label() == "corMetGlobalMuons" ) {
00115     inputBeamSpotLabel      = parameters.getParameter<edm::InputTag>("InputBeamSpotLabel");
00116   }
00117   
00118   // Other data collections
00119   theCaloTowersLabel          = parameters.getParameter<edm::InputTag>("CaloTowersLabel");
00120   theJetCollectionLabel       = parameters.getParameter<edm::InputTag>("JetCollectionLabel");
00121   HcalNoiseRBXCollectionTag   = parameters.getParameter<edm::InputTag>("HcalNoiseRBXCollection");
00122   HcalNoiseSummaryTag         = parameters.getParameter<edm::InputTag>("HcalNoiseSummary");
00123   BeamHaloSummaryTag          = parameters.getParameter<edm::InputTag>("BeamHaloSummaryLabel");
00124 
00125   // misc
00126   _verbose     = parameters.getParameter<int>("verbose");
00127   _print       = parameters.getParameter<int>("printOut");
00128   _etThreshold = parameters.getParameter<double>("etThreshold"); // MET threshold
00129   _allhist     = parameters.getParameter<bool>("allHist");       // Full set of monitoring histograms
00130   _allSelection= parameters.getParameter<bool>("allSelection");  // Plot with all sets of event selection
00131   _cleanupSelection= parameters.getParameter<bool>("cleanupSelection");  // Plot with all sets of event selection
00132 
00133   _highPtJetThreshold = parameters.getParameter<double>("HighPtJetThreshold"); // High Pt Jet threshold
00134   _lowPtJetThreshold = parameters.getParameter<double>("LowPtJetThreshold"); // Low Pt Jet threshold
00135   _highMETThreshold = parameters.getParameter<double>("HighMETThreshold"); // High MET threshold
00136   _lowMETThreshold = parameters.getParameter<double>("LowMETThreshold"); // Low MET threshold
00137 
00138   //
00139   jetID = new reco::helper::JetIDHelper(parameters.getParameter<ParameterSet>("JetIDParams"));
00140 
00141   // DQStore stuff
00142   LogTrace(metname)<<"[CaloMETAnalyzer] Parameters initialization";
00143   std::string DirName = "JetMET/MET/"+_source;
00144   dbe->setCurrentFolder(DirName);
00145 
00146   hmetME = dbe->book1D("metReco", "metReco", 4, 1, 5);
00147   hmetME->setBinLabel(1,"CaloMET",1);
00148 
00149   _dbe = dbe;
00150 
00151   _FolderNames.push_back("All");
00152   _FolderNames.push_back("BasicCleanup");
00153   _FolderNames.push_back("ExtraCleanup");
00154   _FolderNames.push_back("HcalNoiseFilter");
00155   _FolderNames.push_back("HcalNoiseFilterTight");
00156   _FolderNames.push_back("JetIDMinimal");
00157   _FolderNames.push_back("JetIDLoose");
00158   _FolderNames.push_back("JetIDTight");
00159   _FolderNames.push_back("BeamHaloIDTightPass");
00160   _FolderNames.push_back("BeamHaloIDLoosePass");
00161   _FolderNames.push_back("Triggers");
00162   _FolderNames.push_back("PV");
00163 
00164   for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); 
00165        ic != _FolderNames.end(); ic++){
00166     if (*ic=="All")             bookMESet(DirName+"/"+*ic);
00167     if (_cleanupSelection){
00168     if (*ic=="BasicCleanup")    bookMESet(DirName+"/"+*ic);
00169     if (*ic=="ExtraCleanup")    bookMESet(DirName+"/"+*ic);
00170     }
00171     if (_allSelection){
00172     if (*ic=="HcalNoiseFilter")      bookMESet(DirName+"/"+*ic);
00173     if (*ic=="HcalNoiseFilterTight") bookMESet(DirName+"/"+*ic);
00174     if (*ic=="JetIDMinimal")         bookMESet(DirName+"/"+*ic);
00175     if (*ic=="JetIDLoose")           bookMESet(DirName+"/"+*ic);
00176     if (*ic=="JetIDTight")           bookMESet(DirName+"/"+*ic);
00177     if (*ic=="BeamHaloIDTightPass")  bookMESet(DirName+"/"+*ic);
00178     if (*ic=="BeamHaloIDLoosePass")  bookMESet(DirName+"/"+*ic);
00179     if (*ic=="Triggers")             bookMESet(DirName+"/"+*ic);
00180     if (*ic=="PV")                   bookMESet(DirName+"/"+*ic);
00181     }
00182   }
00183 
00184 }
00185 
00186 // ***********************************************************
00187 void CaloMETAnalyzer::endJob() {
00188 
00189   delete jetID;
00190   delete DCSFilter;
00191 
00192 }
00193 
00194 // ***********************************************************
00195 void CaloMETAnalyzer::bookMESet(std::string DirName)
00196 {
00197 
00198   bool bLumiSecPlot=false;
00199   if (DirName.find("All")!=std::string::npos) bLumiSecPlot=true;
00200 
00201   bookMonitorElement(DirName,bLumiSecPlot);
00202 
00203   if ( _HighPtJetEventFlag->on() ) {
00204     bookMonitorElement(DirName+"/"+"HighPtJet",false);
00205     hTriggerName_HighPtJet = _dbe->bookString("triggerName_HighPtJet", _hlt_HighPtJet);
00206   }  
00207 
00208   if ( _LowPtJetEventFlag->on() ) {
00209     bookMonitorElement(DirName+"/"+"LowPtJet",false);
00210     hTriggerName_LowPtJet = _dbe->bookString("triggerName_LowPtJet", _hlt_LowPtJet);
00211   }
00212 
00213   if ( _MinBiasEventFlag->on() ) {
00214     bookMonitorElement(DirName+"/"+"MinBias",false);
00215     hTriggerName_MinBias = _dbe->bookString("triggerName_MinBias", _hlt_MinBias);
00216   }
00217 
00218   if ( _HighMETEventFlag->on() ) {
00219     bookMonitorElement(DirName+"/"+"HighMET",false);
00220     hTriggerName_HighMET = _dbe->bookString("triggerName_HighMET", _hlt_HighMET);
00221   }
00222 
00223   if ( _LowMETEventFlag->on() ) {
00224     bookMonitorElement(DirName+"/"+"LowMET",false);
00225     hTriggerName_LowMET = _dbe->bookString("triggerName_LowMET", _hlt_LowMET);
00226   }
00227 
00228   if ( _EleEventFlag->on() ) {
00229     bookMonitorElement(DirName+"/"+"Ele",false);
00230     hTriggerName_Ele = _dbe->bookString("triggerName_Ele", _hlt_Ele);
00231   }
00232 
00233   if ( _MuonEventFlag->on() ) {
00234     bookMonitorElement(DirName+"/"+"Muon",false);
00235     hTriggerName_Muon = _dbe->bookString("triggerName_Muon", _hlt_Muon);
00236   }
00237 }
00238 
00239 // ***********************************************************
00240 void CaloMETAnalyzer::bookMonitorElement(std::string DirName, bool bLumiSecPlot=false)
00241 {
00242 
00243   if (_verbose) std::cout << "bookMonitorElement " << DirName << std::endl;
00244   _dbe->setCurrentFolder(DirName);
00245  
00246   //removed for optimizations//hNevents                = _dbe->book1D("METTask_Nevents",   "METTask_Nevents"   ,1,0,1);
00247   hCaloMEx                = _dbe->book1D("METTask_CaloMEx",   "METTask_CaloMEx"   ,200,-500,500);
00248   hCaloMEx->setAxisTitle("MEx [GeV]",1);
00249   hCaloMEy                = _dbe->book1D("METTask_CaloMEy",   "METTask_CaloMEy"   ,200,-500,500);
00250   hCaloMEy->setAxisTitle("MEy [GeV]",1);
00251   //removed for optimizations//hCaloEz                 = _dbe->book1D("METTask_CaloEz",    "METTask_CaloEz"    ,200,-500,500);
00252   //removed for optimizations//hCaloEz->setAxisTitle("Ez [GeV]",1);
00253   hCaloMETSig             = _dbe->book1D("METTask_CaloMETSig","METTask_CaloMETSig",51,0,51);
00254   hCaloMETSig->setAxisTitle("METSig",1);
00255   hCaloMET                = _dbe->book1D("METTask_CaloMET",   "METTask_CaloMET"   ,200,0,1000);
00256   hCaloMET->setAxisTitle("MET [GeV]",1);
00257   hCaloMET1               = _dbe->book1D("METTask_CaloMET1",  "METTask_CaloMET1"  ,40,0,200);
00258   //meCaloMET->getTH1F()->SetStats(111111);
00259   //meCaloMET->getTH1F()->SetOption("logy");
00260   hCaloMETPhi             = _dbe->book1D("METTask_CaloMETPhi","METTask_CaloMETPhi",60,-TMath::Pi(),TMath::Pi());
00261   hCaloMETPhi->setAxisTitle("METPhi [rad]",1);
00262   hCaloSumET              = _dbe->book1D("METTask_CaloSumET", "METTask_CaloSumET" ,400,0,2000);
00263   hCaloSumET->setAxisTitle("SumET [GeV]",1);
00264 
00265   hCaloMET_logx           = _dbe->book1D("METTask_CaloMET_logx",   "METTask_CaloMET_logx"   ,40,-1.,7.);
00266   hCaloMET_logx->setAxisTitle("log(MET) [GeV]",1);
00267   hCaloSumET_logx         = _dbe->book1D("METTask_CaloSumET_logx", "METTask_CaloSumET_logx" ,40,-1.,7.);
00268   hCaloSumET_logx->setAxisTitle("log(SumET) [GeV]",1);
00269 
00270   //removed for optimizations//hCaloMETIonFeedbck      = _dbe->book1D("METTask_CaloMETIonFeedbck", "METTask_CaloMETIonFeedbck" ,500,0,1000);
00271   //removed for optimizations//hCaloMETIonFeedbck->setAxisTitle("MET [GeV]",1);
00272   //removed for optimizations//hCaloMETHPDNoise        = _dbe->book1D("METTask_CaloMETHPDNoise",   "METTask_CaloMETHPDNoise"   ,500,0,1000);
00273   //removed for optimizations//hCaloMETHPDNoise->setAxisTitle("MET [GeV]",1);
00274   //removed for optimizations//hCaloMETRBXNoise        = _dbe->book1D("METTask_CaloMETRBXNoise",   "METTask_CaloMETRBXNoise"   ,500,0,1000);
00275   //removed for optimizations//hCaloMETRBXNoise->setAxisTitle("MET [GeV]",1);
00276 
00277   //removed for optimizations//hCaloMETPhi002          = _dbe->book1D("METTask_CaloMETPhi002","METTask_CaloMETPhi002",72,-TMath::Pi(),TMath::Pi());
00278   //removed for optimizations//hCaloMETPhi002->setAxisTitle("METPhi [rad] (MET>2 GeV)",1);
00279   //removed for optimizations//hCaloMETPhi010          = _dbe->book1D("METTask_CaloMETPhi010","METTask_CaloMETPhi010",72,-TMath::Pi(),TMath::Pi());
00280   //removed for optimizations//hCaloMETPhi010->setAxisTitle("METPhi [rad] (MET>10 GeV)",1);
00281   hCaloMETPhi020          = _dbe->book1D("METTask_CaloMETPhi020","METTask_CaloMETPhi020",60,-TMath::Pi(),TMath::Pi());
00282   hCaloMETPhi020->setAxisTitle("METPhi [rad] (MET>20 GeV)",1);
00283 
00284   if (_allhist){
00285     if (bLumiSecPlot){
00286       hCaloMExLS              = _dbe->book2D("METTask_CaloMEx_LS","METTask_CaloMEx_LS",200,-200,200,50,0.,500.);
00287       hCaloMExLS->setAxisTitle("MEx [GeV]",1);
00288       hCaloMExLS->setAxisTitle("Lumi Section",2);
00289       hCaloMEyLS              = _dbe->book2D("METTask_CaloMEy_LS","METTask_CaloMEy_LS",200,-200,200,50,0.,500.);
00290       hCaloMEyLS->setAxisTitle("MEy [GeV]",1);
00291       hCaloMEyLS->setAxisTitle("Lumi Section",2);
00292     }
00293 
00294     hCaloMaxEtInEmTowers    = _dbe->book1D("METTask_CaloMaxEtInEmTowers",   "METTask_CaloMaxEtInEmTowers"   ,100,0,2000);
00295     hCaloMaxEtInEmTowers->setAxisTitle("Et(Max) in EM Tower [GeV]",1);
00296     hCaloMaxEtInHadTowers   = _dbe->book1D("METTask_CaloMaxEtInHadTowers",  "METTask_CaloMaxEtInHadTowers"  ,100,0,2000);
00297     hCaloMaxEtInHadTowers->setAxisTitle("Et(Max) in Had Tower [GeV]",1);
00298     hCaloEtFractionHadronic = _dbe->book1D("METTask_CaloEtFractionHadronic","METTask_CaloEtFractionHadronic",100,0,1);
00299     hCaloEtFractionHadronic->setAxisTitle("Hadronic Et Fraction",1);
00300     hCaloEmEtFraction       = _dbe->book1D("METTask_CaloEmEtFraction",      "METTask_CaloEmEtFraction"      ,100,0,1);
00301     hCaloEmEtFraction->setAxisTitle("EM Et Fraction",1);
00302 
00303     //removed for optimizations//hCaloEmEtFraction002    = _dbe->book1D("METTask_CaloEmEtFraction002",   "METTask_CaloEmEtFraction002"      ,100,0,1);
00304     //removed for optimizations//hCaloEmEtFraction002->setAxisTitle("EM Et Fraction (MET>2 GeV)",1);
00305     //removed for optimizations//hCaloEmEtFraction010    = _dbe->book1D("METTask_CaloEmEtFraction010",   "METTask_CaloEmEtFraction010"      ,100,0,1);
00306     //removed for optimizations//hCaloEmEtFraction010->setAxisTitle("EM Et Fraction (MET>10 GeV)",1);
00307     hCaloEmEtFraction020    = _dbe->book1D("METTask_CaloEmEtFraction020",   "METTask_CaloEmEtFraction020"      ,100,0,1);
00308     hCaloEmEtFraction020->setAxisTitle("EM Et Fraction (MET>20 GeV)",1);
00309 
00310     hCaloHadEtInHB          = _dbe->book1D("METTask_CaloHadEtInHB","METTask_CaloHadEtInHB",100,0,2000);
00311     hCaloHadEtInHB->setAxisTitle("Had Et [GeV]",1);
00312     hCaloHadEtInHO          = _dbe->book1D("METTask_CaloHadEtInHO","METTask_CaloHadEtInHO",25,0,500);
00313     hCaloHadEtInHO->setAxisTitle("Had Et [GeV]",1);
00314     hCaloHadEtInHE          = _dbe->book1D("METTask_CaloHadEtInHE","METTask_CaloHadEtInHE",100,0,2000);
00315     hCaloHadEtInHE->setAxisTitle("Had Et [GeV]",1);
00316     hCaloHadEtInHF          = _dbe->book1D("METTask_CaloHadEtInHF","METTask_CaloHadEtInHF",50,0,1000);
00317     hCaloHadEtInHF->setAxisTitle("Had Et [GeV]",1);
00318     hCaloEmEtInHF           = _dbe->book1D("METTask_CaloEmEtInHF" ,"METTask_CaloEmEtInHF" ,25,0,500);
00319     hCaloEmEtInHF->setAxisTitle("EM Et [GeV]",1);
00320     hCaloEmEtInEE           = _dbe->book1D("METTask_CaloEmEtInEE" ,"METTask_CaloEmEtInEE" ,50,0,1000);
00321     hCaloEmEtInEE->setAxisTitle("EM Et [GeV]",1);
00322     hCaloEmEtInEB           = _dbe->book1D("METTask_CaloEmEtInEB" ,"METTask_CaloEmEtInEB" ,100,0,2000);
00323     hCaloEmEtInEB->setAxisTitle("EM Et [GeV]",1);
00324 
00325     hCaloEmMEx= _dbe->book1D("METTask_CaloEmMEx","METTask_CaloEmMEx",200,-500,500);
00326     hCaloEmMEx->setAxisTitle("EM MEx [GeV]",1);
00327     hCaloEmMEy= _dbe->book1D("METTask_CaloEmMEy","METTask_CaloEmMEy",200,-500,500);
00328     hCaloEmMEy->setAxisTitle("EM MEy [GeV]",1);
00329     //removed for optimizations//hCaloEmEz= _dbe->book1D("METTask_CaloEmEz","METTask_CaloEmEz",100,-500,500);
00330     //removed for optimizations//hCaloEmEz->setAxisTitle("EM Ez [GeV]",1);
00331     hCaloEmMET= _dbe->book1D("METTask_CaloEmMET","METTask_CaloEmMET",200,0,1000);
00332     hCaloEmMET->setAxisTitle("EM MET [GeV]",1);
00333     hCaloEmMETPhi= _dbe->book1D("METTask_CaloEmMETPhi","METTask_CaloEmMETPhi",60,-TMath::Pi(),TMath::Pi());
00334     hCaloEmMETPhi->setAxisTitle("EM METPhi [rad]",1);
00335     //removed for optimizations//hCaloEmSumET= _dbe->book1D("METTask_CaloEmSumET","METTask_CaloEmSumET",200,0,2000);
00336     //removed for optimizations//hCaloEmSumET->setAxisTitle("EM SumET [GeV]",1);
00337 
00338     hCaloHaMEx= _dbe->book1D("METTask_CaloHaMEx","METTask_CaloHaMEx",200,-500,500);
00339     hCaloHaMEx->setAxisTitle("HA MEx [GeV]",1);
00340     hCaloHaMEy= _dbe->book1D("METTask_CaloHaMEy","METTask_CaloHaMEy",200,-500,500);
00341     hCaloHaMEy->setAxisTitle("HA MEy [GeV]",1);
00342     //removed for optimizations//hCaloHaEz= _dbe->book1D("METTask_CaloHaEz","METTask_CaloHaEz",100,-500,500);
00343     //removed for optimizations//hCaloHaEz->setAxisTitle("HA Ez [GeV]",1);
00344     hCaloHaMET= _dbe->book1D("METTask_CaloHaMET","METTask_CaloHaMET",200,0,1000);
00345     hCaloHaMET->setAxisTitle("HA MET [GeV]",1);
00346     hCaloHaMETPhi= _dbe->book1D("METTask_CaloHaMETPhi","METTask_CaloHaMETPhi",60,-TMath::Pi(),TMath::Pi());
00347     hCaloHaMETPhi->setAxisTitle("HA METPhi [rad]",1);
00348     //removed for optimizations//hCaloHaSumET= _dbe->book1D("METTask_CaloHaSumET","METTask_CaloHaSumET",200,0,2000);
00349     //removed for optimizations//hCaloHaSumET->setAxisTitle("HA SumET [GeV]",1);
00350   }
00351   
00352   if (theCaloMETCollectionLabel.label() == "corMetGlobalMuons" ) {
00353     hCalomuPt    = _dbe->book1D("METTask_CalomuonPt", "METTask_CalomuonPt", 50, 0, 500);
00354     hCalomuEta   = _dbe->book1D("METTask_CalomuonEta", "METTask_CalomuonEta", 60, -3.0, 3.0);
00355     hCalomuNhits = _dbe->book1D("METTask_CalomuonNhits", "METTask_CalomuonNhits", 50, 0, 50);
00356     hCalomuChi2  = _dbe->book1D("METTask_CalomuonNormalizedChi2", "METTask_CalomuonNormalizedChi2", 20, 0, 20);
00357     hCalomuD0    = _dbe->book1D("METTask_CalomuonD0", "METTask_CalomuonD0", 50, -1, 1);
00358     hCaloMExCorrection       = _dbe->book1D("METTask_CaloMExCorrection", "METTask_CaloMExCorrection", 100, -500.0,500.0);
00359     hCaloMEyCorrection       = _dbe->book1D("METTask_CaloMEyCorrection", "METTask_CaloMEyCorrection", 100, -500.0,500.0);
00360     hCaloMuonCorrectionFlag  = _dbe->book1D("METTask_CaloCorrectionFlag","METTask_CaloCorrectionFlag", 5, -0.5, 4.5);
00361   }
00362 
00363 }
00364 
00365 // ***********************************************************
00366 void CaloMETAnalyzer::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
00367 {
00368 
00369   if ( _HighPtJetEventFlag->on() ) _HighPtJetEventFlag->initRun( iRun, iSetup );
00370   if ( _LowPtJetEventFlag ->on() ) _LowPtJetEventFlag ->initRun( iRun, iSetup );
00371   if ( _MinBiasEventFlag  ->on() ) _MinBiasEventFlag  ->initRun( iRun, iSetup );
00372   if ( _HighMETEventFlag  ->on() ) _HighMETEventFlag  ->initRun( iRun, iSetup );
00373   if ( _LowMETEventFlag   ->on() ) _LowMETEventFlag   ->initRun( iRun, iSetup );
00374   if ( _EleEventFlag      ->on() ) _EleEventFlag      ->initRun( iRun, iSetup );
00375   if ( _MuonEventFlag     ->on() ) _MuonEventFlag     ->initRun( iRun, iSetup );
00376 
00377 }
00378 
00379 // ***********************************************************
00380 void CaloMETAnalyzer::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup, DQMStore * dbe)
00381 {
00382   
00383   //
00384   //--- Check the time length of the Run from the lumi section plots
00385 
00386   std::string dirName = "JetMET/MET/"+_source+"/";
00387   _dbe->setCurrentFolder(dirName);
00388 
00389   TH1F* tlumisec;
00390 
00391   MonitorElement *meLumiSec = _dbe->get("aaa");
00392   meLumiSec = _dbe->get("JetMET/lumisec");
00393 
00394   int totlsec=0;
00395   double totltime=0.;
00396   if ( meLumiSec->getRootObject() ) {
00397     tlumisec = meLumiSec->getTH1F();
00398     for (int i=0; i<500; i++){
00399       if (tlumisec->GetBinContent(i+1)) totlsec++;
00400     }
00401     totltime = double(totlsec*90); // one lumi sec ~ 90 (sec)
00402   }
00403 
00404   if (totltime==0.) totltime=1.; 
00405 
00406   //
00407   //--- Make the integrated plots with rate (Hz)
00408 
00409   for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); ic != _FolderNames.end(); ic++)
00410     {
00411 
00412       std::string DirName;
00413       DirName = dirName+*ic;
00414 
00415       makeRatePlot(DirName,totltime);
00416       if ( _HighPtJetEventFlag->on() ) 
00417         makeRatePlot(DirName+"/"+"triggerName_HighJetPt",totltime);
00418       if ( _LowPtJetEventFlag->on() ) 
00419         makeRatePlot(DirName+"/"+"triggerName_LowJetPt",totltime);
00420       if ( _MinBiasEventFlag->on() ) 
00421         makeRatePlot(DirName+"/"+"triggerName_MinBias",totltime);
00422       if ( _HighMETEventFlag->on() ) 
00423         makeRatePlot(DirName+"/"+"triggerName_HighMET",totltime);
00424       if ( _LowMETEventFlag->on() ) 
00425         makeRatePlot(DirName+"/"+"triggerName_LowMET",totltime);
00426       if ( _EleEventFlag->on() ) 
00427         makeRatePlot(DirName+"/"+"triggerName_Ele",totltime);
00428       if ( _MuonEventFlag->on() ) 
00429         makeRatePlot(DirName+"/"+"triggerName_Muon",totltime);
00430     }
00431 
00432 }
00433 
00434 // ***********************************************************
00435 void CaloMETAnalyzer::makeRatePlot(std::string DirName, double totltime)
00436 {
00437 
00438   _dbe->setCurrentFolder(DirName);
00439   MonitorElement *meCaloMET = _dbe->get(DirName+"/"+"METTask_CaloMET");
00440 
00441   TH1F* tCaloMET;
00442   TH1F* tCaloMETRate;
00443 
00444   if ( meCaloMET )
00445     if ( meCaloMET->getRootObject() ) {
00446       tCaloMET     = meCaloMET->getTH1F();
00447       
00448       // Integral plot & convert number of events to rate (hz)
00449       tCaloMETRate = (TH1F*) tCaloMET->Clone("METTask_CaloMETRate");
00450       for (int i = tCaloMETRate->GetNbinsX()-1; i>=0; i--){
00451         tCaloMETRate->SetBinContent(i+1,tCaloMETRate->GetBinContent(i+2)+tCaloMET->GetBinContent(i+1));
00452       }
00453       for (int i = 0; i<tCaloMETRate->GetNbinsX(); i++){
00454         tCaloMETRate->SetBinContent(i+1,tCaloMETRate->GetBinContent(i+1)/double(totltime));
00455       }      
00456 
00457       tCaloMETRate->SetName("METTask_CaloMETRate");
00458       tCaloMETRate->SetTitle("METTask_CaloMETRate");
00459       hCaloMETRate = _dbe->book1D("METTask_CaloMETRate",tCaloMETRate);
00460       hCaloMETRate->setAxisTitle("MET Threshold [GeV]",1);
00461     }
00462 }
00463 
00464 
00465 // ***********************************************************
00466 void CaloMETAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup, 
00467                               const edm::TriggerResults& triggerResults) {
00468 
00469   if (_verbose) std::cout << "CaloMETAnalyzer analyze" << std::endl;
00470 
00471   std::string DirName = "JetMET/MET/"+_source;
00472 
00473   if (_print){
00474   std::cout << " " << std::endl;
00475   std::cout << "Event = " << iEvent.id().event() << std::endl;
00476   }
00477 
00478   LogTrace(metname)<<"[CaloMETAnalyzer] Analyze CaloMET";
00479 
00480   hmetME->Fill(1);
00481 
00482   // ==========================================================  
00483   // Trigger information 
00484   //
00485   _trig_JetMB=0;
00486   _trig_HighPtJet=0;
00487   _trig_LowPtJet=0;
00488   _trig_MinBias=0;
00489   _trig_HighMET=0;
00490   _trig_LowMET=0;
00491   _trig_Ele=0;
00492   _trig_Muon=0;
00493   _trig_PhysDec=0;
00494   if(&triggerResults) {   
00495     
00497     
00498     //
00499     //
00500     // Check how many HLT triggers are in triggerResults 
00501     int ntrigs = triggerResults.size();
00502     if (_verbose) std::cout << "ntrigs=" << ntrigs << std::endl;
00503     
00504     //
00505     //
00506     // If index=ntrigs, this HLT trigger doesn't exist in the HLT table for this data.
00507     const edm::TriggerNames & triggerNames = iEvent.triggerNames(triggerResults);
00508 
00509     //
00510     //
00511     // count number of requested Jet or MB HLT paths which have fired
00512     for (unsigned int i=0; i!=HLTPathsJetMBByName_.size(); i++) {
00513       unsigned int triggerIndex = triggerNames.triggerIndex(HLTPathsJetMBByName_[i]);
00514       if (triggerIndex<triggerResults.size()) {
00515         if (triggerResults.accept(triggerIndex)) {
00516           _trig_JetMB++;
00517         }
00518       }
00519     }
00520     // for empty input vectors (n==0), take all HLT triggers!
00521     if (HLTPathsJetMBByName_.size()==0) _trig_JetMB=triggerResults.size()-1;
00522 
00523     if ( _HighPtJetEventFlag->on() && _HighPtJetEventFlag->accept( iEvent, iSetup ) ) 
00524       _trig_HighPtJet=1;
00525 
00526     if ( _LowPtJetEventFlag->on() && _LowPtJetEventFlag->accept( iEvent, iSetup ) ) 
00527       _trig_LowPtJet=1;
00528     
00529     if ( _MinBiasEventFlag->on() && _MinBiasEventFlag->accept( iEvent, iSetup ) ) 
00530       _trig_MinBias=1;
00531     
00532     if ( _HighMETEventFlag->on() && _HighMETEventFlag->accept( iEvent, iSetup ) ) 
00533       _trig_HighMET=1;
00534     
00535     if ( _LowMETEventFlag->on() && _LowMETEventFlag->accept( iEvent, iSetup ) ) 
00536       _trig_LowMET=1;
00537     
00538     if ( _EleEventFlag->on() && _EleEventFlag->accept( iEvent, iSetup ) ) 
00539       _trig_Ele=1;
00540     
00541     if ( _MuonEventFlag->on() && _MuonEventFlag->accept( iEvent, iSetup ) ) 
00542       _trig_Muon=1;
00543     
00544     if (triggerNames.triggerIndex(_hlt_PhysDec)   != triggerNames.size() &&
00545         triggerResults.accept(triggerNames.triggerIndex(_hlt_PhysDec)))   _trig_PhysDec=1;
00546     
00547   } else {
00548 
00549     edm::LogInfo("CaloMetAnalyzer") << "TriggerResults::HLT not found, "
00550         "automatically select events"; 
00551     //
00552     // TriggerResults object not found. Look at all events.    
00553     _trig_JetMB=1;
00554     
00555   }
00556   
00557   // ==========================================================  
00558   // CaloMET information
00559 
00560   // **** Get the MET container  
00561   edm::Handle<reco::CaloMETCollection> calometcoll;
00562   iEvent.getByLabel(theCaloMETCollectionLabel, calometcoll);
00563 
00564   if(!calometcoll.isValid()) {
00565     std::cout<<"Unable to find MET results for CaloMET collection "<<theCaloMETCollectionLabel<<std::endl;
00566     return;
00567   }
00568 
00569   const reco::CaloMETCollection *calometcol = calometcoll.product();
00570   const reco::CaloMET *calomet;
00571   calomet = &(calometcol->front());
00572   
00573   LogTrace(metname)<<"[CaloMETAnalyzer] Call to the CaloMET analyzer";
00574 
00575   //Only for corMetGlobalMuons
00576   if (theCaloMETCollectionLabel.label() == "corMetGlobalMuons" ) {
00577     
00578     iEvent.getByLabel("muonMETValueMapProducer" , "muCorrData", corMetGlobalMuons_ValueMap_Handle);
00579     iEvent.getByLabel("muons", muon_h);
00580     iEvent.getByLabel(inputBeamSpotLabel, beamSpot_h);
00581     
00582     if(!beamSpot_h.isValid()) edm::LogInfo("OutputInfo") << "falied to retrieve beam spot data require by MET Task";
00583     
00584     bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
00585     
00586   }
00587 
00588 
00589   // ==========================================================
00590   //
00591   edm::Handle<reco::HcalNoiseRBXCollection> HRBXCollection;
00592   iEvent.getByLabel(HcalNoiseRBXCollectionTag,HRBXCollection);
00593   if (!HRBXCollection.isValid()) {
00594       LogDebug("") << "CaloMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
00595       if (_verbose) std::cout << "CaloMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
00596   }
00597   
00598   edm::Handle<HcalNoiseSummary> HNoiseSummary;
00599   iEvent.getByLabel(HcalNoiseSummaryTag,HNoiseSummary);
00600   if (!HNoiseSummary.isValid()) {
00601     LogDebug("") << "CaloMETAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
00602     if (_verbose) std::cout << "CaloMETAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
00603   }
00604   
00605   edm::Handle<reco::CaloJetCollection> caloJets;
00606   iEvent.getByLabel(theJetCollectionLabel, caloJets);
00607   if (!caloJets.isValid()) {
00608     LogDebug("") << "CaloMETAnalyzer: Could not find jet product" << std::endl;
00609     if (_verbose) std::cout << "CaloMETAnalyzer: Could not find jet product" << std::endl;
00610   }
00611 
00612   edm::Handle<edm::View<reco::Candidate> > towers;
00613   iEvent.getByLabel(theCaloTowersLabel, towers);
00614   if (!towers.isValid()) {
00615     LogDebug("") << "CaloMETAnalyzer: Could not find caltower product" << std::endl;
00616     if (_verbose) std::cout << "CaloMETAnalyzer: Could not find caltower product" << std::endl;
00617   }
00618  
00619   // ==========================================================
00620   // CaloMET sanity check
00621 
00622   if (_source=="CaloMET") validateMET(*calomet,towers);
00623 
00624   // ==========================================================
00625 
00626   if (_allhist) computeEmHaMET(towers);
00627     
00628   // ==========================================================
00629   // JetID 
00630 
00631   if (_verbose) std::cout << "JetID starts" << std::endl;
00632   
00633   //
00634   // --- Minimal cuts
00635   //
00636   bool bJetIDMinimal=true;
00637   int nj=0;
00638   for (reco::CaloJetCollection::const_iterator cal = caloJets->begin(); 
00639        cal!=caloJets->end(); ++cal){
00640     jetID->calculate(iEvent, *cal);
00641     if (_print && nj<=1) std::cout << "Jet pT = " << cal->pt() << " (GeV) "
00642                                    << " eta = " << cal->eta() << " "
00643                                    << " phi = " << cal->phi() << " "
00644                                    << " emf = " << cal->emEnergyFraction() << std::endl;
00645     nj++;
00646     if (cal->pt()>10.){
00647       if (fabs(cal->eta())<=2.6 && 
00648           cal->emEnergyFraction()<=0.01) bJetIDMinimal=false;
00649     }
00650   }
00651 
00652   //
00653   // --- Loose cuts
00654   //
00655   bool bJetIDLoose=true;
00656   for (reco::CaloJetCollection::const_iterator cal = caloJets->begin(); 
00657        cal!=caloJets->end(); ++cal){
00658     jetID->calculate(iEvent, *cal);
00659     if (_verbose) std::cout << jetID->n90Hits() << " " 
00660                             << jetID->restrictedEMF() << " "
00661                             << cal->pt() << std::endl;
00662     if (cal->pt()>10.){
00663       //
00664       // for all regions
00665       if (jetID->n90Hits()<2)  bJetIDLoose=false; 
00666       if (jetID->fHPD()>=0.98) bJetIDLoose=false; 
00667       //
00668       // for non-forward
00669       if (fabs(cal->eta())<2.55){
00670         if (cal->emEnergyFraction()<=0.01) bJetIDLoose=false; 
00671       }
00672       // for forward
00673       else {
00674         if (cal->emEnergyFraction()<=-0.9) bJetIDLoose=false; 
00675         if (cal->pt()>80.){
00676         if (cal->emEnergyFraction()>= 1.0) bJetIDLoose=false; 
00677         }
00678       } // forward vs non-forward
00679     }   // pt>10 GeV/c
00680   }     // calor-jets loop
00681 
00682   //
00683   // --- Tight cuts
00684   //
00685   bool bJetIDTight=true;
00686   bJetIDTight=bJetIDLoose;
00687   for (reco::CaloJetCollection::const_iterator cal = caloJets->begin(); 
00688        cal!=caloJets->end(); ++cal){
00689     jetID->calculate(iEvent, *cal);
00690     if (cal->pt()>25.){
00691       //
00692       // for all regions
00693       if (jetID->fHPD()>=0.95) bJetIDTight=false; 
00694       //
00695       // for 1.0<|eta|<1.75
00696       if (fabs(cal->eta())>=1.00 && fabs(cal->eta())<1.75){
00697         if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false; 
00698       }
00699       //
00700       // for 1.75<|eta|<2.55
00701       else if (fabs(cal->eta())>=1.75 && fabs(cal->eta())<2.55){
00702         if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false; 
00703       }
00704       //
00705       // for 2.55<|eta|<3.25
00706       else if (fabs(cal->eta())>=2.55 && fabs(cal->eta())<3.25){
00707         if (cal->pt()< 50.                   && cal->emEnergyFraction()<=-0.3) bJetIDTight=false; 
00708         if (cal->pt()>=50. && cal->pt()< 80. && cal->emEnergyFraction()<=-0.2) bJetIDTight=false; 
00709         if (cal->pt()>=80. && cal->pt()<340. && cal->emEnergyFraction()<=-0.1) bJetIDTight=false; 
00710         if (cal->pt()>=340.                  && cal->emEnergyFraction()<=-0.1 
00711                                              && cal->emEnergyFraction()>=0.95) bJetIDTight=false; 
00712       }
00713       //
00714       // for 3.25<|eta|
00715       else if (fabs(cal->eta())>=3.25){
00716         if (cal->pt()< 50.                   && cal->emEnergyFraction()<=-0.3
00717                                              && cal->emEnergyFraction()>=0.90) bJetIDTight=false; 
00718         if (cal->pt()>=50. && cal->pt()<130. && cal->emEnergyFraction()<=-0.2
00719                                              && cal->emEnergyFraction()>=0.80) bJetIDTight=false; 
00720         if (cal->pt()>=130.                  && cal->emEnergyFraction()<=-0.1 
00721                                              && cal->emEnergyFraction()>=0.70) bJetIDTight=false; 
00722       }
00723     }   // pt>10 GeV/c
00724   }     // calor-jets loop
00725   
00726   if (_verbose) std::cout << "JetID ends" << std::endl;
00727      
00728   // ==========================================================
00729   // HCAL Noise filter
00730   
00731   bool bHcalNoiseFilter      = HNoiseSummary->passLooseNoiseFilter();
00732   bool bHcalNoiseFilterTight = HNoiseSummary->passTightNoiseFilter();
00733 
00734   if (_verbose) std::cout << "HcalNoiseFilter Summary ends" << std::endl;
00735 
00736   // ==========================================================
00737   // Get BeamHaloSummary
00738   edm::Handle<reco::BeamHaloSummary> TheBeamHaloSummary ;
00739   iEvent.getByLabel(BeamHaloSummaryTag, TheBeamHaloSummary) ;
00740 
00741   bool bBeamHaloIDTightPass = true;
00742   bool bBeamHaloIDLoosePass = true;
00743   
00744   if(TheBeamHaloSummary.isValid()) {
00745     
00746     const reco::BeamHaloSummary TheSummary = (*TheBeamHaloSummary.product() );
00747     
00748     //   std::cout << TheSummary.EcalLooseHaloId() << " "
00749     //      << TheSummary.HcalLooseHaloId() << " "
00750     //      << TheSummary.CSCLooseHaloId()  << " "
00751     //      << TheSummary.GlobalLooseHaloId() << std::endl;
00752     
00753     if( TheSummary.EcalLooseHaloId()  || TheSummary.HcalLooseHaloId() || 
00754         TheSummary.CSCLooseHaloId()   || TheSummary.GlobalLooseHaloId() )
00755       bBeamHaloIDLoosePass = false;
00756     
00757     if( TheSummary.EcalTightHaloId()  || TheSummary.HcalTightHaloId() || 
00758         TheSummary.CSCTightHaloId()   || TheSummary.GlobalTightHaloId() )
00759       bBeamHaloIDTightPass = false;
00760     
00761   }
00762   
00763   if (_verbose) std::cout << "BeamHaloSummary ends" << std::endl;
00764   
00765   // ==========================================================
00766   //Vertex information
00767   
00768   bool bPrimaryVertex = true;
00769   if(_doPVCheck){
00770     bPrimaryVertex = false;
00771     Handle<reco::VertexCollection> vertexHandle;
00772 
00773     iEvent.getByLabel(vertexTag, vertexHandle);
00774 
00775     if (!vertexHandle.isValid()) {
00776       LogDebug("") << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
00777       if (_verbose) std::cout << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
00778     }
00779     
00780     if ( vertexHandle.isValid() ){
00781       reco::VertexCollection vertexCollection = *(vertexHandle.product());
00782       int vertex_number     = vertexCollection.size();
00783       reco::VertexCollection::const_iterator v = vertexCollection.begin();
00784       double vertex_chi2    = v->normalizedChi2();
00785       double vertex_ndof    = v->ndof();
00786       bool   fakeVtx        = v->isFake();
00787       double vertex_Z       = v->z();
00788       
00789       if (  !fakeVtx
00790             && vertex_number>=_nvtx_min
00791             && vertex_ndof   >_vtxndof_min
00792             && vertex_chi2   <_vtxchi2_max
00793             && fabs(vertex_Z)<_vtxz_max ) 
00794         bPrimaryVertex = true;
00795     }
00796   }
00797   // ==========================================================
00798 
00799   edm::Handle< L1GlobalTriggerReadoutRecord > gtReadoutRecord;
00800   iEvent.getByLabel( gtTag, gtReadoutRecord);
00801 
00802   if (!gtReadoutRecord.isValid()) {
00803     LogDebug("") << "CaloMETAnalyzer: Could not find GT readout record" << std::endl;
00804     if (_verbose) std::cout << "CaloMETAnalyzer: Could not find GT readout record product" << std::endl;
00805   }
00806   
00807   bool bTechTriggers    = true;
00808   bool bTechTriggersAND = true;
00809   bool bTechTriggersOR  = false;
00810   bool bTechTriggersNOT = false;
00811 
00812   if (gtReadoutRecord.isValid()) {
00813     const TechnicalTriggerWord&  technicalTriggerWordBeforeMask = gtReadoutRecord->technicalTriggerWord();
00814 
00815     if (_techTrigsAND.size() == 0)
00816       bTechTriggersAND = true;
00817     else
00818       for (unsigned ttr = 0; ttr != _techTrigsAND.size(); ttr++) {
00819         bTechTriggersAND = bTechTriggersAND && technicalTriggerWordBeforeMask.at(_techTrigsAND.at(ttr));
00820       }
00821     
00822     if (_techTrigsAND.size() == 0)
00823       bTechTriggersOR = true;
00824     else
00825       for (unsigned ttr = 0; ttr != _techTrigsOR.size(); ttr++) {
00826         bTechTriggersOR = bTechTriggersOR || technicalTriggerWordBeforeMask.at(_techTrigsOR.at(ttr));
00827       }
00828     if (_techTrigsNOT.size() == 0)
00829       bTechTriggersNOT = false;
00830     else
00831       for (unsigned ttr = 0; ttr != _techTrigsNOT.size(); ttr++) {
00832         bTechTriggersNOT = bTechTriggersNOT || technicalTriggerWordBeforeMask.at(_techTrigsNOT.at(ttr));
00833       }
00834   }
00835   else
00836     {
00837       bTechTriggersAND = true;
00838       bTechTriggersOR  = true;
00839       bTechTriggersNOT = false;
00840     }
00841     
00842   if (_techTrigsAND.size()==0)
00843     bTechTriggersAND = true;
00844   if (_techTrigsOR.size()==0)
00845     bTechTriggersOR = true;
00846   if (_techTrigsNOT.size()==0)
00847     bTechTriggersNOT = false;
00848   
00849   bTechTriggers = bTechTriggersAND && bTechTriggersOR && !bTechTriggersNOT;
00850     
00851   // ==========================================================
00852   // Reconstructed MET Information - fill MonitorElements
00853   
00854   bool bHcalNoise   = bHcalNoiseFilter;
00855   bool bBeamHaloID  = bBeamHaloIDLoosePass;
00856   bool bJetID       = bJetIDMinimal;
00857 
00858   bool bPhysicsDeclared = true;
00859   if(_doHLTPhysicsOn) bPhysicsDeclared =_trig_PhysDec;
00860 
00861   if      (_tightHcalFiltering)     bHcalNoise  = bHcalNoiseFilterTight;
00862   if      (_tightBHFiltering)       bBeamHaloID = bBeamHaloIDTightPass;
00863 
00864   if      (_tightJetIDFiltering==1)  bJetID      = bJetIDMinimal;
00865   else if (_tightJetIDFiltering==2)  bJetID      = bJetIDLoose;
00866   else if (_tightJetIDFiltering==3)  bJetID      = bJetIDTight;
00867   else if (_tightJetIDFiltering==-1) bJetID      = true;
00868 
00869   bool bBasicCleanup = bTechTriggers && bPrimaryVertex && bPhysicsDeclared;
00870   bool bExtraCleanup = bBasicCleanup && bHcalNoise && bJetID && bBeamHaloID;
00871 
00872   //std::string DirName = "JetMET/MET/"+_source;
00873   
00874   for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); 
00875        ic != _FolderNames.end(); ic++){
00876     if (*ic=="All")                                             fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00877     if (DCSFilter->filter(iEvent, iSetup)) {
00878     if (_cleanupSelection){
00879     if (*ic=="BasicCleanup"   && bBasicCleanup)                 fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00880     if (*ic=="ExtraCleanup"   && bExtraCleanup)                 fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00881     }
00882     if (_allSelection) {
00883       if (*ic=="HcalNoiseFilter"      && bHcalNoiseFilter )       fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00884       if (*ic=="HcalNoiseFilterTight" && bHcalNoiseFilterTight )  fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00885       if (*ic=="JetIDMinimal"         && bJetIDMinimal)           fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00886       if (*ic=="JetIDLoose"           && bJetIDLoose)             fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00887       if (*ic=="JetIDTight"           && bJetIDTight)             fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00888       if (*ic=="BeamHaloIDTightPass"  && bBeamHaloIDTightPass)    fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00889       if (*ic=="BeamHaloIDLoosePass"  && bBeamHaloIDLoosePass)    fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00890       if (*ic=="Triggers"             && bTechTriggers)           fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00891       if (*ic=="PV"                   && bPrimaryVertex)          fillMESet(iEvent, DirName+"/"+*ic, *calomet);
00892     }
00893     } // DCS
00894   }
00895 }
00896 
00897 // ***********************************************************
00898 void CaloMETAnalyzer::computeEmHaMET(edm::Handle<edm::View<reco::Candidate> > towers)
00899 {
00900 
00901   edm::View<reco::Candidate>::const_iterator towerCand = towers->begin();
00902   
00903   double sum_em_et = 0.0;
00904   double sum_em_ex = 0.0;
00905   double sum_em_ey = 0.0;
00906   double sum_em_ez = 0.0;
00907   
00908   double sum_ha_et = 0.0;
00909   double sum_ha_ex = 0.0;
00910   double sum_ha_ey = 0.0;
00911   double sum_ha_ez = 0.0;
00912   
00913   for ( ; towerCand != towers->end(); towerCand++)
00914     {
00915       const reco::Candidate* candidate = &(*towerCand);
00916       if (candidate)
00917         {
00918           const CaloTower* calotower = dynamic_cast<const CaloTower*> (candidate);
00919           if (calotower){
00920             double Tower_ET = calotower->et();
00921             if (Tower_ET>0.3) {
00922               
00923               double phi   = candidate->phi();
00924               double theta = candidate->theta();
00925               //double e     = candidate->energy();
00926               double e_em  = calotower->emEnergy();
00927               double e_ha  = calotower->hadEnergy();
00928               double et_em = e_em*sin(theta);
00929               double et_ha = e_ha*sin(theta);
00930 
00931               sum_em_ez += e_em*cos(theta);
00932               sum_em_et += et_em;
00933               sum_em_ex += et_em*cos(phi);
00934               sum_em_ey += et_em*sin(phi);
00935 
00936               sum_ha_ez += e_ha*cos(theta);
00937               sum_ha_et += et_ha;
00938               sum_ha_ex += et_ha*cos(phi);
00939               sum_ha_ey += et_ha*sin(phi);
00940 
00941             } // Et>0.5
00942           }   // calotower
00943         }     // candidate
00944     }         // loop
00945   
00946   //
00947   _EmMEx = -sum_em_ex;
00948   _EmMEy = -sum_em_ey;
00949   _EmMET = pow(_EmMEx*_EmMEx+_EmMEy*_EmMEy,0.5);
00950   _EmCaloEz = sum_em_ez;
00951   _EmSumEt  = sum_em_et;
00952   _EmMetPhi   = atan2( _EmMEy, _EmMEx ); 
00953   //
00954   _HaMEx = -sum_ha_ex;
00955   _HaMEy = -sum_ha_ey;
00956   _HaMET = pow(_HaMEx*_HaMEx+_HaMEy*_HaMEy,0.5);
00957   _HaCaloEz = sum_ha_ez;
00958   _HaSumEt  = sum_ha_et;
00959   _HaMetPhi   = atan2( _HaMEy, _HaMEx ); 
00960   
00961 }
00962 // ***********************************************************
00963 void CaloMETAnalyzer::validateMET(const reco::CaloMET& calomet, 
00964                                   edm::Handle<edm::View<reco::Candidate> > towers)
00965 {
00966 
00967   edm::View<reco::Candidate>::const_iterator towerCand = towers->begin();
00968   
00969   double sum_et = 0.0;
00970   double sum_ex = 0.0;
00971   double sum_ey = 0.0;
00972   double sum_ez = 0.0;
00973   
00974   for ( ; towerCand != towers->end(); towerCand++)
00975     {
00976       const reco::Candidate* candidate = &(*towerCand);
00977       if (candidate)
00978         {
00979           const CaloTower* calotower = dynamic_cast<const CaloTower*> (candidate);
00980           if (calotower){
00981             double Tower_ET = calotower->et();
00982             if (Tower_ET>0.3) {
00983               
00984               double phi   = candidate->phi();
00985               double theta = candidate->theta();
00986               double e     = candidate->energy();
00987               double et    = e*sin(theta);
00988               sum_ez += e*cos(theta);
00989               sum_et += et;
00990               sum_ex += et*cos(phi);
00991               sum_ey += et*sin(phi);
00992 
00993             } // Et>0.5
00994           }   // calotower
00995         }     // candidate
00996     }         // loop
00997   
00998   double Mex   = -sum_ex;
00999   double Mey   = -sum_ey;
01000   //double Mez   = -sum_ez;
01001   double Met   = sqrt( sum_ex*sum_ex + sum_ey*sum_ey );
01002   double Sumet = sum_et;
01003   //double MetPhi   = atan2( -sum_ey, -sum_ex ); // since MET is now a candidate,
01004   
01005   if (_verbose){
01006     if (Sumet!=calomet.sumEt() || Mex!=calomet.px() || Mey!=calomet.py() || Met!=calomet.pt() ){
01007       std::cout << _source << std::endl;
01008       std::cout << "SUMET" << Sumet << " METBlock" << calomet.sumEt() << std::endl;
01009       std::cout << "MEX"   << Mex   << " METBlock" << calomet.px()    << std::endl;
01010       std::cout << "MEY"   << Mey   << " METBlock" << calomet.py()    << std::endl;
01011       std::cout << "MET"   << Met   << " METBlock" << calomet.pt()    << std::endl;
01012     }
01013   }  
01014 
01015   if (_print){
01016     std::cout << "SUMET = " << calomet.sumEt() << " (GeV) "
01017               << "MEX"   << calomet.px() << " (GeV) "
01018               << "MEY"   << calomet.py() << " (GeV) " 
01019               << "MET"   << calomet.pt() << " (GeV) " << std::endl;
01020   }
01021 
01022 }
01023 
01024 // ***********************************************************
01025 void CaloMETAnalyzer::fillMESet(const edm::Event& iEvent, std::string DirName, 
01026                                 const reco::CaloMET& calomet)
01027 {
01028 
01029   _dbe->setCurrentFolder(DirName);
01030 
01031   bool bLumiSecPlot=false;
01032   if (DirName.find("All")) bLumiSecPlot=true;
01033 
01034   if (_trig_JetMB)
01035     fillMonitorElement(iEvent,DirName,"",calomet, bLumiSecPlot);
01036   if (_trig_HighPtJet)
01037     fillMonitorElement(iEvent,DirName,"HighPtJet",calomet,false);
01038   if (_trig_LowPtJet)
01039     fillMonitorElement(iEvent,DirName,"LowPtJet",calomet,false);
01040   if (_trig_MinBias)
01041     fillMonitorElement(iEvent,DirName,"MinBias",calomet,false);
01042   if (_trig_HighMET)
01043     fillMonitorElement(iEvent,DirName,"HighMET",calomet,false);
01044   if (_trig_LowMET)
01045     fillMonitorElement(iEvent,DirName,"LowMET",calomet,false);
01046   if (_trig_Ele)
01047     fillMonitorElement(iEvent,DirName,"Ele",calomet,false);
01048   if (_trig_Muon)
01049     fillMonitorElement(iEvent,DirName,"Muon",calomet,false);
01050 
01051 }
01052 
01053 // ***********************************************************
01054 void CaloMETAnalyzer::fillMonitorElement(const edm::Event& iEvent, std::string DirName, 
01055                                          std::string TriggerTypeName, 
01056                                          const reco::CaloMET& calomet, bool bLumiSecPlot)
01057 {
01058 
01059   if (TriggerTypeName=="HighPtJet") {
01060     if (!selectHighPtJetEvent(iEvent)) return;
01061   }
01062   else if (TriggerTypeName=="LowPtJet") {
01063     if (!selectLowPtJetEvent(iEvent)) return;
01064   }
01065   else if (TriggerTypeName=="HighMET") {
01066     if (calomet.pt()<_highMETThreshold) return;
01067   }
01068   else if (TriggerTypeName=="LowMET") {
01069     if (calomet.pt()<_lowMETThreshold) return;
01070   }
01071   else if (TriggerTypeName=="Ele") {
01072     if (!selectWElectronEvent(iEvent)) return;
01073   }
01074   else if (TriggerTypeName=="Muon") {
01075     if (!selectWMuonEvent(iEvent)) return;
01076   }
01077 
01078   double caloSumET  = calomet.sumEt();
01079   double caloMETSig = calomet.mEtSig();
01080   //removed for optimizations//double caloEz     = calomet.e_longitudinal();
01081   double caloMET    = calomet.pt();
01082   double caloMEx    = calomet.px();
01083   double caloMEy    = calomet.py();
01084   double caloMETPhi = calomet.phi();
01085 
01086   if (_verbose) std::cout << _source << " " << caloMET << std::endl;
01087 
01088   double caloEtFractionHadronic = calomet.etFractionHadronic();
01089   double caloEmEtFraction       = calomet.emEtFraction();
01090 
01091   double caloMaxEtInEMTowers    = calomet.maxEtInEmTowers();
01092   double caloMaxEtInHadTowers   = calomet.maxEtInHadTowers();
01093 
01094   double caloHadEtInHB = calomet.hadEtInHB();
01095   double caloHadEtInHO = calomet.hadEtInHO();
01096   double caloHadEtInHE = calomet.hadEtInHE();
01097   double caloHadEtInHF = calomet.hadEtInHF();
01098   double caloEmEtInEB  = calomet.emEtInEB();
01099   double caloEmEtInEE  = calomet.emEtInEE();
01100   double caloEmEtInHF  = calomet.emEtInHF();
01101 
01102   //
01103   int myLuminosityBlock;
01104   //  myLuminosityBlock = (evtCounter++)/1000;
01105   myLuminosityBlock = iEvent.luminosityBlock();
01106   //
01107 
01108   if (TriggerTypeName!="") DirName = DirName +"/"+TriggerTypeName;
01109 
01110   if (_verbose) std::cout << "_etThreshold = " << _etThreshold << std::endl;
01111   if (caloSumET>_etThreshold){
01112 
01113     hCaloMEx    = _dbe->get(DirName+"/"+"METTask_CaloMEx");    if (hCaloMEx     && hCaloMEx->getRootObject() )    hCaloMEx->Fill(caloMEx);
01114     hCaloMEy    = _dbe->get(DirName+"/"+"METTask_CaloMEy");    if (hCaloMEy     && hCaloMEy->getRootObject() )    hCaloMEy->Fill(caloMEy);
01115     hCaloMET    = _dbe->get(DirName+"/"+"METTask_CaloMET");    if (hCaloMET     && hCaloMET->getRootObject() )    hCaloMET->Fill(caloMET);
01116     hCaloMET1   = _dbe->get(DirName+"/"+"METTask_CaloMET1");   if (hCaloMET1    && hCaloMET1->getRootObject() )   hCaloMET1->Fill(caloMET);
01117     hCaloMETPhi = _dbe->get(DirName+"/"+"METTask_CaloMETPhi"); if (hCaloMETPhi  && hCaloMETPhi->getRootObject() ) hCaloMETPhi->Fill(caloMETPhi);
01118     hCaloSumET  = _dbe->get(DirName+"/"+"METTask_CaloSumET");  if (hCaloSumET   && hCaloSumET->getRootObject() )  hCaloSumET->Fill(caloSumET);
01119     hCaloMETSig = _dbe->get(DirName+"/"+"METTask_CaloMETSig"); if (hCaloMETSig  && hCaloMETSig->getRootObject() ) hCaloMETSig->Fill(caloMETSig);
01120     //removed for optimizations//hCaloEz     = _dbe->get(DirName+"/"+"METTask_CaloEz");     if (hCaloEz      && hCaloEz->getRootObject() )     hCaloEz->Fill(caloEz);
01121 
01122     hCaloMET_logx   = _dbe->get(DirName+"/"+"METTask_CaloMET_logx");      if (hCaloMET_logx    && hCaloMET_logx->getRootObject() )   hCaloMET_logx->Fill(log10(caloMET));
01123     hCaloSumET_logx = _dbe->get(DirName+"/"+"METTask_CaloSumET_logx");    if (hCaloSumET_logx  && hCaloSumET_logx->getRootObject() ) hCaloSumET_logx->Fill(log10(caloSumET));
01124 
01125     //removed for optimizations//hCaloMETIonFeedbck = _dbe->get(DirName+"/"+"METTask_CaloMETIonFeedbck"); if (hCaloMETIonFeedbck  && hCaloMETIonFeedbck->getRootObject() ) hCaloMETIonFeedbck->Fill(caloMET);
01126     //removed for optimizations//hCaloMETHPDNoise   = _dbe->get(DirName+"/"+"METTask_CaloMETHPDNoise");   if (hCaloMETHPDNoise    && hCaloMETHPDNoise->getRootObject() )   hCaloMETHPDNoise->Fill(caloMET);
01127 
01128     //removed for optimizations//hCaloMETPhi002 = _dbe->get(DirName+"/"+"METTask_CaloMETPhi002");    if (caloMET>  2. && hCaloMETPhi002  &&  hCaloMETPhi002->getRootObject()) { hCaloMETPhi002->Fill(caloMETPhi);}
01129     //removed for optimizations//hCaloMETPhi010 = _dbe->get(DirName+"/"+"METTask_CaloMETPhi010");    if (caloMET> 10. && hCaloMETPhi010  &&  hCaloMETPhi010->getRootObject()) { hCaloMETPhi010->Fill(caloMETPhi);}
01130     hCaloMETPhi020 = _dbe->get(DirName+"/"+"METTask_CaloMETPhi020");    if (caloMET> 20. && hCaloMETPhi020  &&  hCaloMETPhi020->getRootObject()) { hCaloMETPhi020->Fill(caloMETPhi);}
01131 
01132     if (_allhist){
01133       if (bLumiSecPlot){
01134         hCaloMExLS = _dbe->get(DirName+"/"+"METTask_CaloMExLS"); if (hCaloMExLS  &&  hCaloMExLS->getRootObject())   hCaloMExLS->Fill(caloMEx,myLuminosityBlock);
01135         hCaloMEyLS = _dbe->get(DirName+"/"+"METTask_CaloMEyLS"); if (hCaloMEyLS  &&  hCaloMEyLS->getRootObject())   hCaloMEyLS->Fill(caloMEy,myLuminosityBlock);
01136       }
01137       
01138       hCaloEtFractionHadronic = _dbe->get(DirName+"/"+"METTask_CaloEtFractionHadronic"); if (hCaloEtFractionHadronic && hCaloEtFractionHadronic->getRootObject())  hCaloEtFractionHadronic->Fill(caloEtFractionHadronic);
01139       hCaloEmEtFraction       = _dbe->get(DirName+"/"+"METTask_CaloEmEtFraction");       if (hCaloEmEtFraction       && hCaloEmEtFraction->getRootObject())        hCaloEmEtFraction->Fill(caloEmEtFraction);
01140       
01141       //removed for optimizations//hCaloEmEtFraction002 = _dbe->get(DirName+"/"+"METTask_CaloEmEtFraction002");       if (caloMET>  2.  &&  hCaloEmEtFraction002    && hCaloEmEtFraction002->getRootObject()) hCaloEmEtFraction002->Fill(caloEmEtFraction);
01142       //removed for optimizations//hCaloEmEtFraction010 = _dbe->get(DirName+"/"+"METTask_CaloEmEtFraction010");       if (caloMET> 10.  &&  hCaloEmEtFraction010    && hCaloEmEtFraction010->getRootObject()) hCaloEmEtFraction010->Fill(caloEmEtFraction);
01143       hCaloEmEtFraction020 = _dbe->get(DirName+"/"+"METTask_CaloEmEtFraction020");       if (caloMET> 20.  &&  hCaloEmEtFraction020    && hCaloEmEtFraction020->getRootObject()) hCaloEmEtFraction020->Fill(caloEmEtFraction);
01144 
01145       hCaloMaxEtInEmTowers  = _dbe->get(DirName+"/"+"METTask_CaloMaxEtInEmTowers");   if (hCaloMaxEtInEmTowers  && hCaloMaxEtInEmTowers->getRootObject())   hCaloMaxEtInEmTowers->Fill(caloMaxEtInEMTowers);
01146       hCaloMaxEtInHadTowers = _dbe->get(DirName+"/"+"METTask_CaloMaxEtInHadTowers");  if (hCaloMaxEtInHadTowers && hCaloMaxEtInHadTowers->getRootObject())  hCaloMaxEtInHadTowers->Fill(caloMaxEtInHadTowers);
01147 
01148       hCaloHadEtInHB = _dbe->get(DirName+"/"+"METTask_CaloHadEtInHB");  if (hCaloHadEtInHB  &&  hCaloHadEtInHB->getRootObject())  hCaloHadEtInHB->Fill(caloHadEtInHB);
01149       hCaloHadEtInHO = _dbe->get(DirName+"/"+"METTask_CaloHadEtInHO");  if (hCaloHadEtInHO  &&  hCaloHadEtInHO->getRootObject())  hCaloHadEtInHO->Fill(caloHadEtInHO);
01150       hCaloHadEtInHE = _dbe->get(DirName+"/"+"METTask_CaloHadEtInHE");  if (hCaloHadEtInHE  &&  hCaloHadEtInHE->getRootObject())  hCaloHadEtInHE->Fill(caloHadEtInHE);
01151       hCaloHadEtInHF = _dbe->get(DirName+"/"+"METTask_CaloHadEtInHF");  if (hCaloHadEtInHF  &&  hCaloHadEtInHF->getRootObject())  hCaloHadEtInHF->Fill(caloHadEtInHF);
01152       hCaloEmEtInEB  = _dbe->get(DirName+"/"+"METTask_CaloEmEtInEB");   if (hCaloEmEtInEB   &&  hCaloEmEtInEB->getRootObject())   hCaloEmEtInEB->Fill(caloEmEtInEB);
01153       hCaloEmEtInEE  = _dbe->get(DirName+"/"+"METTask_CaloEmEtInEE");   if (hCaloEmEtInEE   &&  hCaloEmEtInEE->getRootObject())   hCaloEmEtInEE->Fill(caloEmEtInEE);
01154       hCaloEmEtInHF  = _dbe->get(DirName+"/"+"METTask_CaloEmEtInHF");   if (hCaloEmEtInHF   &&  hCaloEmEtInHF->getRootObject())   hCaloEmEtInHF->Fill(caloEmEtInHF);
01155 
01156       hCaloEmMEx    = _dbe->get(DirName+"/"+"METTask_CaloEmMEx");     if (hCaloEmMEx    && hCaloEmMEx->getRootObject())     hCaloEmMEx->Fill(_EmMEx);
01157       hCaloEmMEy    = _dbe->get(DirName+"/"+"METTask_CaloEmMEy");     if (hCaloEmMEy    && hCaloEmMEy->getRootObject())     hCaloEmMEy->Fill(_EmMEy);
01158       //removed for optimizations//hCaloEmEz     = _dbe->get(DirName+"/"+"METTask_CaloEmEz");      if (hCaloEmEz     && hCaloEmEz->getRootObject())      hCaloEmEz->Fill(_EmCaloEz);
01159       hCaloEmMET    = _dbe->get(DirName+"/"+"METTask_CaloEmMET");     if (hCaloEmMET    && hCaloEmMET->getRootObject())     hCaloEmMET->Fill(_EmMET);
01160       hCaloEmMETPhi = _dbe->get(DirName+"/"+"METTask_CaloEmMETPhi");  if (hCaloEmMETPhi && hCaloEmMETPhi->getRootObject())  hCaloEmMETPhi->Fill(_EmMetPhi);
01161       //removed for optimizations//hCaloEmSumET  = _dbe->get(DirName+"/"+"METTask_CaloEmSumET");   if (hCaloEmSumET  && hCaloEmSumET->getRootObject())   hCaloEmSumET->Fill(_EmSumEt);
01162 
01163       hCaloHaMEx    = _dbe->get(DirName+"/"+"METTask_CaloHaMEx");     if (hCaloHaMEx    && hCaloHaMEx->getRootObject())     hCaloHaMEx->Fill(_HaMEx);
01164       hCaloHaMEy    = _dbe->get(DirName+"/"+"METTask_CaloHaMEy");     if (hCaloHaMEy    && hCaloHaMEy->getRootObject())     hCaloHaMEy->Fill(_HaMEy);
01165       //removed for optimizations//hCaloHaEz     = _dbe->get(DirName+"/"+"METTask_CaloHaEz");      if (hCaloHaEz     && hCaloHaEz->getRootObject())      hCaloHaEz->Fill(_HaCaloEz);
01166       hCaloHaMET    = _dbe->get(DirName+"/"+"METTask_CaloHaMET");     if (hCaloHaMET    && hCaloHaMET->getRootObject())     hCaloHaMET->Fill(_HaMET);
01167       hCaloHaMETPhi = _dbe->get(DirName+"/"+"METTask_CaloHaMETPhi");  if (hCaloHaMETPhi && hCaloHaMETPhi->getRootObject())  hCaloHaMETPhi->Fill(_HaMetPhi);
01168       //removed for optimizations//hCaloHaSumET  = _dbe->get(DirName+"/"+"METTask_CaloHaSumET");   if (hCaloHaSumET  && hCaloHaSumET->getRootObject())   hCaloHaSumET->Fill(_HaSumEt);
01169 
01170     } // _allhist
01171 
01172     if (theCaloMETCollectionLabel.label() == "corMetGlobalMuons" ) {
01173 
01174       for( reco::MuonCollection::const_iterator muonit = muon_h->begin(); muonit != muon_h->end(); muonit++ ) {
01175         const reco::TrackRef siTrack = muonit->innerTrack();
01176         hCalomuPt    = _dbe->get(DirName+"/"+"METTask_CalomuPt");     if (hCalomuPt    && hCalomuPt->getRootObject())     hCalomuPt->Fill( muonit->p4().pt() );
01177         hCalomuEta   = _dbe->get(DirName+"/"+"METTask_CalomuEta");    if (hCalomuEta   && hCalomuEta->getRootObject())    hCalomuEta->Fill( muonit->p4().eta() );
01178         hCalomuNhits = _dbe->get(DirName+"/"+"METTask_CalomuNhits");  if (hCalomuNhits && hCalomuNhits->getRootObject())  hCalomuNhits->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
01179         hCalomuChi2  = _dbe->get(DirName+"/"+"METTask_CalomuChi2");   if (hCalomuChi2  && hCalomuChi2->getRootObject())   hCalomuChi2->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
01180         double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
01181         hCalomuD0    = _dbe->get(DirName+"/"+"METTask_CalomuD0");     if (hCalomuD0    && hCalomuD0->getRootObject())  hCalomuD0->Fill( d0 );
01182       }
01183       
01184       const unsigned int nMuons = muon_h->size();      
01185       for( unsigned int mus = 0; mus < nMuons; mus++ ) {
01186         reco::MuonRef muref( muon_h, mus);
01187         reco::MuonMETCorrectionData muCorrData = (*corMetGlobalMuons_ValueMap_Handle)[muref];
01188         hCaloMExCorrection      = _dbe->get(DirName+"/"+"METTask_CaloMExCorrection");       if (hCaloMExCorrection      && hCaloMExCorrection->getRootObject())       hCaloMExCorrection-> Fill(muCorrData.corrY());
01189         hCaloMEyCorrection      = _dbe->get(DirName+"/"+"METTask_CaloMEyCorrection");       if (hCaloMEyCorrection      && hCaloMEyCorrection->getRootObject())       hCaloMEyCorrection-> Fill(muCorrData.corrX());
01190         hCaloMuonCorrectionFlag = _dbe->get(DirName+"/"+"METTask_CaloMuonCorrectionFlag");  if (hCaloMuonCorrectionFlag && hCaloMuonCorrectionFlag->getRootObject())  hCaloMuonCorrectionFlag-> Fill(muCorrData.type());
01191       }
01192     }    
01193   } // et threshold cut
01194 
01195 }
01196 
01197 // ***********************************************************
01198 bool CaloMETAnalyzer::selectHighPtJetEvent(const edm::Event& iEvent){
01199 
01200   bool return_value=false;
01201 
01202   edm::Handle<reco::CaloJetCollection> caloJets;
01203   iEvent.getByLabel(theJetCollectionLabel, caloJets);
01204   if (!caloJets.isValid()) {
01205     LogDebug("") << "CaloMETAnalyzer: Could not find jet product" << std::endl;
01206     if (_verbose) std::cout << "CaloMETAnalyzer: Could not find jet product" << std::endl;
01207   }
01208 
01209   for (reco::CaloJetCollection::const_iterator cal = caloJets->begin(); 
01210        cal!=caloJets->end(); ++cal){
01211     if (cal->pt()>_highPtJetThreshold){
01212       return_value=true;
01213     }
01214   }
01215 
01216   return return_value;
01217 
01218 }
01219 
01220 // ***********************************************************
01221 bool CaloMETAnalyzer::selectLowPtJetEvent(const edm::Event& iEvent){
01222 
01223   bool return_value=false;
01224 
01225   edm::Handle<reco::CaloJetCollection> caloJets;
01226   iEvent.getByLabel(theJetCollectionLabel, caloJets);
01227   if (!caloJets.isValid()) {
01228     LogDebug("") << "CaloMETAnalyzer: Could not find jet product" << std::endl;
01229     if (_verbose) std::cout << "CaloMETAnalyzer: Could not find jet product" << std::endl;
01230   }
01231 
01232   for (reco::CaloJetCollection::const_iterator cal = caloJets->begin(); 
01233        cal!=caloJets->end(); ++cal){
01234     if (cal->pt()>_lowPtJetThreshold){
01235       return_value=true;
01236     }
01237   }
01238 
01239   return return_value;
01240 
01241 }
01242 
01243 // ***********************************************************
01244 bool CaloMETAnalyzer::selectWElectronEvent(const edm::Event& iEvent){
01245 
01246   bool return_value=true;
01247 
01248   /*
01249     W-electron event selection comes here
01250    */
01251 
01252   return return_value;
01253 
01254 }
01255 
01256 // ***********************************************************
01257 bool CaloMETAnalyzer::selectWMuonEvent(const edm::Event& iEvent){
01258 
01259   bool return_value=true;
01260 
01261   /*
01262     W-muon event selection comes here
01263    */
01264 
01265   return return_value;
01266 
01267 }
01268
/data/refman/pasoursint/CMSSW_4_2_9_HLT1_bphpatch4/src/DQMOffline/JetMET/src/CaloMETAnalyzer.cc
