CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
METTester Class Reference

#include <METTester.h>

Inheritance diagram for METTester:
edm::EDAnalyzer

Public Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
 
virtual void beginRun (const edm::Run &, const edm::EventSetup &)
 
virtual void endJob ()
 
 METTester (const edm::ParameterSet &)
 
- Public Member Functions inherited from edm::EDAnalyzer
 EDAnalyzer ()
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 

Private Member Functions

bool isGoodTrack (const reco::TrackRef, float d0corr)
 

Private Attributes

DQMStore * dbe_
 
bool finebinning_
 
std::string FolderName_
 
edm::InputTag inputBeamSpotLabel_
 
edm::InputTag inputCaloMETLabel_
 
edm::InputTag inputElectronLabel_
 
edm::InputTag inputMETLabel_
 
edm::InputTag inputMuonLabel_
 
edm::InputTag inputTrackLabel_
 
double maxchi2_
 
double maxd0_
 
double maxeta_
 
double maxpt_
 
double maxPtErr_
 
std::map< std::string,
MonitorElement * > 		me
 
std::string METType_
 
int minhits_
 
std::vector< int > trkAlgos_
 
std::vector< int > trkQuality_
 

Additional Inherited Members

- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
typedef WorkerT< EDAnalyzer > WorkerType
 
- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const * currentContext () const
 

Detailed Description

Definition at line 29 of file METTester.h.

Constructor & Destructor Documentation

METTester::METTester ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 59 of file METTester.cc.

References finebinning_, FolderName_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inputBeamSpotLabel_, inputCaloMETLabel_, inputElectronLabel_, inputMETLabel_, inputMuonLabel_, inputTrackLabel_, maxchi2_, maxd0_, maxeta_, maxpt_, maxPtErr_, METType_, minhits_, trkAlgos_, and trkQuality_.

60 {
61  METType_ = iConfig.getUntrackedParameter<std::string>("METType");
62  inputMETLabel_ = iConfig.getParameter<edm::InputTag>("InputMETLabel");
63  if(METType_ == "TCMET") {
64  inputCaloMETLabel_ = iConfig.getParameter<edm::InputTag>("InputCaloMETLabel");
65  inputTrackLabel_ = iConfig.getParameter<edm::InputTag>("InputTrackLabel");
66  inputMuonLabel_ = iConfig.getParameter<edm::InputTag>("InputMuonLabel");
67  inputElectronLabel_ = iConfig.getParameter<edm::InputTag>("InputElectronLabel");
68  inputBeamSpotLabel_ = iConfig.getParameter<edm::InputTag>("InputBeamSpotLabel");
69  minhits_ = iConfig.getParameter<int>("minhits");
70  maxd0_ = iConfig.getParameter<double>("maxd0");
71  maxchi2_ = iConfig.getParameter<double>("maxchi2");
72  maxeta_ = iConfig.getParameter<double>("maxeta");
73  maxpt_ = iConfig.getParameter<double>("maxpt");
74  maxPtErr_ = iConfig.getParameter<double>("maxPtErr");
75  trkQuality_ = iConfig.getParameter<std::vector<int> >("trkQuality");
76  trkAlgos_ = iConfig.getParameter<std::vector<int> >("trkAlgos");
77  }
78  finebinning_ = iConfig.getUntrackedParameter<bool>("FineBinning");
79  FolderName_ = iConfig.getUntrackedParameter<std::string>("FolderName");
80 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
METTester::inputCaloMETLabel_
edm::InputTag inputCaloMETLabel_
Definition: METTester.h:50
METTester::maxchi2_
double maxchi2_
Definition: METTester.h:61
METTester::inputTrackLabel_
edm::InputTag inputTrackLabel_
Definition: METTester.h:51
METTester::FolderName_
std::string FolderName_
Definition: METTester.h:48
METTester::METType_
std::string METType_
Definition: METTester.h:47
METTester::trkQuality_
std::vector< int > trkQuality_
Definition: METTester.h:65
METTester::inputElectronLabel_
edm::InputTag inputElectronLabel_
Definition: METTester.h:53
METTester::trkAlgos_
std::vector< int > trkAlgos_
Definition: METTester.h:66
METTester::inputBeamSpotLabel_
edm::InputTag inputBeamSpotLabel_
Definition: METTester.h:54
METTester::maxPtErr_
double maxPtErr_
Definition: METTester.h:64
METTester::inputMuonLabel_
edm::InputTag inputMuonLabel_
Definition: METTester.h:52
METTester::finebinning_
bool finebinning_
Definition: METTester.h:55
METTester::maxpt_
double maxpt_
Definition: METTester.h:63
METTester::minhits_
int minhits_
Definition: METTester.h:59
METTester::maxeta_
double maxeta_
Definition: METTester.h:62
METTester::inputMETLabel_
edm::InputTag inputMETLabel_
Definition: METTester.h:49
METTester::maxd0_
double maxd0_
Definition: METTester.h:60

Member Function Documentation

void METTester::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
virtual

Implements edm::EDAnalyzer.

Definition at line 420 of file METTester.cc.

References reco::GenMET::ChargedEMEtFraction(), reco::GenMET::ChargedHadEtFraction(), MetMuonCorrections_cff::corMetGlobalMuons, reco::MuonMETCorrectionData::corrX(), reco::MuonMETCorrectionData::corrY(), debug_cff::d0, reco::CaloMET::emEtFraction(), reco::CaloMET::emEtInEB(), reco::CaloMET::emEtInEE(), reco::CaloMET::emEtInHF(), reco::CaloMET::etFractionHadronic(), HcalObjRepresent::Fill(), cropTnPTrees::frac, genMetCalo_cfi::genMetCalo, python.GeneratorTools.genMetTrue_cff::genMetTrue, edm::Event::getByLabel(), reco::CaloMET::hadEtInHB(), reco::CaloMET::hadEtInHE(), reco::CaloMET::hadEtInHF(), reco::CaloMET::hadEtInHO(), inputBeamSpotLabel_, inputCaloMETLabel_, inputElectronLabel_, inputMETLabel_, inputMuonLabel_, inputTrackLabel_, reco::GenMET::InvisibleEtFraction(), isGoodTrack(), edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), edm::Ref< C, T, F >::key(), edm::InputTag::label(), reco::CaloMET::maxEtInEmTowers(), reco::CaloMET::maxEtInHadTowers(), me, CaloMET_cfi::met, reco::MET::mEtSig(), METType_, reco::GenMET::MuonEtFraction(), reco::GenMET::NeutralEMEtFraction(), reco::GenMET::NeutralHadEtFraction(), reco::LeafCandidate::phi(), edm::Handle< T >::product(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), dt_dqm_sourceclient_common_cff::reco, reco::MET::sumEt(), TCMET_cfi::tcMet, and reco::MuonMETCorrectionData::type().

421 {
422  using namespace reco;
423  if (METType_ == "CaloMET")
424  {
425  const CaloMET *calomet;
426  // Get CaloMET
427  edm::Handle<CaloMETCollection> calo;
428  iEvent.getByLabel(inputMETLabel_, calo);
429  if (!calo.isValid()) {
430  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task";
431  edm::LogInfo("OutputInfo") << " MET Task cannot continue...!";
432  return;
433  } else {
434  const CaloMETCollection *calometcol = calo.product();
435  calomet = &(calometcol->front());
436  }
437 
438 
439  // ==========================================================
440  // Reconstructed MET Information
441  double caloSumET = calomet->sumEt();
442  double caloMETSig = calomet->mEtSig();
443  double caloMET = calomet->pt();
444  double caloMEx = calomet->px();
445  double caloMEy = calomet->py();
446  double caloMETPhi = calomet->phi();
447  double caloMaxEtInEMTowers = calomet->maxEtInEmTowers();
448  double caloMaxEtInHadTowers = calomet->maxEtInHadTowers();
449  double caloEtFractionHadronic = calomet->etFractionHadronic();
450  double caloEmEtFraction = calomet->emEtFraction();
451  double caloHadEtInHB = calomet->hadEtInHB();
452  double caloHadEtInHO = calomet->hadEtInHO();
453  double caloHadEtInHE = calomet->hadEtInHE();
454  double caloHadEtInHF = calomet->hadEtInHF();
455  double caloEmEtInEB = calomet->emEtInEB();
456  double caloEmEtInEE = calomet->emEtInEE();
457  double caloEmEtInHF = calomet->emEtInHF();
458 
459  edm::LogInfo("OutputInfo") << caloMET << " " << caloSumET << std::endl;
460  me["hNevents"]->Fill(0.5);
461  me["hCaloMEx"]->Fill(caloMEx);
462  me["hCaloMEy"]->Fill(caloMEy);
463  me["hCaloMET"]->Fill(caloMET);
464  me["hCaloMETPhi"]->Fill(caloMETPhi);
465  me["hCaloSumET"]->Fill(caloSumET);
466  me["hCaloMETSig"]->Fill(caloMETSig);
467  me["hCaloMaxEtInEmTowers"]->Fill(caloMaxEtInEMTowers);
468  me["hCaloMaxEtInHadTowers"]->Fill(caloMaxEtInHadTowers);
469  me["hCaloEtFractionHadronic"]->Fill(caloEtFractionHadronic);
470  me["hCaloEmEtFraction"]->Fill(caloEmEtFraction);
471  me["hCaloHadEtInHB"]->Fill(caloHadEtInHB);
472  me["hCaloHadEtInHO"]->Fill(caloHadEtInHO);
473  me["hCaloHadEtInHE"]->Fill(caloHadEtInHE);
474  me["hCaloHadEtInHF"]->Fill(caloHadEtInHF);
475  me["hCaloEmEtInEB"]->Fill(caloEmEtInEB);
476  me["hCaloEmEtInEE"]->Fill(caloEmEtInEE);
477  me["hCaloEmEtInHF"]->Fill(caloEmEtInHF);
478 
479 
480  // Get Generated MET for Resolution plots
481 
482  edm::Handle<GenMETCollection> genTrue;
483  iEvent.getByLabel("genMetTrue", genTrue);
484  if (genTrue.isValid()) {
485  const GenMETCollection *genmetcol = genTrue.product();
486  const GenMET *genMetTrue = &(genmetcol->front());
487  double genMET = genMetTrue->pt();
488  double genMETPhi = genMetTrue->phi();
489 
490  me["hCaloMETResolution_GenMETTrue"]->Fill( caloMET - genMET );
491  me["hCaloMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( caloMETPhi - genMETPhi ) ) );
492  } else {
493  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetTrue";
494  }
495 
496 
497  edm::Handle<GenMETCollection> genCalo;
498  iEvent.getByLabel("genMetCalo", genCalo);
499  if (genCalo.isValid()) {
500  const GenMETCollection *genmetcol = genCalo.product();
501  const GenMET *genMetCalo = &(genmetcol->front());
502  double genMET = genMetCalo->pt();
503  double genMETPhi = genMetCalo->phi();
504 
505  me["hCaloMETResolution_GenMETCalo"]->Fill( caloMET - genMET );
506  me["hCaloMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( caloMETPhi - genMETPhi ) ) );
507  } else {
508  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetCalo";
509  }
510 
511 
512  }
513 
514 
515  else if (METType_ == "GenMET")
516  {
517  const GenMET *genmet;
518  // Get Generated MET
519  edm::Handle<GenMETCollection> gen;
520  iEvent.getByLabel(inputMETLabel_, gen);
521  if (!gen.isValid()) {
522  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task";
523  edm::LogInfo("OutputInfo") << " MET Task cannot continue...!";
524  return;
525  } else {
526  const GenMETCollection *genmetcol = gen.product();
527  genmet = &(genmetcol->front());
528  }
529 
530  // ==========================================================
531  // Genenerated MET Information
532  double genSumET = genmet->sumEt();
533  double genMET = genmet->pt();
534  double genMEx = genmet->px();
535  double genMEy = genmet->py();
536  double genMETPhi = genmet->phi();
537  double genMETSig = genmet->mEtSig();
538  /*
539  double genEmEnergy = genmet->emEnergy();
540  double genHadEnergy = genmet->hadEnergy();
541  double genInvisibleEnergy= genmet->invisibleEnergy();
542  double genAuxiliaryEnergy= genmet->auxiliaryEnergy();
543  */
544 
545  double NeutralEMEtFraction = genmet->NeutralEMEtFraction() ;
546  double NeutralHadEtFraction = genmet->NeutralHadEtFraction() ;
547  double ChargedEMEtFraction = genmet->ChargedEMEtFraction () ;
548  double ChargedHadEtFraction = genmet->ChargedHadEtFraction();
549  double MuonEtFraction = genmet->MuonEtFraction() ;
550  double InvisibleEtFraction = genmet->InvisibleEtFraction() ;
551 
552  me["hNevents"]->Fill(0);
553  me["hGenMEx"]->Fill(genMEx);
554  me["hGenMEy"]->Fill(genMEy);
555  me["hGenMET"]->Fill(genMET);
556  me["hGenMETPhi"]->Fill(genMETPhi);
557  me["hGenSumET"]->Fill(genSumET);
558  me["hGenMETSig"]->Fill(genMETSig);
559  //me["hGenEz"]->Fill(genEz);
560 
561  me["hNeutralEMEtFraction"]->Fill( NeutralEMEtFraction );
562  me["hNeutralHadEtFraction"]->Fill( NeutralHadEtFraction );
563  me["hChargedEMEtFraction"]->Fill( ChargedEMEtFraction );
564  me["hChargedHadEtFraction"]->Fill( ChargedHadEtFraction );
565  me["hMuonEtFraction"]->Fill( MuonEtFraction );
566  me["hInvisibleEtFraction"]->Fill( InvisibleEtFraction );
567 
568  me["hNevents"]->Fill(0.5);
569  }
570  else if( METType_ == "PFMET")
571  {
572  const PFMET *pfmet;
573  edm::Handle<PFMETCollection> hpfmetcol;
574  iEvent.getByLabel(inputMETLabel_,hpfmetcol);
575  if(!hpfmetcol.isValid()){
576  edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
577  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
578  return;
579  }
580  else
581  {
582  const PFMETCollection *pfmetcol = hpfmetcol.product();
583  pfmet = &(pfmetcol->front());
584  }
585  // Reconstructed MET Information
586  double SumET = pfmet->sumEt();
587  double MET = pfmet->pt();
588  double MEx = pfmet->px();
589  double MEy = pfmet->py();
590  double METPhi = pfmet->phi();
591  double METSig = pfmet->mEtSig();
592  me["hMEx"]->Fill(MEx);
593  me["hMEy"]->Fill(MEy);
594  me["hMET"]->Fill(MET);
595  me["hMETPhi"]->Fill(METPhi);
596  me["hSumET"]->Fill(SumET);
597  me["hMETSig"]->Fill(METSig);
598  me["hNevents"]->Fill(0.5);
599 
600  edm::Handle<GenMETCollection> genTrue;
601  iEvent.getByLabel("genMetTrue", genTrue);
602  if (genTrue.isValid()) {
603  const GenMETCollection *genmetcol = genTrue.product();
604  const GenMET *genMetTrue = &(genmetcol->front());
605  double genMET = genMetTrue->pt();
606  double genMETPhi = genMetTrue->phi();
607 
608  me["hMETResolution_GenMETTrue"]->Fill( MET - genMET );
609  me["hMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
610  } else {
611  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetTrue";
612  }
613 
614 
615  edm::Handle<GenMETCollection> genCalo;
616  iEvent.getByLabel("genMetCalo", genCalo);
617  if (genCalo.isValid()) {
618  const GenMETCollection *genmetcol = genCalo.product();
619  const GenMET *genMetCalo = &(genmetcol->front());
620  double genMET = genMetCalo->pt();
621  double genMETPhi = genMetCalo->phi();
622 
623  me["hMETResolution_GenMETCalo"]->Fill( MET - genMET );
624  me["hMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
625  } else {
626  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetCalo";
627  }
628 
629 
630 
631  }
632  else if (METType_ == "MET")
633  {
634  const MET *met;
635  // Get Generated MET
636  edm::Handle<METCollection> hmetcol;
637  iEvent.getByLabel(inputMETLabel_, hmetcol);
638  if (!hmetcol.isValid()) {
639  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task";
640  edm::LogInfo("OutputInfo") << " MET Task cannot continue...!";
641  return;
642  } else {
643  const METCollection *metcol = hmetcol.product();
644  met = &(metcol->front());
645  }
646 
647  // Reconstructed MET Information
648  double SumET = met->sumEt();
649  double MET = met->pt();
650  double MEx = met->px();
651  double MEy = met->py();
652  double METPhi = met->phi();
653  double METSig = met->mEtSig();
654 
655  me["hMEx"]->Fill(MEx);
656  me["hMEy"]->Fill(MEy);
657  me["hMET"]->Fill(MET);
658  me["hMETPhi"]->Fill(METPhi);
659  me["hSumET"]->Fill(SumET);
660  me["hMETSig"]->Fill(METSig);
661  me["hNevents"]->Fill(0.5);
662 
663  }
664  else if( METType_ == "TCMET" )
665  {
666  const MET *tcMet;
667  edm::Handle<METCollection> htcMetcol;
668  iEvent.getByLabel(inputMETLabel_, htcMetcol);
669 
670  const CaloMET *caloMet;
671  edm::Handle<CaloMETCollection> hcaloMetcol;
672  iEvent.getByLabel(inputCaloMETLabel_, hcaloMetcol);
673 
674  edm::Handle< reco::MuonCollection > muon_h;
675  iEvent.getByLabel(inputMuonLabel_, muon_h);
676 
677 // edm::Handle< edm::View<reco::Track> > track_h;
678  edm::Handle<reco::TrackCollection> track_h;
679  iEvent.getByLabel(inputTrackLabel_, track_h);
680 
681  edm::Handle< edm::View<reco::GsfElectron > > electron_h;
682  iEvent.getByLabel(inputElectronLabel_, electron_h);
683 
684  edm::Handle< reco::BeamSpot > beamSpot_h;
685  iEvent.getByLabel(inputBeamSpotLabel_, beamSpot_h);
686 
687  if(!htcMetcol.isValid()){
688  edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
689  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
690  return;
691  }
692  else
693  {
694  const METCollection *tcMetcol = htcMetcol.product();
695  tcMet = &(tcMetcol->front());
696  }
697 
698  if(!hcaloMetcol.isValid()){
699  edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
700  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
701  return;
702  }
703  else
704  {
705  const CaloMETCollection *caloMetcol = hcaloMetcol.product();
706  caloMet = &(caloMetcol->front());
707  }
708 
709  if(!muon_h.isValid()){
710  edm::LogInfo("OutputInfo") << "falied to retrieve muon data require by MET Task";
711  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
712  return;
713  }
714 
715  if(!track_h.isValid()){
716  edm::LogInfo("OutputInfo") << "falied to retrieve track data require by MET Task";
717  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
718  return;
719  }
720 
721  if(!electron_h.isValid()){
722  edm::LogInfo("OutputInfo") << "falied to retrieve electron data require by MET Task";
723  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
724  return;
725  }
726 
727  if(!beamSpot_h.isValid()){
728  edm::LogInfo("OutputInfo") << "falied to retrieve beam spot data require by MET Task";
729  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
730  return;
731  }
732 
733  math::XYZPoint bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
734 
735  // Reconstructed TCMET Information
736  double SumET = tcMet->sumEt();
737  double MET = tcMet->pt();
738  double MEx = tcMet->px();
739  double MEy = tcMet->py();
740  double METPhi = tcMet->phi();
741  double METSig = tcMet->mEtSig();
742 
743  me["hMEx"]->Fill(MEx);
744  me["hMEy"]->Fill(MEy);
745  me["hMET"]->Fill(MET);
746  me["hMETPhi"]->Fill(METPhi);
747  me["hSumET"]->Fill(SumET);
748  me["hMETSig"]->Fill(METSig);
749  me["hNevents"]->Fill(0.5);
750 
751  double caloMET = caloMet->pt();
752  double caloMEx = caloMet->px();
753  double caloMEy = caloMet->py();
754 
755  me["hdMETx"]->Fill(caloMEx-MEx);
756  me["hdMETy"]->Fill(caloMEy-MEy);
757  me["hdMET"]->Fill(caloMET-MET);
758 
759  unsigned int nTracks = track_h->size();
760  unsigned int nCorrTracks = 0;
761  unsigned int trackCount = 0;
762 // for( edm::View<reco::Track>::const_iterator trkit = track_h->begin(); trkit != track_h->end(); trkit++ ) {
763  for( reco::TrackCollection::const_iterator trkit = track_h->begin(); trkit != track_h->end(); trkit++ ) {
764  ++trackCount;
765  me["htrkPt"]->Fill( trkit->pt() );
766  me["htrkEta"]->Fill( trkit->eta() );
767  me["htrkNhits"]->Fill( trkit->numberOfValidHits() );
768  me["htrkChi2"]->Fill( trkit->chi2() / trkit->ndof() );
769 
770  double d0 = -1 * trkit->dxy( bspot );
771 
772  me["htrkD0"]->Fill( d0 );
773 
774  me["htrkQuality"]->Fill( trkit->qualityMask() );
775  me["htrkAlgo"]->Fill( trkit->algo() );
776  me["htrkPtErr"]->Fill( trkit->ptError() / trkit->pt() );
777 
778  reco::TrackRef trkref( track_h, trackCount );
779 
780  if( isGoodTrack( trkref, d0) ) ++nCorrTracks;
781  }
782 
783  float frac = (float)nCorrTracks / (float)nTracks;
784  me["hfracTrks"]->Fill(frac);
785 
786  int nEls = 0;
787  for( edm::View<reco::GsfElectron>::const_iterator eleit = electron_h->begin(); eleit != electron_h->end(); eleit++ ) {
788  me["helePt"]->Fill( eleit->p4().pt() );
789  me["heleEta"]->Fill( eleit->p4().eta() );
790  me["heleHoE"]->Fill( eleit->hadronicOverEm() );
791 
792  reco::TrackRef el_track = eleit->closestCtfTrackRef();
793 
794  unsigned int ele_idx = el_track.isNonnull() ? el_track.key() : 99999;
795 
796  if( eleit->hadronicOverEm() < 0.1 && ele_idx < nTracks )
797  ++nEls;
798  }
799 
800  me["hnEls"]->Fill(nEls);
801 
802  for( reco::MuonCollection::const_iterator muonit = muon_h->begin(); muonit != muon_h->end(); muonit++ ) {
803 
804  const reco::TrackRef siTrack = muonit->innerTrack();
805 
806  me["hmuPt"]->Fill( muonit->p4().pt() );
807  me["hmuEta"]->Fill( muonit->p4().eta() );
808  me["hmuNhits"]->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
809  me["hmuChi2"]->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
810 
811  double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
812 
813  me["hmuD0"]->Fill( d0 );
814  }
815 
816  edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > tcMet_ValueMap_Handle;
817  iEvent.getByLabel("muonTCMETValueMapProducer" , "muCorrData", tcMet_ValueMap_Handle);
818 
819  edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > muon_ValueMap_Handle;
820  iEvent.getByLabel("muonMETValueMapProducer" , "muCorrData", muon_ValueMap_Handle);
821 
822  const unsigned int nMuons = muon_h->size();
823 
824  int nMus = 0;
825  int nMusPis = 0;
826  double muDx = 0;
827  double muDy = 0;
828  for( unsigned int mus = 0; mus < nMuons; mus++ )
829  {
830  reco::MuonRef muref( muon_h, mus);
831  reco::MuonMETCorrectionData muCorrData = (*tcMet_ValueMap_Handle)[muref];
832  reco::MuonMETCorrectionData muonCorrData = (*muon_ValueMap_Handle)[muref];
833 
834  me["hMExCorrection"] -> Fill(muCorrData.corrX());
835  me["hMEyCorrection"] -> Fill(muCorrData.corrY());
836 
837  int type = muCorrData.type();
838  me["hMuonCorrectionFlag"]-> Fill(type);
839 
840  if( type == 1 || type == 2 || type == 5 ) {
841  ++nMus;
842 
843  if( type == 1 ) {
844  muDx += muonCorrData.corrX() - muref->globalTrack()->px();
845  muDy += muonCorrData.corrY() - muref->globalTrack()->py();
846  }
847  else if( type == 2 ) {
848  muDx += muonCorrData.corrX() - muref->innerTrack()->px();
849  muDy += muonCorrData.corrY() - muref->innerTrack()->py();
850  }
851  else if( type == 5 ) {
852  muDx += muonCorrData.corrX() - muref->px();
853  muDy += muonCorrData.corrY() - muref->py();
854  }
855  }
856  else if( type == 4 )
857  ++nMusPis;
858  }
859 
860  me["hnMus"]->Fill(nMus);
861  me["hnMusPis"]->Fill(nMusPis);
862  me["hdMUx"]->Fill(muDx);
863  me["hdMUy"]->Fill(muDy);
864 
865  edm::Handle<GenMETCollection> genTrue;
866  iEvent.getByLabel("genMetTrue", genTrue);
867  if (genTrue.isValid()) {
868  const GenMETCollection *genmetcol = genTrue.product();
869  const GenMET *genMetTrue = &(genmetcol->front());
870  double genMET = genMetTrue->pt();
871  double genMETPhi = genMetTrue->phi();
872 
873  me["hMETResolution_GenMETTrue"]->Fill( MET - genMET );
874  me["hMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
875  } else {
876  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetTrue";
877  }
878 
879 
880  edm::Handle<GenMETCollection> genCalo;
881  iEvent.getByLabel("genMetCalo", genCalo);
882  if (genCalo.isValid()) {
883  const GenMETCollection *genmetcol = genCalo.product();
884  const GenMET *genMetCalo = &(genmetcol->front());
885  double genMET = genMetCalo->pt();
886  double genMETPhi = genMetCalo->phi();
887 
888  me["hMETResolution_GenMETCalo"]->Fill( MET - genMET );
889  me["hMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
890  } else {
891  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetCalo";
892  }
893  }
894 
895  else if( inputMETLabel_.label() == "corMetGlobalMuons" )
896  {
897  const CaloMET *corMetGlobalMuons = 0;
898  edm::Handle<CaloMETCollection> hcorMetGlobalMuonscol;
899  iEvent.getByLabel(inputMETLabel_, hcorMetGlobalMuonscol );
900  if(! hcorMetGlobalMuonscol.isValid()){
901  edm::LogInfo("OutputInfo") << "hcorMetGlobalMuonscol is NOT Valid";
902  edm::LogInfo("OutputInfo") << "MET Taks continues anyway...!";
903  }
904  else
905  {
906  const CaloMETCollection *corMetGlobalMuonscol = hcorMetGlobalMuonscol.product();
907  corMetGlobalMuons = &(corMetGlobalMuonscol->front());
908  }
909 
910  // Reconstructed TCMET Information
911  double SumET = corMetGlobalMuons->sumEt();
912  double MET = corMetGlobalMuons->pt();
913  double MEx = corMetGlobalMuons->px();
914  double MEy = corMetGlobalMuons->py();
915  double METPhi = corMetGlobalMuons->phi();
916  double METSig = corMetGlobalMuons->mEtSig();
917  me["hMEx"]->Fill(MEx);
918  me["hMEy"]->Fill(MEy);
919  me["hMET"]->Fill(MET);
920  me["hMETPhi"]->Fill(METPhi);
921  me["hSumET"]->Fill(SumET);
922  me["hMETSig"]->Fill(METSig);
923  me["hNevents"]->Fill(0.5);
924 
925  edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > corMetGlobalMuons_ValueMap_Handle;
926  iEvent.getByLabel("muonMETValueMapProducer" , "muCorrData", corMetGlobalMuons_ValueMap_Handle);
927 
928  edm::Handle< reco::MuonCollection > muon_Handle;
929  iEvent.getByLabel("muons", muon_Handle);
930 
931  edm::Handle< reco::BeamSpot > beamSpot_h;
932  iEvent.getByLabel(inputBeamSpotLabel_, beamSpot_h);
933 
934  if(!beamSpot_h.isValid()){
935  edm::LogInfo("OutputInfo") << "beamSpot is NOT Valid";
936  edm::LogInfo("OutputInfo") << "MET Taks continues anyway...!";
937  }
938 
939  math::XYZPoint bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
940 
941  for( reco::MuonCollection::const_iterator muonit = muon_Handle->begin(); muonit != muon_Handle->end(); muonit++ ) {
942 
943  const reco::TrackRef siTrack = muonit->innerTrack();
944  const reco::TrackRef globalTrack = muonit->globalTrack();
945 
946  me["hmuPt"]->Fill( muonit->p4().pt() );
947  me["hmuEta"]->Fill( muonit->p4().eta() );
948  me["hmuNhits"]->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
949  me["hmuChi2"]->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
950 
951  double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
952 
953  me["hmuD0"]->Fill( d0 );
954 
955  int nHits = globalTrack.isNonnull() ? globalTrack->hitPattern().numberOfValidMuonHits() : -999;
956 
957  me["hmuSAhits"]->Fill( nHits );
958  }
959 
960  const unsigned int nMuons = muon_Handle->size();
961  for( unsigned int mus = 0; mus < nMuons; mus++ )
962  {
963  reco::MuonRef muref( muon_Handle, mus);
964  reco::MuonMETCorrectionData muCorrData = (*corMetGlobalMuons_ValueMap_Handle)[muref];
965 
966  me["hMExCorrection"] -> Fill(muCorrData.corrY());
967  me["hMEyCorrection"] -> Fill(muCorrData.corrX());
968  me["hMuonCorrectionFlag"]-> Fill(muCorrData.type());
969  }
970 
971  edm::Handle<GenMETCollection> genTrue;
972  iEvent.getByLabel("genMetTrue", genTrue);
973  if (genTrue.isValid()) {
974  const GenMETCollection *genmetcol = genTrue.product();
975  const GenMET *genMetTrue = &(genmetcol->front());
976  double genMET = genMetTrue->pt();
977  double genMETPhi = genMetTrue->phi();
978 
979  me["hMETResolution_GenMETTrue"]->Fill( MET - genMET );
980  me["hMETPhiResolution_GenMETTrue"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
981  } else {
982  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetTrue";
983  }
984 
985 
986  edm::Handle<GenMETCollection> genCalo;
987  iEvent.getByLabel("genMetCalo", genCalo);
988  if (genCalo.isValid()) {
989  const GenMETCollection *genmetcol = genCalo.product();
990  const GenMET *genMetCalo = &(genmetcol->front());
991  double genMET = genMetCalo->pt();
992  double genMETPhi = genMetCalo->phi();
993 
994  me["hMETResolution_GenMETCalo"]->Fill( MET - genMET );
995  me["hMETPhiResolution_GenMETCalo"]->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
996  } else {
997  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetCalo";
998  }
999 
1000 
1001 
1002  }
1003 
1004 }
type
type
Definition: HCALResponse.h:22
METTester::inputCaloMETLabel_
edm::InputTag inputCaloMETLabel_
Definition: METTester.h:50
reco::CaloMET::hadEtInHE
double hadEtInHE() const
Definition: CaloMET.h:51
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
GenMETCollection
Collection of Gen MET.
METTester::inputTrackLabel_
edm::InputTag inputTrackLabel_
Definition: METTester.h:51
CaloMET_cfi.met
tuple met
Definition: CaloMET_cfi.py:18
reco::CaloMET::hadEtInHF
double hadEtInHF() const
Definition: CaloMET.h:53
debug_cff.d0
tuple d0
Definition: debug_cff.py:3
reco::CaloMET::maxEtInHadTowers
double maxEtInHadTowers() const
Definition: CaloMET.h:40
MetMuonCorrections_cff.corMetGlobalMuons
tuple corMetGlobalMuons
Definition: MetMuonCorrections_cff.py:6
genMetCalo_cfi.genMetCalo
tuple genMetCalo
Definition: genMetCalo_cfi.py:8
reco::GenMET::MuonEtFraction
double MuonEtFraction() const
Definition: GenMET.h:57
reco::CaloMET::maxEtInEmTowers
double maxEtInEmTowers() const
Definition: CaloMET.h:38
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:101
METTester::METType_
std::string METType_
Definition: METTester.h:47
METTester::inputElectronLabel_
edm::InputTag inputElectronLabel_
Definition: METTester.h:53
CaloMETCollection
Collection of Calo MET.
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:249
reco::MET::mEtSig
double mEtSig() const
Definition: MET.h:50
reco::MET::sumEt
double sumEt() const
Definition: MET.h:48
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
reco::MET
Definition: MET.h:32
METTester::inputBeamSpotLabel_
edm::InputTag inputBeamSpotLabel_
Definition: METTester.h:54
reco::GenMET::ChargedEMEtFraction
double ChargedEMEtFraction() const
Definition: GenMET.h:39
reco::CaloMET::emEtInEB
double emEtInEB() const
Definition: CaloMET.h:55
METCollection
Collection of MET.
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
METTester::inputMuonLabel_
edm::InputTag inputMuonLabel_
Definition: METTester.h:52
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:355
reco::GenMET::InvisibleEtFraction
double InvisibleEtFraction() const
Definition: GenMET.h:63
reco::CaloMET::hadEtInHO
double hadEtInHO() const
Definition: CaloMET.h:49
reco::CaloMET::etFractionHadronic
double etFractionHadronic() const
Definition: CaloMET.h:42
reco::LeafCandidate::px
virtual double px() const
x coordinate of momentum vector
Definition: LeafCandidate.h:131
reco::LeafCandidate::pt
virtual double pt() const
transverse momentum
Definition: LeafCandidate.cc:127
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:13
TCMET_cfi.tcMet
tuple tcMet
Definition: TCMET_cfi.py:9
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:265
METTester::me
std::map< std::string, MonitorElement * > me
Definition: METTester.h:44
edm::Handle::product
T const * product() const
Definition: Handle.h:74
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:25
reco::GenMET::NeutralEMEtFraction
double NeutralEMEtFraction() const
Definition: GenMET.h:33
reco::CaloMET::emEtInEE
double emEtInEE() const
Definition: CaloMET.h:57
reco::GenMET::NeutralHadEtFraction
double NeutralHadEtFraction() const
Definition: GenMET.h:45
METTester::isGoodTrack
bool isGoodTrack(const reco::TrackRef, float d0corr)
Definition: METTester.cc:1011
reco::CaloMET::emEtInHF
double emEtInHF() const
Definition: CaloMET.h:59
python.GeneratorTools.genMetTrue_cff.genMetTrue
tuple genMetTrue
Definition: genMetTrue_cff.py:21
METTester::inputMETLabel_
edm::InputTag inputMETLabel_
Definition: METTester.h:49
reco::GenMET::ChargedHadEtFraction
double ChargedHadEtFraction() const
Definition: GenMET.h:51
reco::LeafCandidate::phi
virtual double phi() const
momentum azimuthal angle
Definition: LeafCandidate.h:139
reco::CaloMET::hadEtInHB
double hadEtInHB() const
Definition: CaloMET.h:47
reco::LeafCandidate::py
virtual double py() const
y coordinate of momentum vector
Definition: LeafCandidate.h:133
reco::CaloMET::emEtFraction
double emEtFraction() const
Definition: CaloMET.h:45
PFMETCollection
Collection of PF MET.
void METTester::beginRun ( const edm::Run &  iRun,
const edm::EventSetup &  iSetup 
)
virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 83 of file METTester.cc.

References DQMStore::book1D(), dbe_, TrackerOfflineValidation_Dqm_cff::dirName, finebinning_, FolderName_, inputMETLabel_, edm::InputTag::label(), label, me, METType_, cmsCodeRules.cppFunctionSkipper::operator, and DQMStore::setCurrentFolder().

84 {
85  // get ahold of back-end interface
86  dbe_ = edm::Service<DQMStore>().operator->();
87 
88  if (dbe_) {
89  // TString dirName = "RecoMETV/METTask/MET/";
90  //TString dirName = "JetMET/EventInfo/CertificationSummary/MET_Global/";
91  // TString dirName = "RecoMETV/MET_Global/";
92  TString dirName(FolderName_.c_str());
93  TString label(inputMETLabel_.label());
94  dirName += label;
95  dbe_->setCurrentFolder((std::string)dirName);
96 
97  if (METType_ == "CaloMET")
98  {
99  // CaloMET Histograms
100  if(!finebinning_)
101  {
102  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,-0.5,1);
103  me["hCaloMEx"] = dbe_->book1D("METTask_CaloMEx","METTask_CaloMEx",500,-999.5,499.5);
104  me["hCaloMEy"] = dbe_->book1D("METTask_CaloMEy","METTask_CaloMEy",500,-999.5,499.5);
105  // me["hCaloEz"] = dbe_->book1D("METTask_CaloEz","METTask_CaloEz",2001,-500,501);
106  me["hCaloMETSig"] = dbe_->book1D("METTask_CaloMETSig","METTask_CaloMETSig",25,-0.5,24.5);
107  me["hCaloMET"] = dbe_->book1D("METTask_CaloMET","METTask_CaloMET",1000,-0.5,1999.5);
108  me["hCaloMETPhi"] = dbe_->book1D("METTask_CaloMETPhi","METTask_CaloMETPhi",80,-4,4);
109  me["hCaloSumET"] = dbe_->book1D("METTask_CaloSumET","METTask_CaloSumET",800,-0.5,7999.5); //10GeV
110  me["hCaloMaxEtInEmTowers"] = dbe_->book1D("METTask_CaloMaxEtInEmTowers","METTask_CaloMaxEtInEmTowers",600,-0.5,2999.5); //5GeV
111  me["hCaloMaxEtInHadTowers"] = dbe_->book1D("METTask_CaloMaxEtInHadTowers","METTask_CaloMaxEtInHadTowers",600,-.05,2999.5); //5GeV
112  me["hCaloEtFractionHadronic"] = dbe_->book1D("METTask_CaloEtFractionHadronic","METTask_CaloEtFractionHadronic",100,0,1);
113  me["hCaloEmEtFraction"] = dbe_->book1D("METTask_CaloEmEtFraction","METTask_CaloEmEtFraction",100,0,1);
114  me["hCaloHadEtInHB"] = dbe_->book1D("METTask_CaloHadEtInHB","METTask_CaloHadEtInHB",1000, -0.5, 4999.5); //5GeV
115  me["hCaloHadEtInHO"] = dbe_->book1D("METTask_CaloHadEtInHO","METTask_CaloHadEtInHO",250, -0.5, 499.5); //5GeV
116  me["hCaloHadEtInHE"] = dbe_->book1D("METTask_CaloHadEtInHE","METTask_CaloHadEtInHE",200, -0.5, 399.5); //5GeV
117  me["hCaloHadEtInHF"] = dbe_->book1D("METTask_CaloHadEtInHF","METTask_CaloHadEtInHF",100, -0.5, 199.5); //5GeV
118  me["hCaloEmEtInHF"] = dbe_->book1D("METTask_CaloEmEtInHF","METTask_CaloEmEtInHF",100, -0.5, 99.5); //5GeV
119  me["hCaloEmEtInEE"] = dbe_->book1D("METTask_CaloEmEtInEE","METTask_CaloEmEtInEE",100,0,199.5); //5GeV
120  me["hCaloEmEtInEB"] = dbe_->book1D("METTask_CaloEmEtInEB","METTask_CaloEmEtInEB",1200,0, 5999.5); //5GeV
121 
122 
123 
124  me["hCaloMETResolution_GenMETTrue"] = dbe_->book1D("METTask_CaloMETResolution_GenMETTrue","METTask_CaloMETResolution_GenMETTrue", 500,-500,500);
125  me["hCaloMETResolution_GenMETCalo"] = dbe_->book1D("METTask_CaloMETResolution_GenMETCalo","METTask_CaloMETResolution_GenMETCalo", 500,-500,500);
126 
127  me["hCaloMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETTrue","METTask_CaloMETPhiResolution_GenMETTrue", 80,0,4);
128  me["hCaloMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETCalo","METTask_CaloMETPhiResolution_GenMETCalo", 80,0,4);
129 
130  }
131  else
132  {
133  //FineBinnning
134  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,-0.5,1);
135  me["hCaloMEx"] = dbe_->book1D("METTask_CaloMEx","METTask_CaloMEx",4001,-1000,1001);
136  me["hCaloMEy"] = dbe_->book1D("METTask_CaloMEy","METTask_CaloMEy",4001,-1000,1001);
137  //me["hCaloEz"] = dbe_->book1D("METTask_CaloEz","METTask_CaloEz",2001,-500,501);
138  me["hCaloMETSig"] = dbe_->book1D("METTask_CaloMETSig","METTask_CaloMETSig",51,0,51);
139  me["hCaloMET"] = dbe_->book1D("METTask_CaloMET","METTask_CaloMET",2001,0,2001);
140  me["hCaloMETPhi"] = dbe_->book1D("METTask_CaloMETPhi","METTask_CaloMETPhi",80,-4,4);
141  me["hCaloSumET"] = dbe_->book1D("METTask_CaloSumET","METTask_CaloSumET",10001,0,10001);
142  me["hCaloMaxEtInEmTowers"] = dbe_->book1D("METTask_CaloMaxEtInEmTowers","METTask_CaloMaxEtInEmTowers",4001,0,4001);
143  me["hCaloMaxEtInHadTowers"] = dbe_->book1D("METTask_CaloMaxEtInHadTowers","METTask_CaloMaxEtInHadTowers",4001,0,4001);
144  me["hCaloEtFractionHadronic"] = dbe_->book1D("METTask_CaloEtFractionHadronic","METTask_CaloEtFractionHadronic",100,0,1);
145  me["hCaloEmEtFraction"] = dbe_->book1D("METTask_CaloEmEtFraction","METTask_CaloEmEtFraction",100,0,1);
146  me["hCaloHadEtInHB"] = dbe_->book1D("METTask_CaloHadEtInHB","METTask_CaloHadEtInHB",8001,0,8001);
147  me["hCaloHadEtInHO"] = dbe_->book1D("METTask_CaloHadEtInHO","METTask_CaloHadEtInHO",4001,0,4001);
148  me["hCaloHadEtInHE"] = dbe_->book1D("METTask_CaloHadEtInHE","METTask_CaloHadEtInHE",4001,0,4001);
149  me["hCaloHadEtInHF"] = dbe_->book1D("METTask_CaloHadEtInHF","METTask_CaloHadEtInHF",4001,0,4001);
150  me["hCaloHadEtInEB"] = dbe_->book1D("METTask_CaloHadEtInEB","METTask_CaloHadEtInEB",8001,0,8001);
151  me["hCaloHadEtInEE"] = dbe_->book1D("METTask_CaloHadEtInEE","METTask_CaloHadEtInEE",4001,0,4001);
152  me["hCaloEmEtInHF"] = dbe_->book1D("METTask_CaloEmEtInHF","METTask_CaloEmEtInHF",4001,0,4001);
153  me["hCaloEmEtInEE"] = dbe_->book1D("METTask_CaloEmEtInEE","METTask_CaloEmEtInEE",4001,0,4001);
154  me["hCaloEmEtInEB"] = dbe_->book1D("METTask_CaloEmEtInEB","METTask_CaloEmEtInEB",8001,0,8001);
155 
156  me["hCaloMETResolution_GenMETTrue"] = dbe_->book1D("METTask_CaloMETResolution_GenMETTrue","METTask_CaloMETResolution_GenMETTrue", 2000,-1000,1000);
157  me["hCaloMETResolution_GenMETCalo"] = dbe_->book1D("METTask_CaloMETResolution_GenMETCalo","METTask_CaloMETResolution_GenMETCalo", 2000,-1000,1000);
158 
159  me["hCaloMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETTrue","METTask_CaloMETPhiResolution_GenMETTrue", 80,0,4);
160  me["hCaloMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_CaloMETPhiResolution_GenMETCalo","METTask_CaloMETPhiResolution_GenMETCalo", 80,0,4);
161  }
162  }
163 
164  else if (METType_ == "GenMET")
165  {
166  // GenMET Histograms
167 
168  if(!finebinning_)
169  {
170  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
171  me["hGenMEx"] = dbe_->book1D("METTask_GenMEx","METTask_GenMEx",1000,-999.5,999.5);
172  me["hGenMEy"] = dbe_->book1D("METTask_GenMEy","METTask_GenMEy",1000,-999.5,999.5);
173  // me["hGenEz"] = dbe_->book1D("METTask_GenEz","METTask_GenEz",2001,-500,501);
174  me["hGenMETSig"] = dbe_->book1D("METTask_GenMETSig","METTask_GenMETSig",51,0,51);
175  me["hGenMET"] = dbe_->book1D("METTask_GenMET","METTask_GenMET", 2000,-0.5,1999.5);
176  me["hGenMETPhi"] = dbe_->book1D("METTask_GenMETPhi","METTask_GenMETPhi",80,-4,4);
177  me["hGenSumET"] = dbe_->book1D("METTask_GenSumET","METTask_GenSumET",1000,-0.5,9999.5);
178 
179  me["hNeutralEMEtFraction"] = dbe_->book1D("METTask_GenNeutralEMEtFraction", "METTask_GenNeutralEMEtFraction", 120, 0.0, 1.2 );
180  me["hNeutralHadEtFraction"] = dbe_->book1D("METTask_GenNeutralHadEtFraction", "METTask_GenNeutralHadEtFraction", 120, 0.0, 1.2 );
181  me["hChargedEMEtFraction"] = dbe_->book1D("METTask_GenChargedEMEtFraction", "METTask_GenChargedEMEtFraction", 120, 0.0, 1.2);
182  me["hChargedHadEtFraction"] = dbe_->book1D("METTask_GenChargedHadEtFraction", "METTask_GenChargedHadEtFraction", 120, 0.0,1.2);
183  me["hMuonEtFraction"] = dbe_->book1D("METTask_GenMuonEtFraction", "METTask_GenMuonEtFraction", 120, 0.0, 1.2 );
184  me["hInvisibleEtFraction"] = dbe_->book1D("METTask_GenInvisibleEtFraction", "METTask_GenInvisibleEtFraction", 120, 0.0, 1.2 );
185 
186  }
187  else
188  {
189  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
190  me["hGenMEx"] = dbe_->book1D("METTask_GenMEx","METTask_GenMEx",4001,-1000,1001);
191  me["hGenMEy"] = dbe_->book1D("METTask_GenMEy","METTask_GenMEy",4001,-1000,1001);
192  //me["hGenEz"] = dbe_->book1D("METTask_GenEz","METTask_GenEz",2001,-500,501);
193  me["hGenMETSig"] = dbe_->book1D("METTask_GenMETSig","METTask_GenMETSig",51,0,51);
194  me["hGenMET"] = dbe_->book1D("METTask_GenMET","METTask_GenMET",2001,0,2001);
195  me["hGenMETPhi"] = dbe_->book1D("METTask_GenMETPhi","METTask_GenMETPhi",80,-4,4);
196  me["hGenSumET"] = dbe_->book1D("METTask_GenSumET","METTask_GenSumET",10001,0,10001);
197  me["hNeutralEMEtFraction"] = dbe_->book1D("METTask_GenNeutralEMEtFraction", "METTask_GenNeutralEMEtFraction", 120, 0.0, 1.2 );
198  me["hNeutralHadEtFraction"] = dbe_->book1D("METTask_GenNeutralHadEtFraction", "METTask_GenNeutralHadEtFraction", 120, 0.0, 1.2 );
199  me["hChargedEMEtFraction"] = dbe_->book1D("METTask_GenChargedEMEtFraction", "METTask_GenChargedEMEtFraction", 120, 0.0, 1.2);
200  me["hChargedHadEtFraction"] = dbe_->book1D("METTask_GenChargedHadEtFraction", "METTask_GenChargedHadEtFraction", 120, 0.0,1.2);
201  me["hMuonEtFraction"] = dbe_->book1D("METTask_GenMuonEtFraction", "METTask_GenMuonEtFraction", 120, 0.0, 1.2 );
202  me["hInvisibleEtFraction"] = dbe_->book1D("METTask_GenInvisibleEtFraction", "METTask_GenInvisibleEtFraction", 120, 0.0, 1.2 );
203 
204  }
205  }
206  else if (METType_ == "MET")
207  {
208  // MET Histograms
209  if(!finebinning_)
210  {
211  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
212  me["hMEx"] = dbe_->book1D("METTask_MEx","METTask_MEx",1000,-999.5,999.5);
213  me["hMEy"] = dbe_->book1D("METTask_MEy","METTask_MEy",1000,-999.5,999.5);
214  //me["hEz"] = dbe_->book1D("METTask_Ez","METTask_Ez",1000,-999.5,999.5);
215  me["hMETSig"] = dbe_->book1D("METTask_METSig","METTask_METSig",50,-0.5,49.5);
216  me["hMET"] = dbe_->book1D("METTask_MET","METTask_MET",1000,-0.5,1999.5);
217  me["hMETPhi"] = dbe_->book1D("METTask_METPhi","METTask_METPhi",80,-4,4);
218  me["hSumET"] = dbe_->book1D("METTask_SumET","METTask_SumET",1000,0,9999.5);
219 
220  }
221  else
222  {
223  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
224  me["hMEx"] = dbe_->book1D("METTask_MEx","METTask_MEx",2001,-500,501);
225  me["hMEy"] = dbe_->book1D("METTask_MEy","METTask_MEy",2001,-500,501);
226  //me["hEz"] = dbe_->book1D("METTask_Ez","METTask_Ez",2001,-500,501);
227  me["hMETSig"] = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
228  me["hMET"] = dbe_->book1D("METTask_MET","METTask_MET",2001,0,2001);
229  me["hMETPhi"] = dbe_->book1D("METTask_METPhi","METTask_METPhi",80,-4,4);
230  me["hSumET"] = dbe_->book1D("METTask_SumET","METTask_SumET",4001,0,4001);
231 
232  }
233  }
234  else if (METType_ == "PFMET")
235  {
236  // PFMET Histograms
237  if(!finebinning_)
238  {
239  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
240  me["hMEx"] = dbe_->book1D("METTask_MEx","METTask_MEx",1000,-999.5,999.5);
241  me["hMEy"] = dbe_->book1D("METTask_MEy","METTask_MEy",1000,-999.5,999.5);
242  // me["hEz"] = dbe_->book1D("METTask_Ez","METTask_Ez",2001,-500,501);
243  me["hMETSig"] = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
244  me["hMET"] = dbe_->book1D("METTask_MET","METTask_MET",1000,-0.5,1999.5);
245  me["hMETPhi"] = dbe_->book1D("METTask_METPhi","METTask_METPhi",80,-4,4);
246  me["hSumET"] = dbe_->book1D("METTask_SumET","METTask_SumET",1000,-0.50,9999.5);
247 
248  me["hMETResolution_GenMETTrue"] = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue", 500,-500,500);
249  me["hMETResolution_GenMETCalo"] = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo", 500,-500,500);
250 
251  me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4);
252  me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4);
253 
254  }
255  else
256  {
257  //FineBin
258  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
259  me["hMEx"] = dbe_->book1D("METTask_MEx","METTask_MEx",2001,-500,501);
260  me["hMEy"] = dbe_->book1D("METTask_MEy","METTask_MEy",2001,-500,501);
261  //me["hEz"] = dbe_->book1D("METTask_Ez","METTask_Ez",2001,-500,501);
262  me["hMETSig"] = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
263  me["hMET"] = dbe_->book1D("METTask_MET","METTask_MET",2001,0,2001);
264  me["hMETPhi"] = dbe_->book1D("METTask_METPhi","METTask_METPhi",80,-4,4);
265  me["hSumET"] = dbe_->book1D("METTask_SumET","METTask_SumET",4001,0,4001);
266 
267  me["hMETResolution_GenMETTrue"] = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue",2000,-1000,1000);
268  me["hMETResolution_GenMETCalo"] = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo",2000,-1000,1000);
269 
270  me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4);
271  me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4);
272 
273 
274  }
275  }
276  else if (METType_ == "TCMET" || inputMETLabel_.label() == "corMetGlobalMuons")
277  {
278  //TCMET or MuonCorrectedCaloMET Histograms
279  if(!finebinning_)
280  {
281  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
282  me["hMEx"] = dbe_->book1D("METTask_MEx","METTask_MEx",1000,-999.5,999.5);
283  me["hMEy"] = dbe_->book1D("METTask_MEy","METTask_MEy",1000,-999.5,999.5);
284  me["hMETSig"] = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
285  me["hMET"] = dbe_->book1D("METTask_MET","METTask_MET",1000,-0.5,1999.5);
286  me["hMETPhi"] = dbe_->book1D("METTask_METPhi","METTask_METPhi",80,-4,4);
287  me["hSumET"] = dbe_->book1D("METTask_SumET","METTask_SumET",1000,-0.50,9999.5);
288 
289  me["hMExCorrection"] = dbe_->book1D("METTask_MExCorrection","METTask_MExCorrection", 1000, -500.0,500.0);
290  me["hMEyCorrection"] = dbe_->book1D("METTask_MEyCorrection","METTask_MEyCorrection", 1000, -500.0,500.0);
291  me["hMuonCorrectionFlag"] = dbe_->book1D("METTask_CorrectionFlag", "METTask_CorrectionFlag", 6, -0.5, 5.5);
292 
293  me["hMETResolution_GenMETTrue"] = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue", 500,-500,500);
294  me["hMETResolution_GenMETCalo"] = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo", 500,-500,500);
295 
296  me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4);
297  me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4);
298 
299  if( METType_ == "TCMET" ) {
300  me["htrkPt"] = dbe_->book1D("METTask_trackPt", "METTask_trackPt", 50, 0, 500);
301  me["htrkEta"] = dbe_->book1D("METTask_trackEta", "METTask_trackEta", 50, -2.5, 2.5);
302  me["htrkNhits"] = dbe_->book1D("METTask_trackNhits", "METTask_trackNhits", 50, 0, 50);
303  me["htrkChi2"] = dbe_->book1D("METTask_trackNormalizedChi2", "METTask_trackNormalizedChi2", 20, 0, 20);
304  me["htrkD0"] = dbe_->book1D("METTask_trackD0", "METTask_trackd0", 50, -1, 1);
305  me["htrkQuality"] = dbe_->book1D("METTask_trackQuality", "METTask_trackQuality", 30, -0.5, 29.5);
306  me["htrkAlgo"] = dbe_->book1D("METTask_trackAlgo", "METTask_trackAlgo", 6, 3.5, 9.5);
307  me["htrkPtErr"] = dbe_->book1D("METTask_trackPtErr", "METTask_trackPtErr", 200, 0, 2);
308  me["helePt"] = dbe_->book1D("METTask_electronPt", "METTask_electronPt", 50, 0, 500);
309  me["heleEta"] = dbe_->book1D("METTask_electronEta", "METTask_electronEta", 50, -2.5, 2.5);
310  me["heleHoE"] = dbe_->book1D("METTask_electronHoverE", "METTask_electronHoverE", 25, 0, 0.5);
311  me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 50, 0, 500);
312  me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 50, -2.5, 2.5);
313  me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
314  me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 20, 0, 20);
315  me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 50, -1, 1);
316  me["hnMus"] = dbe_->book1D("METTask_nMus", "METTask_nMus", 5, -0.5, 4.5);
317  me["hnMusPis"] = dbe_->book1D("METTask_nMusAsPis", "METTask_nMusAsPis", 5, -0.5, 4.5);
318  me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
319  me["hnEls"] = dbe_->book1D("METTask_nEls", "METTask_nEls", 5, -0.5, 4.5);
320  me["hfracTrks"] = dbe_->book1D("METTask_fracTracks", "METTask_fracTracks", 100, 0, 1);
321  me["hdMETx"] = dbe_->book1D("METTask_dMETx", "METTask_dMETx", 500, -250, 250);
322  me["hdMETy"] = dbe_->book1D("METTask_dMETy", "METTask_dMETy", 500, -250, 250);
323  me["hdMET"] = dbe_->book1D("METTask_dMET", "METTask_dMET", 500, -250, 250);
324  me["hdMUx"] = dbe_->book1D("METTask_dMUx", "METTask_dMUx", 500, -250, 250);
325  me["hdMUy"] = dbe_->book1D("METTask_dMUy", "METTask_dMUy", 500, -250, 250);
326  }
327  else if( inputMETLabel_.label() == "corMetGlobalMuons" ) {
328  me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 50, 0, 500);
329  me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 50, -2.5, 2.5);
330  me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
331  me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 20, 0, 20);
332  me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 50, -1, 1);
333  me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
334  }
335  }
336  else
337  {
338  //FineBin
339  me["hNevents"] = dbe_->book1D("METTask_Nevents","METTask_Nevents",1,0,1);
340  me["hMEx"] = dbe_->book1D("METTask_MEx","METTask_MEx",2001,-500,501);
341  me["hMEy"] = dbe_->book1D("METTask_MEy","METTask_MEy",2001,-500,501);
342  me["hMETSig"] = dbe_->book1D("METTask_METSig","METTask_METSig",51,0,51);
343  me["hMET"] = dbe_->book1D("METTask_MET","METTask_MET",2001,0,2001);
344  me["hMETPhi"] = dbe_->book1D("METTask_METPhi","METTask_METPhi",80,-4,4);
345  me["hSumET"] = dbe_->book1D("METTask_SumET","METTask_SumET",4001,0,4001);
346  me["hMExCorrection"] = dbe_->book1D("METTask_MExCorrection","METTask_MExCorrection", 2000, -500.0,500.0);
347  me["hMEyCorrection"] = dbe_->book1D("METTask_MEyCorrection","METTask_MEyCorrection", 2000, -500.0,500.0);
348  me["hMuonCorrectionFlag"] = dbe_->book1D("METTask_CorrectionFlag", "METTask_CorrectionFlag", 6, -0.5, 5.5);
349 
350  me["hMETResolution_GenMETTrue"] = dbe_->book1D("METTask_METResolution_GenMETTrue","METTask_METResolution_GenMETTrue",2000,-1000,1000);
351  me["hMETResolution_GenMETCalo"] = dbe_->book1D("METTask_METResolution_GenMETCalo","METTask_METResolution_GenMETCalo",2000,-1000,1000);
352 
353  me["hMETPhiResolution_GenMETTrue"] = dbe_->book1D("METTask_METPhiResolution_GenMETTrue","METTask_METPhiResolution_GenMETTrue", 80,0,4);
354  me["hMETPhiResolution_GenMETCalo"] = dbe_->book1D("METTask_METPhiResolution_GenMETCalo","METTask_METPhiResolution_GenMETCalo", 80,0,4);
355 
356  if( METType_ == "TCMET" ) {
357  me["htrkPt"] = dbe_->book1D("METTask_trackPt", "METTask_trackPt", 250, 0, 500);
358  me["htrkEta"] = dbe_->book1D("METTask_trackEta", "METTask_trackEta", 250, -2.5, 2.5);
359  me["htrkNhits"] = dbe_->book1D("METTask_trackNhits", "METTask_trackNhits", 50, 0, 50);
360  me["htrkChi2"] = dbe_->book1D("METTask_trackNormalizedChi2", "METTask_trackNormalizedChi2", 100, 0, 20);
361  me["htrkD0"] = dbe_->book1D("METTask_trackD0", "METTask_trackd0", 200, -1, 1);
362  me["htrkQuality"] = dbe_->book1D("METTask_trackQuality", "METTask_trackQuality", 30, -0.5, 29.5);
363  me["htrkAlgo"] = dbe_->book1D("METTask_trackAlgo", "METTask_trackAlgo", 6, 3.5, 9.5);
364  me["htrkPtErr"] = dbe_->book1D("METTask_trackPtErr", "METTask_trackPtErr", 200, 0, 2);
365  me["helePt"] = dbe_->book1D("METTask_electronPt", "METTask_electronPt", 250, 0, 500);
366  me["heleEta"] = dbe_->book1D("METTask_electronEta", "METTask_electronEta", 250, -2.5, 2.5);
367  me["heleHoE"] = dbe_->book1D("METTask_electronHoverE", "METTask_electronHoverE", 100, 0, 0.5);
368  me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 250, 0, 500);
369  me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 250, -2.5, 2.5);
370  me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
371  me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 100, 0, 20);
372  me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 200, -1, 1);
373  me["hnMus"] = dbe_->book1D("METTask_nMus", "METTask_nMus", 5, -0.5, 4.5);
374  me["hnMusPis"] = dbe_->book1D("METTask_nMusAsPis", "METTask_nMusAsPis", 5, -0.5, 4.5);
375  me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
376  me["hnEls"] = dbe_->book1D("METTask_nEls", "METTask_nEls", 5, -0.5, 4.5);
377  me["hfracTrks"] = dbe_->book1D("METTask_fracTracks", "METTask_fracTracks", 100, 0, 1);
378  me["hdMETx"] = dbe_->book1D("METTask_dMETx", "METTask_dMETx", 500, -250, 250);
379  me["hdMETy"] = dbe_->book1D("METTask_dMETy", "METTask_dMETy", 500, -250, 250);
380  me["hdMET"] = dbe_->book1D("METTask_dMET", "METTask_dMET", 500, -250, 250);
381  me["hdMUx"] = dbe_->book1D("METTask_dMUx", "METTask_dMUx", 500, -250, 250);
382  me["hdMUy"] = dbe_->book1D("METTask_dMUy", "METTask_dMUy", 500, -250, 250);
383  }
384  else if( inputMETLabel_.label() == "corMetGlobalMuons" ) {
385  me["hmuPt"] = dbe_->book1D("METTask_muonPt", "METTask_muonPt", 250, 0, 500);
386  me["hmuEta"] = dbe_->book1D("METTask_muonEta", "METTask_muonEta", 250, -2.5, 2.5);
387  me["hmuNhits"] = dbe_->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
388  me["hmuChi2"] = dbe_->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 100, 0, 20);
389  me["hmuD0"] = dbe_->book1D("METTask_muonD0", "METTask_muonD0", 200, -1, 1);
390  me["hmuSAhits"] = dbe_->book1D("METTask_muonSAhits", "METTask_muonSAhits", 51, -0.5, 50.5);
391  }
392  }
393 
394  if(METType_ == "TCMET")
395  {
396  me["hMuonCorrectionFlag"]->setBinLabel(1,"Not Corrected");
397  me["hMuonCorrectionFlag"]->setBinLabel(2,"Global Fit");
398  me["hMuonCorrectionFlag"]->setBinLabel(3,"Tracker Fit");
399  me["hMuonCorrectionFlag"]->setBinLabel(4,"SA Fit");
400  me["hMuonCorrectionFlag"]->setBinLabel(5,"Treated as Pion");
401  me["hMuonCorrectionFlag"]->setBinLabel(6,"Default fit");
402  }
403  else if( inputMETLabel_.label() == "corMetGlobalMuons")
404  {
405  me["hMuonCorrectionFlag"]->setBinLabel(1,"Not Corrected");
406  me["hMuonCorrectionFlag"]->setBinLabel(2,"Global Fit");
407  me["hMuonCorrectionFlag"]->setBinLabel(3,"Tracker Fit");
408  me["hMuonCorrectionFlag"]->setBinLabel(4,"SA Fit");
409  me["hMuonCorrectionFlag"]->setBinLabel(5,"Treated as Pion");
410  me["hMuonCorrectionFlag"]->setBinLabel(6,"Default fit");
411  }
412  }
413  else
414  {
415  edm::LogInfo("OutputInfo") << " METType not correctly specified!'";// << outputFile_.c_str();
416  }
417  }
418 }
METTester::FolderName_
std::string FolderName_
Definition: METTester.h:48
label
const std::string & label
Definition: MVAComputer.cc:186
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:514
METTester::METType_
std::string METType_
Definition: METTester.h:47
METTester::dbe_
DQMStore * dbe_
Definition: METTester.h:43
TrackerOfflineValidation_Dqm_cff.dirName
tuple dirName
Definition: TrackerOfflineValidation_Dqm_cff.py:56
METTester::finebinning_
bool finebinning_
Definition: METTester.h:55
METTester::me
std::map< std::string, MonitorElement * > me
Definition: METTester.h:44
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:25
METTester::inputMETLabel_
edm::InputTag inputMETLabel_
Definition: METTester.h:49
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:232
void METTester::endJob ( void  )
virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1006 of file METTester.cc.

1007 {
1008 }
bool METTester::isGoodTrack ( const reco::TrackRef  track,
float  d0corr 
)
private

Definition at line 1011 of file METTester.cc.

References align_tpl::cut, i, maxchi2_, maxd0_, maxeta_, maxpt_, maxPtErr_, minhits_, trkAlgos_, and trkQuality_.

Referenced by analyze().

1011  {
1012 
1013  if( fabs( d0corr ) > maxd0_ ) return false;
1014  if( track->numberOfValidHits() < minhits_ ) return false;
1015  if( track->normalizedChi2() > maxchi2_ ) return false;
1016  if( fabs( track->eta() ) > maxeta_ ) return false;
1017  if( track->pt() > maxpt_ ) return false;
1018  if( (track->ptError() / track->pt()) > maxPtErr_ ) return false;
1019 
1020  int cut = 0;
1021  for( unsigned int i = 0; i < trkQuality_.size(); i++ ) {
1022 
1023  cut |= (1 << trkQuality_.at(i));
1024  }
1025 
1026  if( !( ( track->qualityMask() & cut ) == cut ) ) return false;
1027 
1028  bool isGoodAlgo = false;
1029  if( trkAlgos_.size() == 0 ) isGoodAlgo = true;
1030  for( unsigned int i = 0; i < trkAlgos_.size(); i++ ) {
1031 
1032  if( track->algo() == trkAlgos_.at(i) ) isGoodAlgo = true;
1033  }
1034 
1035  if( !isGoodAlgo ) return false;
1036 
1037  return true;
1038 }
i
int i
Definition: DBlmapReader.cc:9
METTester::maxchi2_
double maxchi2_
Definition: METTester.h:61
METTester::trkQuality_
std::vector< int > trkQuality_
Definition: METTester.h:65
METTester::trkAlgos_
std::vector< int > trkAlgos_
Definition: METTester.h:66
METTester::maxPtErr_
double maxPtErr_
Definition: METTester.h:64
align_tpl.cut
tuple cut
Definition: align_tpl.py:88
METTester::maxpt_
double maxpt_
Definition: METTester.h:63
METTester::minhits_
int minhits_
Definition: METTester.h:59
METTester::maxeta_
double maxeta_
Definition: METTester.h:62
METTester::maxd0_
double maxd0_
Definition: METTester.h:60

Member Data Documentation

DQMStore* METTester::dbe_
private

Definition at line 43 of file METTester.h.

Referenced by beginRun().

bool METTester::finebinning_
private

Definition at line 55 of file METTester.h.

Referenced by beginRun(), and METTester().

std::string METTester::FolderName_
private

Definition at line 48 of file METTester.h.

Referenced by beginRun(), and METTester().

edm::InputTag METTester::inputBeamSpotLabel_
private

Definition at line 54 of file METTester.h.

Referenced by analyze(), and METTester().

edm::InputTag METTester::inputCaloMETLabel_
private

Definition at line 50 of file METTester.h.

Referenced by analyze(), and METTester().

edm::InputTag METTester::inputElectronLabel_
private

Definition at line 53 of file METTester.h.

Referenced by analyze(), and METTester().

edm::InputTag METTester::inputMETLabel_
private

Definition at line 49 of file METTester.h.

Referenced by analyze(), beginRun(), and METTester().

edm::InputTag METTester::inputMuonLabel_
private

Definition at line 52 of file METTester.h.

Referenced by analyze(), and METTester().

edm::InputTag METTester::inputTrackLabel_
private

Definition at line 51 of file METTester.h.

Referenced by analyze(), and METTester().

double METTester::maxchi2_
private

Definition at line 61 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

double METTester::maxd0_
private

Definition at line 60 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

double METTester::maxeta_
private

Definition at line 62 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

double METTester::maxpt_
private

Definition at line 63 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

double METTester::maxPtErr_
private

Definition at line 64 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

std::map<std::string, MonitorElement*> METTester::me
private

Definition at line 44 of file METTester.h.

Referenced by analyze(), and beginRun().

std::string METTester::METType_
private

Definition at line 47 of file METTester.h.

Referenced by analyze(), beginRun(), and METTester().

int METTester::minhits_
private

Definition at line 59 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

std::vector<int> METTester::trkAlgos_
private

Definition at line 66 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

std::vector<int> METTester::trkQuality_
private

Definition at line 65 of file METTester.h.

Referenced by isGoodTrack(), and METTester().

Generated for CMSSW Reference Manual by doxygen 1.8.5