CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
DataCertificationJetMET Class Reference

#include <DataCertificationJetMET.h>

Inheritance diagram for DataCertificationJetMET:
DQMEDHarvester edm::one::EDProducer< edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::EndProcessBlockProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns, edm::one::SharedResources, edm::Accumulator > edm::one::EDProducerBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

 DataCertificationJetMET (const edm::ParameterSet &)
 
 ~DataCertificationJetMET () override
 
- Public Member Functions inherited from DQMEDHarvester
void accumulate (edm::Event const &ev, edm::EventSetup const &es) final
 
void beginJob () override
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &) override
 
virtual void dqmAnalyze (DQMStore::IBooker &, DQMStore::IGetter &, edm::Event const &, edm::EventSetup const &)
 
 DQMEDHarvester ()
 
 DQMEDHarvester (edm::ParameterSet const &iConfig)
 
virtual void dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)
 
virtual void dqmEndRun (DQMStore::IBooker &, DQMStore::IGetter &, edm::Run const &, edm::EventSetup const &)
 
void endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final
 
void endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &es) final
 
void endProcessBlockProduce (edm::ProcessBlock &) final
 
void endRun (edm::Run const &, edm::EventSetup const &) override
 
void endRunProduce (edm::Run &run, edm::EventSetup const &es) final
 
 ~DQMEDHarvester () override=default
 
- Public Member Functions inherited from edm::one::EDProducer< edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::EndProcessBlockProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns, edm::one::SharedResources, edm::Accumulator >
 EDProducer ()=default
 
SerialTaskQueue * globalLuminosityBlocksQueue () final
 
SerialTaskQueue * globalRunsQueue () final
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
bool wantsInputProcessBlocks () const final
 
bool wantsProcessBlocks () const final
 
- Public Member Functions inherited from edm::one::EDProducerBase
 EDProducerBase ()
 
ModuleDescription const & moduleDescription () const
 
bool wantsStreamLuminosityBlocks () const
 
bool wantsStreamRuns () const
 
 ~EDProducerBase () override
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
std::vector< edm::ProductResolverIndex > const & indiciesForPutProducts (BranchType iBranchType) const
 
 ProducerBase ()
 
std::vector< edm::ProductResolverIndex > const & putTokenIndexToProductResolverIndex () const
 
std::vector< bool > const & recordProvenanceList () const
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription const &)> registrationCallback () const
 used by the fwk to register list of products More...
 
void resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
 
TypeLabelList const & typeLabelList () const
 used by the fwk to register the list of products of this module More...
 
 ~ProducerBase () noexcept(false) override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase &&)=default
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
std::vector< ESProxyIndex > const & esGetTokenIndicesVector (edm::Transition iTrans) const
 
std::vector< ESRecordIndex > const & esGetTokenRecordIndicesVector (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Private Member Functions

void dqmEndJob (DQMStore::IBooker &, DQMStore::IGetter &) override
 

Private Attributes

bool caloJetKSTest
 
bool caloJetMeanTest
 
bool caloMETKSTest
 
bool caloMETMeanTest
 
MonitorElement * CertificationSummary
 
MonitorElement * CertificationSummaryMap
 
edm::ParameterSet conf_
 
int etaBin_
 
double etaMax_
 
double etaMin_
 
std::string folderName
 
edm::Service< TFileService > fs_
 
bool InMemory_
 
edm::InputTag inputJetLabelMiniAOD_
 
edm::InputTag inputJetLabelRECO_
 
edm::InputTag inputMETLabelMiniAOD_
 
edm::InputTag inputMETLabelRECO_
 
edm::InputTag inputMETLabelRECOUncleaned_
 
bool isData
 
bool isHI
 
std::string jetAlgo
 
bool jetTests [5][2]
 
bool jptJetKSTest
 
bool jptJetMeanTest
 
MonitorElement * mChargedHadronEtFraction_MiniAOD_over_Reco
 
MonitorElement * mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
 
MonitorElement * mChargedMultiplicity_MiniAOD_over_Reco
 
MonitorElement * mCHFrac_MiniAOD_over_Reco
 
MonitorElement * mCHFracVSpT_Barrel_MiniAOD_over_Reco
 
MonitorElement * mDPhi_MiniAOD_over_Reco
 
MonitorElement * mEta_MiniAOD_over_Reco
 
MonitorElement * mEta_uncor_MiniAOD_over_Reco
 
std::string metFolder
 
bool metTests [5][2]
 
MonitorElement * mHFEFracVSpT_Forward_MiniAOD_over_Reco
 
MonitorElement * mHFEMEtFraction_MiniAOD_over_Reco
 
MonitorElement * mHFHadronEtFraction_MiniAOD_over_Reco
 
MonitorElement * mHFHFracVSpT_Forward_MiniAOD_over_Reco
 
MonitorElement * mJetEnergyCorr_MiniAOD_over_Reco
 
MonitorElement * mJetEnergyCorrVSeta_MiniAOD_over_Reco
 
MonitorElement * mLooseJIDPassFractionVSeta_MiniAOD_over_Reco
 
MonitorElement * mMET_EffCSCTightHalo2015Filter
 
MonitorElement * mMET_EffCSCTightHaloFilter
 
MonitorElement * mMET_EffEcalDeadCellBoundaryFilter
 
MonitorElement * mMET_EffEcalDeadCellTriggerFilter
 
MonitorElement * mMET_EffeeBadScFilter
 
MonitorElement * mMET_EffHBHEIsoNoiseFilter
 
MonitorElement * mMET_EffHBHENoiseFilter
 
MonitorElement * mMET_EffHcalStripHaloFilter
 
MonitorElement * mMET_logx_MiniAOD_over_Reco
 
MonitorElement * mMET_MiniAOD_over_Reco
 
MonitorElement * mMET_nVtx_profile_MiniAOD_over_Reco
 
MonitorElement * mMETPhi_MiniAOD_over_Reco
 
MonitorElement * mMEy_MiniAOD_over_Reco
 
MonitorElement * mMuonMultiplicity_MiniAOD_over_Reco
 
MonitorElement * mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco
 
MonitorElement * mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco
 
MonitorElement * mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco
 
MonitorElement * mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco
 
MonitorElement * mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco
 
MonitorElement * mNeutralFraction_MiniAOD_over_Reco
 
MonitorElement * mNeutralHadronEtFraction_MiniAOD_over_Reco
 
MonitorElement * mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
 
MonitorElement * mNeutralMultiplicity_MiniAOD_over_Reco
 
MonitorElement * mNHFrac_MiniAOD_over_Reco
 
MonitorElement * mNHFracVSpT_EndCap_MiniAOD_over_Reco
 
MonitorElement * mNjets_MiniAOD_over_Reco
 
MonitorElement * mPhFrac_MiniAOD_over_Reco
 
MonitorElement * mPhFracVSpT_Barrel_MiniAOD_over_Reco
 
MonitorElement * mPhi_MiniAOD_over_Reco
 
MonitorElement * mPhi_uncor_MiniAOD_over_Reco
 
MonitorElement * mPhotonEtFraction_MiniAOD_over_Reco
 
MonitorElement * mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco
 
MonitorElement * mPt_Barrel_MiniAOD_over_Reco
 
MonitorElement * mPt_EndCap_MiniAOD_over_Reco
 
MonitorElement * mPt_Forward_MiniAOD_over_Reco
 
MonitorElement * mPt_MiniAOD_over_Reco
 
MonitorElement * mPt_uncor_MiniAOD_over_Reco
 
MonitorElement * mSumET_logx_MiniAOD_over_Reco
 
MonitorElement * mSumET_MiniAOD_over_Reco
 
MonitorElement * mSumET_nVtx_profile_MiniAOD_over_Reco
 
int nbinsPV_
 
double nPVMax_
 
double nPVMin_
 
bool pfJetKSTest
 
bool pfJetMeanTest
 
bool pfMETKSTest
 
bool pfMETMeanTest
 
int ptBin_
 
double ptMax_
 
double ptMin_
 
MonitorElement * reportSummary
 
MonitorElement * reportSummaryMap
 
bool tcMETKSTest
 
bool tcMETMeanTest
 
int verbose_
 

Additional Inherited Members

- Public Types inherited from DQMEDHarvester
typedef dqm::harvesting::DQMStore DQMStore
 
typedef dqm::harvesting::MonitorElement MonitorElement
 
- Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase ModuleType
 
- Public Types inherited from edm::ProducerBase
using ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex > >
 
typedef ProductRegistryHelper::TypeLabelList TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType > produces ()
 declare what type of product will make and with which optional label More...
 
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType > produces ()
 
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType > produces ()
 
BranchAliasSetter produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
 
template<BranchType B>
BranchAliasSetter produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
 
template<Transition B>
BranchAliasSetter produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
 
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType > produces (std::string instanceName)
 
template<class ProductType >
BranchAliasSetterT< ProductType > produces (std::string instanceName)
 
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType > produces (std::string instanceName)
 
ProducesCollector producesCollector ()
 
- Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B > consumes (edm::InputTag tag) noexcept
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<Transition Tr = Transition::Event>
constexpr auto esConsumes () noexcept
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<Transition Tr = Transition::Event>
auto esConsumes (ESInputTag tag) noexcept
 
template<Transition Tr = Transition::Event>
ESGetTokenGeneric esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
 Used with EventSetupRecord::doGet. More...
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
- Protected Attributes inherited from DQMEDHarvester
DQMStore * dqmstore_
 
edm::GetterOfProducts< DQMToken > jobmegetter_
 
edm::EDPutTokenT< DQMToken > jobToken_
 
edm::GetterOfProducts< DQMToken > lumimegetter_
 
edm::EDPutTokenT< DQMToken > lumiToken_
 
edm::GetterOfProducts< DQMToken > runmegetter_
 
edm::EDPutTokenT< DQMToken > runToken_
 

Detailed Description

Definition at line 28 of file DataCertificationJetMET.h.

Constructor & Destructor Documentation

◆ DataCertificationJetMET()

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

Definition at line 18 of file DataCertificationJetMET.cc.

18  : conf_(iConfig) {
19  // now do what ever initialization is needed
20  inputMETLabelRECO_ = iConfig.getParameter<edm::InputTag>("METTypeRECO");
21  inputMETLabelRECOUncleaned_ = iConfig.getParameter<edm::InputTag>("METTypeRECOUncleaned");
22  inputMETLabelMiniAOD_ = iConfig.getParameter<edm::InputTag>("METTypeMiniAOD");
23  inputJetLabelRECO_ = iConfig.getParameter<edm::InputTag>("JetTypeRECO");
24  inputJetLabelMiniAOD_ = iConfig.getParameter<edm::InputTag>("JetTypeMiniAOD");
25 
26  nbinsPV_ = iConfig.getParameter<int>("pVBin");
27  nPVMin_ = iConfig.getParameter<double>("pVMin");
28  nPVMax_ = iConfig.getParameter<double>("pVMax");
29 
30  etaBin_ = iConfig.getParameter<int>("etaBin");
31  etaMin_ = iConfig.getParameter<double>("etaMin");
32  etaMax_ = iConfig.getParameter<double>("etaMax");
33 
34  ptBin_ = iConfig.getParameter<int>("ptBin");
35  ptMin_ = iConfig.getParameter<double>("ptMin");
36  ptMax_ = iConfig.getParameter<double>("ptMax");
37 
38  // -----------------------------------------
39  // verbose_ 0: suppress printouts
40  // 1: show printouts
41  verbose_ = conf_.getUntrackedParameter<int>("Verbose", 0);
42  metFolder = conf_.getUntrackedParameter<std::string>("metFolder");
43  jetAlgo = conf_.getUntrackedParameter<std::string>("jetAlgo");
44  folderName = conf_.getUntrackedParameter<std::string>("folderName");
45 
46  jetTests[0][0] = conf_.getUntrackedParameter<bool>("pfBarrelJetMeanTest", true);
47  jetTests[0][1] = conf_.getUntrackedParameter<bool>("pfBarrelJetKSTest", false);
48  jetTests[1][0] = conf_.getUntrackedParameter<bool>("pfEndcapJetMeanTest", true);
49  jetTests[1][1] = conf_.getUntrackedParameter<bool>("pfEndcapJetKSTest", false);
50  jetTests[2][0] = conf_.getUntrackedParameter<bool>("pfForwardJetMeanTest", true);
51  jetTests[2][1] = conf_.getUntrackedParameter<bool>("pfForwardJetKSTest", false);
52  jetTests[3][0] = conf_.getUntrackedParameter<bool>("caloJetMeanTest", true);
53  jetTests[3][1] = conf_.getUntrackedParameter<bool>("caloJetKSTest", false);
54  jetTests[4][0] = conf_.getUntrackedParameter<bool>("jptJetMeanTest", true);
55  jetTests[4][1] = conf_.getUntrackedParameter<bool>("jptJetKSTest", false);
56 
57  metTests[0][0] = conf_.getUntrackedParameter<bool>("caloMETMeanTest", true);
58  metTests[0][1] = conf_.getUntrackedParameter<bool>("caloMETKSTest", false);
59  metTests[1][0] = conf_.getUntrackedParameter<bool>("pfMETMeanTest", true);
60  metTests[1][1] = conf_.getUntrackedParameter<bool>("pfMETKSTest", false);
61  metTests[2][0] = conf_.getUntrackedParameter<bool>("tcMETMeanTest", true);
62  metTests[2][1] = conf_.getUntrackedParameter<bool>("tcMETKSTest", false);
63 
64  isHI = conf_.getUntrackedParameter<bool>("isHI", false);
65 
66  if (verbose_)
67  std::cout << ">>> Constructor (DataCertificationJetMET) <<<" << std::endl;
68 
69  // -----------------------------------------
70  //
71 }

References conf_, gather_cfg::cout, etaBin_, etaMax_, etaMin_, folderName, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inputJetLabelMiniAOD_, inputJetLabelRECO_, inputMETLabelMiniAOD_, inputMETLabelRECO_, inputMETLabelRECOUncleaned_, isHI, jetAlgo, jetTests, metFolder, metTests, nbinsPV_, nPVMax_, nPVMin_, ptBin_, ptMax_, ptMin_, AlCaHLTBitMon_QueryRunRegistry::string, and verbose_.

◆ ~DataCertificationJetMET()

DataCertificationJetMET::~DataCertificationJetMET ( )
override

Definition at line 73 of file DataCertificationJetMET.cc.

73  {
74  // do anything here that needs to be done at desctruction time
75  // (e.g. close files, deallocate resources etc.)
76  if (verbose_)
77  std::cout << ">>> Deconstructor (DataCertificationJetMET) <<<" << std::endl;
78 }

References gather_cfg::cout, and verbose_.

Member Function Documentation

◆ dqmEndJob()

void DataCertificationJetMET::dqmEndJob ( DQMStore::IBooker &  ibook_,
DQMStore::IGetter &  iget_ 
)
overrideprivatevirtual

Implements DQMEDHarvester.

Definition at line 81 of file DataCertificationJetMET.cc.

81  {
82  //put RECO vs MiniAODDir first ->first MET
83  std::vector<std::string> subDirVecMET;
84  std::string RunDirMET = "JetMET/MET/";
85  iget_.setCurrentFolder(RunDirMET);
86  subDirVecMET = iget_.getSubdirs();
87  bool found_METreco_dir = false;
88  bool found_METminiaod_dir = false;
89  //check if proper directories are inside the files
90  for (int i = 0; i < int(subDirVecMET.size()); i++) {
91  ibook_.setCurrentFolder(subDirVecMET[i]);
92  if ((subDirVecMET[i] + "/Cleaned") == (RunDirMET + inputMETLabelRECO_.label() + "/Cleaned")) {
93  found_METreco_dir = true;
94  }
95  if (((subDirVecMET[i] + "/Uncleaned") == (RunDirMET + inputMETLabelRECOUncleaned_.label() + "/Uncleaned")) ||
96  ((subDirVecMET[i] + "/Uncleaned") == (RunDirMET + inputMETLabelMiniAOD_.label() + "/Uncleaned"))) {
97  //check filters in uncleaned directory
98  std::string rundirMET_reco = "";
99  if ((subDirVecMET[i] + "/Uncleaned") == (RunDirMET + inputMETLabelRECOUncleaned_.label() + "/Uncleaned")) {
100  rundirMET_reco = RunDirMET + inputMETLabelRECOUncleaned_.label() + "/Uncleaned";
101  } else {
102  rundirMET_reco = RunDirMET + inputMETLabelMiniAOD_.label() + "/Uncleaned";
103  }
104  MonitorElement* mMET_Reco = iget_.get(rundirMET_reco + "/" + "MET");
105  MonitorElement* mMET_Reco_HBHENoiseFilter = iget_.get(rundirMET_reco + "/" + "MET_HBHENoiseFilter");
106  MonitorElement* mMET_Reco_CSCTightHaloFilter = iget_.get(rundirMET_reco + "/" + "MET_CSCTightHaloFilter");
107  MonitorElement* mMET_Reco_eeBadScFilter = iget_.get(rundirMET_reco + "/" + "MET_eeBadScFilter");
108  MonitorElement* mMET_Reco_HBHEIsoNoiseFilter = iget_.get(rundirMET_reco + "/" + "MET_HBHEIsoNoiseFilter");
109  MonitorElement* mMET_Reco_CSCTightHalo2015Filter = iget_.get(rundirMET_reco + "/" + "MET_CSCTightHalo2015Filter");
110  MonitorElement* mMET_Reco_EcalDeadCellTriggerFilter =
111  iget_.get(rundirMET_reco + "/" + "MET_EcalDeadCellTriggerFilter");
112  MonitorElement* mMET_Reco_EcalDeadCellBoundaryFilter =
113  iget_.get(rundirMET_reco + "/" + "MET_EcalDeadCellBoundaryFilter");
114  MonitorElement* mMET_Reco_HcalStripHaloFilter = iget_.get(rundirMET_reco + "/" + "MET_HcalStripHaloFilter");
115  ibook_.setCurrentFolder(rundirMET_reco);
116  mMET_EffHBHENoiseFilter =
117  ibook_.book1D("MET_EffHBHENoiseFilter", (TH1F*)mMET_Reco_HBHENoiseFilter->getRootObject());
118  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
119  if (mMET_Reco->getBinContent(i) != 0) {
120  mMET_EffHBHENoiseFilter->setBinContent(
121  i, mMET_Reco_HBHENoiseFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
122  } else {
123  mMET_EffHBHENoiseFilter->setBinContent(i, 0);
124  }
125  }
126  mMET_EffCSCTightHaloFilter =
127  ibook_.book1D("MET_EffCSCTightHaloFilter", (TH1F*)mMET_Reco_CSCTightHaloFilter->getRootObject());
128  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
129  if (mMET_Reco->getBinContent(i) != 0) {
130  mMET_EffCSCTightHaloFilter->setBinContent(
131  i, mMET_Reco_CSCTightHaloFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
132  } else {
133  mMET_EffCSCTightHaloFilter->setBinContent(i, 0);
134  }
135  }
136  mMET_EffeeBadScFilter = ibook_.book1D("MET_EffeeBadScFilter", (TH1F*)mMET_Reco_eeBadScFilter->getRootObject());
137  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
138  if (mMET_Reco->getBinContent(i) != 0) {
139  mMET_EffeeBadScFilter->setBinContent(i,
140  mMET_Reco_eeBadScFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
141  } else {
142  mMET_EffeeBadScFilter->setBinContent(i, 0);
143  }
144  }
145  mMET_EffHBHEIsoNoiseFilter =
146  ibook_.book1D("MET_EffHBHEIsoNoiseFilter", (TH1F*)mMET_Reco_HBHEIsoNoiseFilter->getRootObject());
147  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
148  if (mMET_Reco->getBinContent(i) != 0) {
149  mMET_EffHBHEIsoNoiseFilter->setBinContent(
150  i, mMET_Reco_HBHEIsoNoiseFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
151  } else {
152  mMET_EffHBHEIsoNoiseFilter->setBinContent(i, 0);
153  }
154  }
155  mMET_EffCSCTightHalo2015Filter =
156  ibook_.book1D("MET_EffCSCTightHalo2015Filter", (TH1F*)mMET_Reco_CSCTightHalo2015Filter->getRootObject());
157  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
158  if (mMET_Reco->getBinContent(i) != 0) {
159  mMET_EffCSCTightHalo2015Filter->setBinContent(
160  i, mMET_Reco_CSCTightHalo2015Filter->getBinContent(i) / mMET_Reco->getBinContent(i));
161  } else {
162  mMET_EffCSCTightHalo2015Filter->setBinContent(i, 0);
163  }
164  }
165  mMET_EffEcalDeadCellTriggerFilter = ibook_.book1D("MET_EffEcalDeadCellTriggerFilter",
166  (TH1F*)mMET_Reco_EcalDeadCellTriggerFilter->getRootObject());
167  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
168  if (mMET_Reco->getBinContent(i) != 0) {
169  mMET_EffEcalDeadCellTriggerFilter->setBinContent(
170  i, mMET_Reco_EcalDeadCellTriggerFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
171  } else {
172  mMET_EffEcalDeadCellTriggerFilter->setBinContent(i, 0);
173  }
174  }
175  mMET_EffEcalDeadCellBoundaryFilter = ibook_.book1D("MET_EffEcalDeadCellBoundaryFilter",
176  (TH1F*)mMET_Reco_EcalDeadCellBoundaryFilter->getRootObject());
177  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
178  if (mMET_Reco->getBinContent(i) != 0) {
179  mMET_EffEcalDeadCellBoundaryFilter->setBinContent(
180  i, mMET_Reco_EcalDeadCellBoundaryFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
181  } else {
182  mMET_EffEcalDeadCellBoundaryFilter->setBinContent(i, 0);
183  }
184  }
185  mMET_EffHcalStripHaloFilter =
186  ibook_.book1D("MET_EffHcalStripHaloFilter", (TH1F*)mMET_Reco_HcalStripHaloFilter->getRootObject());
187  for (int i = 0; i <= (mMET_Reco->getNbinsX() + 1); i++) {
188  if (mMET_Reco->getBinContent(i) != 0) {
189  mMET_EffHcalStripHaloFilter->setBinContent(
190  i, mMET_Reco_HcalStripHaloFilter->getBinContent(i) / mMET_Reco->getBinContent(i));
191  } else {
192  mMET_EffHcalStripHaloFilter->setBinContent(i, 0);
193  }
194  }
195  }
196  if ((subDirVecMET[i] + "/Cleaned") == (RunDirMET + inputMETLabelMiniAOD_.label() + "/Cleaned")) {
197  found_METminiaod_dir = true;
198  }
199  }
200  if (found_METreco_dir && found_METminiaod_dir) {
201  std::string rundirMET_reco = RunDirMET + inputMETLabelRECO_.label() + "/Cleaned";
202  std::string rundirMET_miniaod = RunDirMET + inputMETLabelMiniAOD_.label() + "/Cleaned";
203  MonitorElement* mMET_Reco = iget_.get(rundirMET_reco + "/" + "MET");
204  MonitorElement* mMEy_Reco = iget_.get(rundirMET_reco + "/" + "MEy");
205  MonitorElement* mSumET_Reco = iget_.get(rundirMET_reco + "/" + "SumET");
206  MonitorElement* mMETPhi_Reco = iget_.get(rundirMET_reco + "/" + "METPhi");
207  MonitorElement* mMET_logx_Reco = iget_.get(rundirMET_reco + "/" + "MET_logx");
208  MonitorElement* mSumET_logx_Reco = iget_.get(rundirMET_reco + "/" + "SumET_logx");
209  MonitorElement* mChargedHadronEtFraction_Reco = iget_.get(rundirMET_reco + "/" + "PfChargedHadronEtFraction");
210  MonitorElement* mNeutralHadronEtFraction_Reco = iget_.get(rundirMET_reco + "/" + "PfNeutralHadronEtFraction");
211  MonitorElement* mPhotonEtFraction_Reco = iget_.get(rundirMET_reco + "/" + "PfPhotonEtFraction");
212  MonitorElement* mHFHadronEtFraction_Reco = iget_.get(rundirMET_reco + "/" + "PfHFHadronEtFraction");
213  MonitorElement* mHFEMEtFraction_Reco = iget_.get(rundirMET_reco + "/" + "PfHFEMEtFraction");
214  MonitorElement* mMET_nVtx_profile_Reco = iget_.get(rundirMET_reco + "/" + "MET_profile");
215  MonitorElement* mSumET_nVtx_profile_Reco = iget_.get(rundirMET_reco + "/" + "SumET_profile");
216  MonitorElement* mChargedHadronEtFraction_nVtx_profile_Reco =
217  iget_.get(rundirMET_reco + "/" + "PfChargedHadronEtFraction_profile");
218  MonitorElement* mNeutralHadronEtFraction_nVtx_profile_Reco =
219  iget_.get(rundirMET_reco + "/" + "PfNeutralHadronEtFraction_profile");
220  MonitorElement* mPhotonEtFraction_nVtx_profile_Reco =
221  iget_.get(rundirMET_reco + "/" + "PfPhotonEtFraction_profile");
222 
223  std::vector<MonitorElement*> me_MET_Reco;
224  me_MET_Reco.push_back(mMET_Reco);
225  me_MET_Reco.push_back(mMEy_Reco);
226  me_MET_Reco.push_back(mSumET_Reco);
227  me_MET_Reco.push_back(mMETPhi_Reco);
228  me_MET_Reco.push_back(mMET_logx_Reco);
229  me_MET_Reco.push_back(mSumET_logx_Reco);
230  me_MET_Reco.push_back(mChargedHadronEtFraction_Reco);
231  me_MET_Reco.push_back(mNeutralHadronEtFraction_Reco);
232  me_MET_Reco.push_back(mPhotonEtFraction_Reco);
233  me_MET_Reco.push_back(mHFHadronEtFraction_Reco);
234  me_MET_Reco.push_back(mHFEMEtFraction_Reco);
235  me_MET_Reco.push_back(mMET_nVtx_profile_Reco);
236  me_MET_Reco.push_back(mSumET_nVtx_profile_Reco);
237  me_MET_Reco.push_back(mChargedHadronEtFraction_nVtx_profile_Reco);
238  me_MET_Reco.push_back(mNeutralHadronEtFraction_nVtx_profile_Reco);
239  me_MET_Reco.push_back(mPhotonEtFraction_nVtx_profile_Reco);
240 
241  MonitorElement* mMET_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "MET");
242  MonitorElement* mMEy_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "MEy");
243  MonitorElement* mSumET_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "SumET");
244  MonitorElement* mMETPhi_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "METPhi");
245  MonitorElement* mMET_logx_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "MET_logx");
246  MonitorElement* mSumET_logx_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "SumET_logx");
247  MonitorElement* mChargedHadronEtFraction_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "PfChargedHadronEtFraction");
248  MonitorElement* mNeutralHadronEtFraction_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "PfNeutralHadronEtFraction");
249  MonitorElement* mPhotonEtFraction_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "PfPhotonEtFraction");
250  MonitorElement* mHFHadronEtFraction_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "PfHFHadronEtFraction");
251  MonitorElement* mHFEMEtFraction_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "PfHFEMEtFraction");
252  MonitorElement* mMET_nVtx_profile_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "MET_profile");
253  MonitorElement* mSumET_nVtx_profile_MiniAOD = iget_.get(rundirMET_miniaod + "/" + "SumET_profile");
254  MonitorElement* mChargedHadronEtFraction_nVtx_profile_MiniAOD =
255  iget_.get(rundirMET_miniaod + "/" + "PfChargedHadronEtFraction_profile");
256  MonitorElement* mNeutralHadronEtFraction_nVtx_profile_MiniAOD =
257  iget_.get(rundirMET_miniaod + "/" + "PfNeutralHadronEtFraction_profile");
258  MonitorElement* mPhotonEtFraction_nVtx_profile_MiniAOD =
259  iget_.get(rundirMET_miniaod + "/" + "PfPhotonEtFraction_profile");
260 
261  std::vector<MonitorElement*> me_MET_MiniAOD;
262  me_MET_MiniAOD.push_back(mMET_MiniAOD);
263  me_MET_MiniAOD.push_back(mMEy_MiniAOD);
264  me_MET_MiniAOD.push_back(mSumET_MiniAOD);
265  me_MET_MiniAOD.push_back(mMETPhi_MiniAOD);
266  me_MET_MiniAOD.push_back(mMET_logx_MiniAOD);
267  me_MET_MiniAOD.push_back(mSumET_logx_MiniAOD);
268  me_MET_MiniAOD.push_back(mChargedHadronEtFraction_MiniAOD);
269  me_MET_MiniAOD.push_back(mNeutralHadronEtFraction_MiniAOD);
270  me_MET_MiniAOD.push_back(mPhotonEtFraction_MiniAOD);
271  me_MET_MiniAOD.push_back(mHFHadronEtFraction_MiniAOD);
272  me_MET_MiniAOD.push_back(mHFEMEtFraction_MiniAOD);
273  me_MET_MiniAOD.push_back(mMET_nVtx_profile_MiniAOD);
274  me_MET_MiniAOD.push_back(mSumET_nVtx_profile_MiniAOD);
275  me_MET_MiniAOD.push_back(mChargedHadronEtFraction_nVtx_profile_MiniAOD);
276  me_MET_MiniAOD.push_back(mNeutralHadronEtFraction_nVtx_profile_MiniAOD);
277  me_MET_MiniAOD.push_back(mPhotonEtFraction_nVtx_profile_MiniAOD);
278 
279  ibook_.setCurrentFolder(RunDirMET + "MiniAOD_over_RECO");
280  mMET_MiniAOD_over_Reco = ibook_.book1D("MET_MiniAOD_over_RECO", (TH1F*)mMET_Reco->getRootObject());
281  mMEy_MiniAOD_over_Reco = ibook_.book1D("MEy_MiniAOD_over_RECO", (TH1F*)mMEy_Reco->getRootObject());
282  mSumET_MiniAOD_over_Reco = ibook_.book1D("SumET_MiniAOD_over_RECO", (TH1F*)mSumET_Reco->getRootObject());
283  mMETPhi_MiniAOD_over_Reco = ibook_.book1D("METPhi_MiniAOD_over_RECO", (TH1F*)mMETPhi_Reco->getRootObject());
284  mMET_logx_MiniAOD_over_Reco = ibook_.book1D("MET_logx_MiniAOD_over_RECO", (TH1F*)mMET_logx_Reco->getRootObject());
285  mSumET_logx_MiniAOD_over_Reco =
286  ibook_.book1D("SumET_logx_MiniAOD_over_RECO", (TH1F*)mSumET_logx_Reco->getRootObject());
287  mChargedHadronEtFraction_MiniAOD_over_Reco = ibook_.book1D("PfChargedHadronEtFraction_MiniAOD_over_RECO",
288  (TH1F*)mChargedHadronEtFraction_Reco->getRootObject());
289  mNeutralHadronEtFraction_MiniAOD_over_Reco = ibook_.book1D("PfNeutralHadronEtFraction_MiniAOD_over_RECO",
290  (TH1F*)mNeutralHadronEtFraction_Reco->getRootObject());
291  mPhotonEtFraction_MiniAOD_over_Reco =
292  ibook_.book1D("PfPhotonEtFraction_MiniAOD_over_RECO", (TH1F*)mPhotonEtFraction_Reco->getRootObject());
293  mHFHadronEtFraction_MiniAOD_over_Reco =
294  ibook_.book1D("PfHFHadronEtFraction_MiniAOD_over_RECO", (TH1F*)mHFHadronEtFraction_Reco->getRootObject());
295  mHFEMEtFraction_MiniAOD_over_Reco =
296  ibook_.book1D("PfHFEMEtFraction_MiniAOD_over_RECO", (TH1F*)mHFEMEtFraction_Reco->getRootObject());
297  //use same parameters defining X-Axis of the profiles
298  mMET_nVtx_profile_MiniAOD_over_Reco =
299  ibook_.book1D("MET_profile_MiniAOD_over_RECO", "MET_vs_nVtx", nbinsPV_, nPVMin_, nPVMax_);
300  mSumET_nVtx_profile_MiniAOD_over_Reco =
301  ibook_.book1D("SumET_profile_MiniAOD_over_RECO", "SumET_vs_nVtx", nbinsPV_, nPVMin_, nPVMax_);
302  mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco =
303  ibook_.book1D("PfChargedHadronEtFraction_profile_MiniAOD_over_RECO",
304  "PfChargedHadronEtFraction_vs_nVtx",
305  nbinsPV_,
306  nPVMin_,
307  nPVMax_);
308  mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco =
309  ibook_.book1D("PfNeutralHadronEtFraction_profile_MiniAOD_over_RECO",
310  "PfNeutralHadronEtFraction_vs_nVtx",
311  nbinsPV_,
312  nPVMin_,
313  nPVMax_);
314  mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco = ibook_.book1D(
315  "PfPhotonEtFraction_profile_MiniAOD_over_RECO", "PfPhotonEtFraction_vs_nVtx", nbinsPV_, nPVMin_, nPVMax_);
316 
317  std::vector<MonitorElement*> me_MET_MiniAOD_over_Reco;
318  me_MET_MiniAOD_over_Reco.push_back(mMET_MiniAOD_over_Reco);
319  me_MET_MiniAOD_over_Reco.push_back(mMEy_MiniAOD_over_Reco);
320  me_MET_MiniAOD_over_Reco.push_back(mSumET_MiniAOD_over_Reco);
321  me_MET_MiniAOD_over_Reco.push_back(mMETPhi_MiniAOD_over_Reco);
322  me_MET_MiniAOD_over_Reco.push_back(mMET_logx_MiniAOD_over_Reco);
323  me_MET_MiniAOD_over_Reco.push_back(mSumET_logx_MiniAOD_over_Reco);
324  me_MET_MiniAOD_over_Reco.push_back(mChargedHadronEtFraction_MiniAOD_over_Reco);
325  me_MET_MiniAOD_over_Reco.push_back(mNeutralHadronEtFraction_MiniAOD_over_Reco);
326  me_MET_MiniAOD_over_Reco.push_back(mPhotonEtFraction_MiniAOD_over_Reco);
327  me_MET_MiniAOD_over_Reco.push_back(mHFHadronEtFraction_MiniAOD_over_Reco);
328  me_MET_MiniAOD_over_Reco.push_back(mHFEMEtFraction_MiniAOD_over_Reco);
329  me_MET_MiniAOD_over_Reco.push_back(mMET_nVtx_profile_MiniAOD_over_Reco);
330  me_MET_MiniAOD_over_Reco.push_back(mSumET_nVtx_profile_MiniAOD_over_Reco);
331  me_MET_MiniAOD_over_Reco.push_back(mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco);
332  me_MET_MiniAOD_over_Reco.push_back(mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco);
333  me_MET_MiniAOD_over_Reco.push_back(mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco);
334 
335  for (unsigned int j = 0; j < me_MET_MiniAOD_over_Reco.size(); j++) {
336  MonitorElement* monMETReco = me_MET_Reco[j];
337  if (monMETReco && monMETReco->getRootObject()) {
338  MonitorElement* monMETMiniAOD = me_MET_MiniAOD[j];
339  if (monMETMiniAOD && monMETMiniAOD->getRootObject()) {
340  MonitorElement* monMETMiniAOD_over_RECO = me_MET_MiniAOD_over_Reco[j];
341  if (monMETMiniAOD_over_RECO && monMETMiniAOD_over_RECO->getRootObject()) {
342  for (int i = 0; i <= (monMETMiniAOD_over_RECO->getNbinsX() + 1); i++) {
343  if (monMETReco->getBinContent(i) != 0) {
344  monMETMiniAOD_over_RECO->setBinContent(i,
345  monMETMiniAOD->getBinContent(i) / monMETReco->getBinContent(i));
346  } else if (monMETMiniAOD->getBinContent(i) != 0) {
347  monMETMiniAOD_over_RECO->setBinContent(i, -0.5);
348  }
349  }
350  }
351  }
352  }
353  }
354  } //check for RECO and MiniAOD directories
355 
356  //put RECO vs MiniAODDir first ->second Jets
357  std::vector<std::string> subDirVecJet;
358  //go only for cleaned directory
359  std::string RunDirJet = "JetMET/Jet/";
360  iget_.setCurrentFolder(RunDirJet);
361  subDirVecJet = iget_.getSubdirs();
362  bool found_Jetreco_dir = false;
363  bool found_Jetminiaod_dir = false;
364  for (int i = 0; i < int(subDirVecJet.size()); i++) {
365  ibook_.setCurrentFolder(subDirVecJet[i]);
366  if (subDirVecJet[i] == (RunDirJet + "Cleaned" + inputJetLabelRECO_.label())) {
367  found_Jetreco_dir = true;
368  }
369  if (subDirVecJet[i] == (RunDirJet + "Cleaned" + inputJetLabelMiniAOD_.label())) {
370  found_Jetminiaod_dir = true;
371  }
372  }
373  if (found_Jetreco_dir && found_Jetminiaod_dir) {
374  std::string rundirJet_reco = RunDirJet + "Cleaned" + inputJetLabelRECO_.label();
375  std::string rundirJet_miniaod = RunDirJet + "Cleaned" + inputJetLabelMiniAOD_.label();
376 
377  MonitorElement* mPt_Reco = iget_.get(rundirJet_reco + "/" + "Pt");
378  MonitorElement* mEta_Reco = iget_.get(rundirJet_reco + "/" + "Eta");
379  MonitorElement* mPhi_Reco = iget_.get(rundirJet_reco + "/" + "Phi");
380  MonitorElement* mNjets_Reco = iget_.get(rundirJet_reco + "/" + "NJets");
381  MonitorElement* mPt_uncor_Reco = iget_.get(rundirJet_reco + "/" + "Pt_uncor");
382  MonitorElement* mEta_uncor_Reco = iget_.get(rundirJet_reco + "/" + "Eta_uncor");
383  MonitorElement* mPhi_uncor_Reco = iget_.get(rundirJet_reco + "/" + "Phi_uncor");
384  MonitorElement* mJetEnergyCorr_Reco = iget_.get(rundirJet_reco + "/" + "JetEnergyCorr");
385  MonitorElement* mJetEnergyCorrVSeta_Reco = iget_.get(rundirJet_reco + "/" + "JetEnergyCorrVSEta");
386  MonitorElement* mDPhi_Reco = iget_.get(rundirJet_reco + "/" + "DPhi");
387  MonitorElement* mLooseJIDPassFractionVSeta_Reco = iget_.get(rundirJet_reco + "/" + "JetIDPassFractionVSeta");
388  MonitorElement* mPt_Barrel_Reco = iget_.get(rundirJet_reco + "/" + "Pt_Barrel");
389  MonitorElement* mPt_EndCap_Reco = iget_.get(rundirJet_reco + "/" + "Pt_EndCap");
390  MonitorElement* mPt_Forward_Reco = iget_.get(rundirJet_reco + "/" + "Pt_Forward");
391  MonitorElement* mMVAPUJIDDiscriminant_lowPt_Barrel_Reco =
392  iget_.get(rundirJet_reco + "/" + "MVAPUJIDDiscriminant_lowPt_Barrel");
393  MonitorElement* mMVAPUJIDDiscriminant_lowPt_EndCap_Reco =
394  iget_.get(rundirJet_reco + "/" + "MVAPUJIDDiscriminant_lowPt_EndCap");
395  MonitorElement* mMVAPUJIDDiscriminant_lowPt_Forward_Reco =
396  iget_.get(rundirJet_reco + "/" + "MVAPUJIDDiscriminant_lowPt_Forward");
397  MonitorElement* mMVAPUJIDDiscriminant_mediumPt_EndCap_Reco =
398  iget_.get(rundirJet_reco + "/" + "MVAPUJIDDiscriminant_mediumPt_EndCap");
399  MonitorElement* mMVAPUJIDDiscriminant_highPt_Barrel_Reco =
400  iget_.get(rundirJet_reco + "/" + "MVAPUJIDDiscriminant_highPt_Barrel");
401  MonitorElement* mCHFracVSpT_Barrel_Reco = iget_.get(rundirJet_reco + "/" + "CHFracVSpT_Barrel");
402  MonitorElement* mNHFracVSpT_EndCap_Reco = iget_.get(rundirJet_reco + "/" + "NHFracVSpT_EndCap");
403  MonitorElement* mPhFracVSpT_Barrel_Reco = iget_.get(rundirJet_reco + "/" + "PhFracVSpT_Barrel");
404  MonitorElement* mHFHFracVSpT_Forward_Reco = iget_.get(rundirJet_reco + "/" + "HFHFracVSpT_Forward");
405  MonitorElement* mHFEFracVSpT_Forward_Reco = iget_.get(rundirJet_reco + "/" + "HFEFracVSpT_Forward");
406  MonitorElement* mCHFrac_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "CHFrac");
407  MonitorElement* mNHFrac_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "NHFrac");
408  MonitorElement* mPhFrac_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "PhFrac");
409  MonitorElement* mChargedMultiplicity_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "ChargedMultiplicity");
410  MonitorElement* mNeutralMultiplicity_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "NeutralMultiplicity");
411  MonitorElement* mMuonMultiplicity_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "MuonMultiplicity");
412  MonitorElement* mNeutralFraction_Reco = iget_.get(rundirJet_reco + "/DiJet/" + "NeutralConstituentsFraction");
413 
414  std::vector<MonitorElement*> me_Jet_Reco;
415  me_Jet_Reco.push_back(mPt_Reco);
416  me_Jet_Reco.push_back(mEta_Reco);
417  me_Jet_Reco.push_back(mPhi_Reco);
418  me_Jet_Reco.push_back(mNjets_Reco);
419  me_Jet_Reco.push_back(mPt_uncor_Reco);
420  me_Jet_Reco.push_back(mEta_uncor_Reco);
421  me_Jet_Reco.push_back(mPhi_uncor_Reco);
422  me_Jet_Reco.push_back(mJetEnergyCorr_Reco);
423  me_Jet_Reco.push_back(mJetEnergyCorrVSeta_Reco);
424  me_Jet_Reco.push_back(mDPhi_Reco);
425  me_Jet_Reco.push_back(mLooseJIDPassFractionVSeta_Reco);
426  me_Jet_Reco.push_back(mPt_Barrel_Reco);
427  me_Jet_Reco.push_back(mPt_EndCap_Reco);
428  me_Jet_Reco.push_back(mPt_Forward_Reco);
429  me_Jet_Reco.push_back(mMVAPUJIDDiscriminant_lowPt_Barrel_Reco);
430  me_Jet_Reco.push_back(mMVAPUJIDDiscriminant_lowPt_EndCap_Reco);
431  me_Jet_Reco.push_back(mMVAPUJIDDiscriminant_lowPt_Forward_Reco);
432  me_Jet_Reco.push_back(mMVAPUJIDDiscriminant_mediumPt_EndCap_Reco);
433  me_Jet_Reco.push_back(mMVAPUJIDDiscriminant_highPt_Barrel_Reco);
434  me_Jet_Reco.push_back(mCHFracVSpT_Barrel_Reco);
435  me_Jet_Reco.push_back(mNHFracVSpT_EndCap_Reco);
436  me_Jet_Reco.push_back(mPhFracVSpT_Barrel_Reco);
437  me_Jet_Reco.push_back(mHFHFracVSpT_Forward_Reco);
438  me_Jet_Reco.push_back(mHFEFracVSpT_Forward_Reco);
439  me_Jet_Reco.push_back(mCHFrac_Reco);
440  me_Jet_Reco.push_back(mNHFrac_Reco);
441  me_Jet_Reco.push_back(mPhFrac_Reco);
442  me_Jet_Reco.push_back(mChargedMultiplicity_Reco);
443  me_Jet_Reco.push_back(mNeutralMultiplicity_Reco);
444  me_Jet_Reco.push_back(mMuonMultiplicity_Reco);
445  me_Jet_Reco.push_back(mNeutralFraction_Reco);
446 
447  MonitorElement* mPt_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Pt");
448  MonitorElement* mEta_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Eta");
449  MonitorElement* mPhi_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Phi");
450  MonitorElement* mNjets_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "NJets");
451  MonitorElement* mPt_uncor_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Pt_uncor");
452  MonitorElement* mEta_uncor_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Eta_uncor");
453  MonitorElement* mPhi_uncor_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Phi_uncor");
454  MonitorElement* mJetEnergyCorr_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "JetEnergyCorr");
455  MonitorElement* mJetEnergyCorrVSeta_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "JetEnergyCorrVSEta");
456  MonitorElement* mDPhi_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "DPhi");
457  MonitorElement* mLooseJIDPassFractionVSeta_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "JetIDPassFractionVSeta");
458  MonitorElement* mPt_Barrel_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Pt_Barrel");
459  MonitorElement* mPt_EndCap_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Pt_EndCap");
460  MonitorElement* mPt_Forward_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "Pt_Forward");
461  MonitorElement* mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD =
462  iget_.get(rundirJet_miniaod + "/" + "MVAPUJIDDiscriminant_lowPt_Barrel");
463  MonitorElement* mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD =
464  iget_.get(rundirJet_miniaod + "/" + "MVAPUJIDDiscriminant_lowPt_EndCap");
465  MonitorElement* mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD =
466  iget_.get(rundirJet_miniaod + "/" + "MVAPUJIDDiscriminant_lowPt_Forward");
467  MonitorElement* mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD =
468  iget_.get(rundirJet_miniaod + "/" + "MVAPUJIDDiscriminant_mediumPt_EndCap");
469  MonitorElement* mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD =
470  iget_.get(rundirJet_miniaod + "/" + "MVAPUJIDDiscriminant_highPt_Barrel");
471  MonitorElement* mCHFracVSpT_Barrel_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "CHFracVSpT_Barrel");
472  MonitorElement* mNHFracVSpT_EndCap_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "NHFracVSpT_EndCap");
473  MonitorElement* mPhFracVSpT_Barrel_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "PhFracVSpT_Barrel");
474  MonitorElement* mHFHFracVSpT_Forward_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "HFHFracVSpT_Forward");
475  MonitorElement* mHFEFracVSpT_Forward_MiniAOD = iget_.get(rundirJet_miniaod + "/" + "HFEFracVSpT_Forward");
476  MonitorElement* mCHFrac_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "CHFrac");
477  MonitorElement* mNHFrac_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "NHFrac");
478  MonitorElement* mPhFrac_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "PhFrac");
479  MonitorElement* mChargedMultiplicity_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "ChargedMultiplicity");
480  MonitorElement* mNeutralMultiplicity_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "NeutralMultiplicity");
481  MonitorElement* mMuonMultiplicity_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "MuonMultiplicity");
482  MonitorElement* mNeutralFraction_MiniAOD = iget_.get(rundirJet_miniaod + "/DiJet/" + "NeutralConstituentsFraction");
483 
484  std::vector<MonitorElement*> me_Jet_MiniAOD;
485  me_Jet_MiniAOD.push_back(mPt_MiniAOD);
486  me_Jet_MiniAOD.push_back(mEta_MiniAOD);
487  me_Jet_MiniAOD.push_back(mPhi_MiniAOD);
488  me_Jet_MiniAOD.push_back(mNjets_MiniAOD);
489  me_Jet_MiniAOD.push_back(mPt_uncor_MiniAOD);
490  me_Jet_MiniAOD.push_back(mEta_uncor_MiniAOD);
491  me_Jet_MiniAOD.push_back(mPhi_uncor_MiniAOD);
492  me_Jet_MiniAOD.push_back(mJetEnergyCorr_MiniAOD);
493  me_Jet_MiniAOD.push_back(mJetEnergyCorrVSeta_MiniAOD);
494  me_Jet_MiniAOD.push_back(mDPhi_MiniAOD);
495  me_Jet_MiniAOD.push_back(mLooseJIDPassFractionVSeta_MiniAOD);
496  me_Jet_MiniAOD.push_back(mPt_Barrel_MiniAOD);
497  me_Jet_MiniAOD.push_back(mPt_EndCap_MiniAOD);
498  me_Jet_MiniAOD.push_back(mPt_Forward_MiniAOD);
499  me_Jet_MiniAOD.push_back(mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD);
500  me_Jet_MiniAOD.push_back(mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD);
501  me_Jet_MiniAOD.push_back(mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD);
502  me_Jet_MiniAOD.push_back(mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD);
503  me_Jet_MiniAOD.push_back(mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD);
504  me_Jet_MiniAOD.push_back(mCHFracVSpT_Barrel_MiniAOD);
505  me_Jet_MiniAOD.push_back(mNHFracVSpT_EndCap_MiniAOD);
506  me_Jet_MiniAOD.push_back(mPhFracVSpT_Barrel_MiniAOD);
507  me_Jet_MiniAOD.push_back(mHFHFracVSpT_Forward_MiniAOD);
508  me_Jet_MiniAOD.push_back(mHFEFracVSpT_Forward_MiniAOD);
509  me_Jet_MiniAOD.push_back(mCHFrac_MiniAOD);
510  me_Jet_MiniAOD.push_back(mNHFrac_MiniAOD);
511  me_Jet_MiniAOD.push_back(mPhFrac_MiniAOD);
512  me_Jet_MiniAOD.push_back(mChargedMultiplicity_MiniAOD);
513  me_Jet_MiniAOD.push_back(mNeutralMultiplicity_MiniAOD);
514  me_Jet_MiniAOD.push_back(mMuonMultiplicity_MiniAOD);
515  me_Jet_MiniAOD.push_back(mNeutralFraction_MiniAOD);
516 
517  ibook_.setCurrentFolder(RunDirJet + "MiniAOD_over_RECO");
518  mPt_MiniAOD_over_Reco = ibook_.book1D("Pt_MiniAOD_over_RECO", (TH1F*)mPt_Reco->getRootObject());
519  mEta_MiniAOD_over_Reco = ibook_.book1D("Eta_MiniAOD_over_RECO", (TH1F*)mEta_Reco->getRootObject());
520  mPhi_MiniAOD_over_Reco = ibook_.book1D("Phi_MiniAOD_over_RECO", (TH1F*)mPhi_Reco->getRootObject());
521  mNjets_MiniAOD_over_Reco = ibook_.book1D("NJets_MiniAOD_over_RECO", (TH1F*)mNjets_Reco->getRootObject());
522  mPt_uncor_MiniAOD_over_Reco = ibook_.book1D("Pt_uncor_MiniAOD_over_RECO", (TH1F*)mPt_uncor_Reco->getRootObject());
523  mEta_uncor_MiniAOD_over_Reco =
524  ibook_.book1D("Eta_uncor_MiniAOD_over_RECO", (TH1F*)mEta_uncor_Reco->getRootObject());
525  mPhi_uncor_MiniAOD_over_Reco =
526  ibook_.book1D("Phi_uncor_MiniAOD_over_RECO", (TH1F*)mPhi_uncor_Reco->getRootObject());
527  mJetEnergyCorr_MiniAOD_over_Reco =
528  ibook_.book1D("JetEnergyCorr_MiniAOD_over_RECO", (TH1F*)mJetEnergyCorr_Reco->getRootObject());
529  mJetEnergyCorrVSeta_MiniAOD_over_Reco = ibook_.book1D(
530  "JetEnergyCorrVSEta_MiniAOD_over_RECO", "jet energy correction factor VS eta", etaBin_, etaMin_, etaMax_);
531  mDPhi_MiniAOD_over_Reco = ibook_.book1D("DPhi_MiniAOD_over_RECO", (TH1F*)mDPhi_Reco->getRootObject());
532  mLooseJIDPassFractionVSeta_MiniAOD_over_Reco =
533  ibook_.book1D("JetIDPassFractionVSeta_MiniAOD_over_RECO", "JetIDPassFractionVSeta", etaBin_, etaMin_, etaMax_);
534  mPt_Barrel_MiniAOD_over_Reco =
535  ibook_.book1D("Pt_Barrel_MiniAOD_over_RECO", (TH1F*)mPt_Barrel_Reco->getRootObject());
536  mPt_EndCap_MiniAOD_over_Reco =
537  ibook_.book1D("Pt_EndCap_MiniAOD_over_RECO", (TH1F*)mPt_EndCap_Reco->getRootObject());
538  mPt_Forward_MiniAOD_over_Reco =
539  ibook_.book1D("Pt_Forward_MiniAOD_over_RECO", (TH1F*)mPt_Forward_Reco->getRootObject());
540  mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco =
541  ibook_.book1D("MVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_RECO",
542  (TH1F*)mMVAPUJIDDiscriminant_lowPt_Barrel_Reco->getRootObject());
543  mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco =
544  ibook_.book1D("MVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_RECO",
545  (TH1F*)mMVAPUJIDDiscriminant_lowPt_EndCap_Reco->getRootObject());
546  mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco =
547  ibook_.book1D("MVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_RECO",
548  (TH1F*)mMVAPUJIDDiscriminant_lowPt_Forward_Reco->getRootObject());
549  mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco =
550  ibook_.book1D("MVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_RECO",
551  (TH1F*)mMVAPUJIDDiscriminant_mediumPt_EndCap_Reco->getRootObject());
552  mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco =
553  ibook_.book1D("MVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_RECO",
554  (TH1F*)mMVAPUJIDDiscriminant_highPt_Barrel_Reco->getRootObject());
555  mCHFracVSpT_Barrel_MiniAOD_over_Reco =
556  ibook_.book1D("CHFracVSpT_Barrel_MiniAOD_over_RECO", "CHFracVSpT_Barrel", ptBin_, ptMin_, ptMax_);
557  mNHFracVSpT_EndCap_MiniAOD_over_Reco =
558  ibook_.book1D("NHFracVSpT_EndCap_MiniAOD_over_RECO", "NHFracVSpT_EndCap", ptBin_, ptMin_, ptMax_);
559  mPhFracVSpT_Barrel_MiniAOD_over_Reco =
560  ibook_.book1D("PhFracVSpT_Barrel_MiniAOD_over_RECO", "PhFracVSpT_Barrel", ptBin_, ptMin_, ptMax_);
561  mHFHFracVSpT_Forward_MiniAOD_over_Reco =
562  ibook_.book1D("HFHFracVSpT_Forward_MiniAOD_over_RECO", "HFHFracVSpT_Forward", ptBin_, ptMin_, ptMax_);
563  mHFEFracVSpT_Forward_MiniAOD_over_Reco =
564  ibook_.book1D("HFEFracVSpT_Forward_MiniAOD_over_RECO", "HFEFracVSpT_Forward", ptBin_, ptMin_, ptMax_);
565  ibook_.setCurrentFolder(RunDirJet + "MiniAOD_over_RECO" + "/" + "DiJet");
566  mCHFrac_MiniAOD_over_Reco = ibook_.book1D("CHFrac_MiniAOD_over_RECO", (TH1F*)mCHFrac_Reco->getRootObject());
567  mNHFrac_MiniAOD_over_Reco = ibook_.book1D("NHFrac_MiniAOD_over_RECO", (TH1F*)mNHFrac_Reco->getRootObject());
568  mPhFrac_MiniAOD_over_Reco = ibook_.book1D("PhFrac_MiniAOD_over_RECO", (TH1F*)mPhFrac_Reco->getRootObject());
569  mChargedMultiplicity_MiniAOD_over_Reco =
570  ibook_.book1D("ChargedMultiplicity_MiniAOD_over_RECO", (TH1F*)mChargedMultiplicity_Reco->getRootObject());
571  mNeutralMultiplicity_MiniAOD_over_Reco =
572  ibook_.book1D("NeutralMultiplicity_MiniAOD_over_RECO", (TH1F*)mNeutralMultiplicity_Reco->getRootObject());
573  mMuonMultiplicity_MiniAOD_over_Reco =
574  ibook_.book1D("MuonMultiplicity_MiniAOD_over_RECO", (TH1F*)mMuonMultiplicity_Reco->getRootObject());
575  mNeutralFraction_MiniAOD_over_Reco =
576  ibook_.book1D("NeutralConstituentsFraction_MiniAOD_over_RECO", (TH1F*)mNeutralFraction_Reco->getRootObject());
577 
578  std::vector<MonitorElement*> me_Jet_MiniAOD_over_Reco;
579  me_Jet_MiniAOD_over_Reco.push_back(mPt_MiniAOD_over_Reco);
580  me_Jet_MiniAOD_over_Reco.push_back(mEta_MiniAOD_over_Reco);
581  me_Jet_MiniAOD_over_Reco.push_back(mPhi_MiniAOD_over_Reco);
582  me_Jet_MiniAOD_over_Reco.push_back(mNjets_MiniAOD_over_Reco);
583  me_Jet_MiniAOD_over_Reco.push_back(mPt_uncor_MiniAOD_over_Reco);
584  me_Jet_MiniAOD_over_Reco.push_back(mEta_uncor_MiniAOD_over_Reco);
585  me_Jet_MiniAOD_over_Reco.push_back(mPhi_uncor_MiniAOD_over_Reco);
586  me_Jet_MiniAOD_over_Reco.push_back(mJetEnergyCorr_MiniAOD_over_Reco);
587  me_Jet_MiniAOD_over_Reco.push_back(mJetEnergyCorrVSeta_MiniAOD_over_Reco);
588  me_Jet_MiniAOD_over_Reco.push_back(mDPhi_MiniAOD_over_Reco);
589  me_Jet_MiniAOD_over_Reco.push_back(mLooseJIDPassFractionVSeta_MiniAOD_over_Reco);
590  me_Jet_MiniAOD_over_Reco.push_back(mPt_Barrel_MiniAOD_over_Reco);
591  me_Jet_MiniAOD_over_Reco.push_back(mPt_EndCap_MiniAOD_over_Reco);
592  me_Jet_MiniAOD_over_Reco.push_back(mPt_Forward_MiniAOD_over_Reco);
593  me_Jet_MiniAOD_over_Reco.push_back(mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco);
594  me_Jet_MiniAOD_over_Reco.push_back(mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco);
595  me_Jet_MiniAOD_over_Reco.push_back(mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco);
596  me_Jet_MiniAOD_over_Reco.push_back(mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco);
597  me_Jet_MiniAOD_over_Reco.push_back(mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco);
598  me_Jet_MiniAOD_over_Reco.push_back(mCHFracVSpT_Barrel_MiniAOD_over_Reco);
599  me_Jet_MiniAOD_over_Reco.push_back(mNHFracVSpT_EndCap_MiniAOD_over_Reco);
600  me_Jet_MiniAOD_over_Reco.push_back(mPhFracVSpT_Barrel_MiniAOD_over_Reco);
601  me_Jet_MiniAOD_over_Reco.push_back(mHFHFracVSpT_Forward_MiniAOD_over_Reco);
602  me_Jet_MiniAOD_over_Reco.push_back(mHFEFracVSpT_Forward_MiniAOD_over_Reco);
603  me_Jet_MiniAOD_over_Reco.push_back(mCHFrac_MiniAOD_over_Reco);
604  me_Jet_MiniAOD_over_Reco.push_back(mNHFrac_MiniAOD_over_Reco);
605  me_Jet_MiniAOD_over_Reco.push_back(mPhFrac_MiniAOD_over_Reco);
606  me_Jet_MiniAOD_over_Reco.push_back(mChargedMultiplicity_MiniAOD_over_Reco);
607  me_Jet_MiniAOD_over_Reco.push_back(mNeutralMultiplicity_MiniAOD_over_Reco);
608  me_Jet_MiniAOD_over_Reco.push_back(mMuonMultiplicity_MiniAOD_over_Reco);
609  me_Jet_MiniAOD_over_Reco.push_back(mNeutralFraction_MiniAOD_over_Reco);
610 
611  for (unsigned int j = 0; j < me_Jet_MiniAOD_over_Reco.size(); j++) {
612  MonitorElement* monJetReco = me_Jet_Reco[j];
613  if (monJetReco && monJetReco->getRootObject()) {
614  MonitorElement* monJetMiniAOD = me_Jet_MiniAOD[j];
615  if (monJetMiniAOD && monJetMiniAOD->getRootObject()) {
616  MonitorElement* monJetMiniAOD_over_RECO = me_Jet_MiniAOD_over_Reco[j];
617  if (monJetMiniAOD_over_RECO && monJetMiniAOD_over_RECO->getRootObject()) {
618  for (int i = 0; i <= (monJetMiniAOD_over_RECO->getNbinsX() + 1); i++) {
619  if (monJetReco->getBinContent(i) != 0) {
620  monJetMiniAOD_over_RECO->setBinContent(i,
621  monJetMiniAOD->getBinContent(i) / monJetReco->getBinContent(i));
622  } else if (monJetMiniAOD->getBinContent(i) != 0) {
623  monJetMiniAOD_over_RECO->setBinContent(i, -0.5);
624  }
625  }
626  }
627  }
628  }
629  }
630  } //check for RECO and MiniAOD directories
631 
632  if (verbose_)
633  std::cout << ">>> EndRun (DataCertificationJetMET) <<<" << std::endl;
634 
635  std::vector<std::string> subDirVec;
636  std::string RunDir;
637 
638  if (verbose_)
639  std::cout << "InMemory_ = " << InMemory_ << std::endl;
640 
641  ibook_.setCurrentFolder(folderName);
642  reportSummary = ibook_.bookFloat("reportSummary");
643  CertificationSummary = ibook_.bookFloat("CertificationSummary");
644 
645  reportSummaryMap = ibook_.book2D("reportSummaryMap", "reportSummaryMap", 3, 0, 3, 5, 0, 5);
646  CertificationSummaryMap = ibook_.book2D("CertificationSummaryMap", "CertificationSummaryMap", 3, 0, 3, 5, 0, 5);
647 
648  reportSummary = iget_.get(folderName + "/" + "reportSummary");
649  CertificationSummary = iget_.get(folderName + "/" + "CertificationSummary");
650  reportSummaryMap = iget_.get(folderName + "/" + "reportSummaryMap");
651  CertificationSummaryMap = iget_.get(folderName + "/" + "CertificationSummaryMap");
652 
653  if (reportSummaryMap && reportSummaryMap->getRootObject()) {
654  reportSummaryMap->getTH2F()->SetStats(kFALSE);
655  reportSummaryMap->setOption("colz");
656  reportSummaryMap->setBinLabel(1, "CaloTower");
657  reportSummaryMap->setBinLabel(2, "MET");
658  reportSummaryMap->setBinLabel(3, "Jet");
659  }
660  if (CertificationSummaryMap && CertificationSummaryMap->getRootObject()) {
661  CertificationSummaryMap->getTH2F()->SetStats(kFALSE);
662  CertificationSummaryMap->setOption("colz");
663  CertificationSummaryMap->setBinLabel(1, "CaloTower");
664  CertificationSummaryMap->setBinLabel(2, "MET");
665  CertificationSummaryMap->setBinLabel(3, "Jet");
666  }
667 
668  reportSummary->Fill(1.);
669  CertificationSummary->Fill(1.);
670 
671  if (RunDir == "Reference")
672  RunDir = "";
673  if (verbose_)
674  std::cout << RunDir << std::endl;
675  ibook_.setCurrentFolder("JetMET/EventInfo/CertificationSummaryContents/");
676 
677  std::string refHistoName;
678  std::string newHistoName;
679 
680  //-----------------------------
681  // Jet DQM Data Certification
682  //-----------------------------
683  //we have 4 types anymore: PF (barrel,endcap,forward) and calojets
684  MonitorElement* meJetPt[4];
685  MonitorElement* meJetEta[4];
686  MonitorElement* meJetPhi[4];
687  MonitorElement* meJetEMFrac[4];
688  MonitorElement* meJetConstituents[4];
689  RunDir = "";
690  if (RunDir.empty())
691  newHistoName = "JetMET/Jet/";
692  else
693  newHistoName = RunDir + "/JetMET/Runsummary/Jet/";
694  std::string cleaningdir = "";
695  cleaningdir = "Cleaned";
696 
697  // Read different histograms for PbPb and pp collisions
698 
699  if (isHI) { // Histograms for heavy ions
700 
701  newHistoName = "JetMET/HIJetValidation/";
702  cleaningdir = "";
703 
704  //Jet Phi histos
705  meJetPhi[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Cs4PFJets/Phi");
706  meJetPhi[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu3PFJets/Phi");
707  meJetPhi[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4PFJets/Phi");
708  meJetPhi[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4CaloJets/Phi");
709 
710  //Jet Eta histos
711  meJetEta[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Cs4PFJets/Eta");
712  meJetEta[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu3PFJets/Eta");
713  meJetEta[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4PFJets/Eta");
714  meJetEta[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4CaloJets/Eta");
715 
716  //Jet Pt histos
717  meJetPt[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Cs4PFJets/Pt");
718  meJetPt[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu3PFJets/Pt");
719  meJetPt[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4PFJets/Pt");
720  meJetPt[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4CaloJets/Pt");
721 
722  //Jet Constituents histos
723  meJetConstituents[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Cs4PFJets/Constituents");
724  meJetConstituents[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu3PFJets/Constituents");
725  meJetConstituents[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4PFJets/Constituents");
726  meJetConstituents[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "Pu4CaloJets/Constituents");
727 
728  //There are no jet EMFrac histograms for HI. Dummy paths will pass the tests by default
729  meJetEMFrac[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "dummy/dummy");
730  meJetEMFrac[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "dummy/dummy");
731  meJetEMFrac[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "dummy/dummy");
732  meJetEMFrac[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "dummy/dummy");
733 
734  } else { // Histograms for protons
735 
736  //Jet Phi histos
737  meJetPhi[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Phi_Barrel");
738  meJetPhi[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Phi_EndCap");
739  meJetPhi[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Phi_Forward");
740  meJetPhi[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "CaloJets/Phi");
741  //meJetPhi[4] = iget_.get(newHistoName+cleaningdir+"JetPlusTrackZSPCorJetAntiKt5/Phi");
742 
743  //Jet Eta histos
744  meJetEta[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Eta");
745  meJetEta[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Eta");
746  meJetEta[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/EtaFirst");
747  meJetEta[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "CaloJets/Eta");
748  //meJetEta[4] = iget_.get(newHistoName+cleaningdir+"JetPlusTrackZSPCorJetAntiKt5/Eta");
749 
750  //Jet Pt histos
751  meJetPt[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Pt_Barrel");
752  meJetPt[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Pt_EndCap");
753  meJetPt[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Pt_Forward");
754  meJetPt[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "CaloJets/Pt_2");
755 
756  //Jet Constituents histos
757  meJetConstituents[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Constituents_Barrel");
758  meJetConstituents[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Constituents_EndCap");
759  meJetConstituents[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/Constituents_Forward");
760  meJetConstituents[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "CaloJets/Constituents");
761 
762  //Jet EMFrac histos
763  meJetEMFrac[0] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/EFrac_Barrel");
764  meJetEMFrac[1] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/EFrac_EndCap");
765  meJetEMFrac[2] = iget_.get(newHistoName + cleaningdir + jetAlgo + "PFJets/EFrac_Forward");
766  meJetEMFrac[3] = iget_.get(newHistoName + cleaningdir + jetAlgo + "CaloJets/EFrac");
767  }
768 
769  //------------------------------------------------------------------------------
770  //--- Extract quality test results and fill data certification results for Jets
771  //--- Tests for Calo Barrel, EndCap and Forward, as well as PF and JPT jets
772  //--- For Calo and PF jets:
773  //--- Look at mean of Constituents, EM Frac and Pt
774  //--- Look at Kolmogorov result for Eta, Phi, and Pt
775  //--- For JPT jets:
776  //--- Look at mean of Pt, AllPionsTrackNHits?, nTracks,
777  //--- Look at Kolmogorov result for Eta, Phi, and Pt
778  //------------------------------------------------------------------------------
779 
780  // Four types of jets {AK5 Barrel, AK5 EndCap, AK5 Forward, PF}, removed JPT which is 5th type of jets
781  //----------------------------------------------------------------------------
782  // Kolmogorov (KS) tests
783  const QReport* QReport_JetEta[4] = {nullptr};
784  const QReport* QReport_JetPhi[4] = {nullptr};
785  // Mean and KS tests for Calo and PF jets
786  const QReport* QReport_JetConstituents[4][2] = {{nullptr}};
787  const QReport* QReport_JetEFrac[4][2] = {{nullptr}};
788  const QReport* QReport_JetPt[4][2] = {{nullptr}};
789 
790  // Mean and KS tests for JPT jets
791  //const QReport* QReport_JetNTracks[2] = {0, 0};
792  float qr_Jet_Eta[4] = {-1};
793  float qr_Jet_Phi[4] = {-1};
794  float dc_Jet[4] = {-1};
795 
796  float qr_Jet_Constituents[4][2] = {{-1}};
797  float qr_Jet_EFrac[4][2] = {{-1}};
798  float qr_Jet_Pt[4][2] = {{-1}};
799 
800  // Loop
801  //----------------------------------------------------------------------------
802  for (int jtyp = 0; jtyp < 4; ++jtyp) {
803  // Mean test results
804 
805  if (meJetConstituents[jtyp] && meJetConstituents[jtyp]->getRootObject()) {
806  QReport_JetConstituents[jtyp][0] = meJetConstituents[jtyp]->getQReport("meanJetConstituentsTest");
807  QReport_JetConstituents[jtyp][1] = meJetConstituents[jtyp]->getQReport("KolmogorovTest");
808  }
809  if (meJetEMFrac[jtyp] && meJetEMFrac[jtyp]->getRootObject()) {
810  QReport_JetEFrac[jtyp][0] = meJetEMFrac[jtyp]->getQReport("meanEMFractionTest");
811  QReport_JetEFrac[jtyp][1] = meJetEMFrac[jtyp]->getQReport("KolmogorovTest");
812  }
813  if (meJetPt[jtyp] && meJetPt[jtyp]->getRootObject()) {
814  QReport_JetPt[jtyp][0] = meJetPt[jtyp]->getQReport("meanJetPtTest");
815  QReport_JetPt[jtyp][1] = meJetPt[jtyp]->getQReport("KolmogorovTest");
816  }
817  if (meJetPhi[jtyp] && meJetPhi[jtyp]->getRootObject()) {
818  QReport_JetPhi[jtyp] = meJetPhi[jtyp]->getQReport("KolmogorovTest");
819  }
820  if (meJetEta[jtyp] && meJetEta[jtyp]->getRootObject()) {
821  QReport_JetEta[jtyp] = meJetEta[jtyp]->getQReport("KolmogorovTest");
822  }
823 
824  //Jet Pt test
825  if (QReport_JetPt[jtyp][0]) {
826  //std::cout<<"jet type test pt "<<jtyp<<"/"<<QReport_JetPt[jtyp][0]->getStatus()<<std::endl;
827  if (QReport_JetPt[jtyp][0]->getStatus() == 100 || QReport_JetPt[jtyp][0]->getStatus() == 200)
828  qr_Jet_Pt[jtyp][0] = 1;
829  else if (QReport_JetPt[jtyp][0]->getStatus() == 300)
830  qr_Jet_Pt[jtyp][0] = 0;
831  else
832  qr_Jet_Pt[jtyp][0] = -1;
833  } else {
834  qr_Jet_Pt[jtyp][0] = -2;
835  //std::cout<<"qreport is REALLY NULL type test pt "<<jtyp<<" 0 "<<std::endl;
836  }
837  if (QReport_JetPt[jtyp][1]) {
838  if (QReport_JetPt[jtyp][1]->getStatus() == 100 || QReport_JetPt[jtyp][1]->getStatus() == 200)
839  qr_Jet_Pt[jtyp][1] = 1;
840  else if (QReport_JetPt[jtyp][1]->getStatus() == 300)
841  qr_Jet_Pt[jtyp][1] = 0;
842  else
843  qr_Jet_Pt[jtyp][1] = -1;
844  } else {
845  qr_Jet_Pt[jtyp][1] = -2;
846  }
847 
848  //Jet Phi test
849  if (QReport_JetPhi[jtyp]) {
850  if (QReport_JetPhi[jtyp]->getStatus() == 100 || QReport_JetPhi[jtyp]->getStatus() == 200)
851  qr_Jet_Phi[jtyp] = 1;
852  else if (QReport_JetPhi[jtyp]->getStatus() == 300)
853  qr_Jet_Phi[jtyp] = 0;
854  else
855  qr_Jet_Phi[jtyp] = -1;
856  } else {
857  qr_Jet_Phi[jtyp] = -2;
858  }
859  //Jet Eta test
860  if (QReport_JetEta[jtyp]) {
861  if (QReport_JetEta[jtyp]->getStatus() == 100 || QReport_JetEta[jtyp]->getStatus() == 200)
862  qr_Jet_Eta[jtyp] = 1;
863  else if (QReport_JetEta[jtyp]->getStatus() == 300)
864  qr_Jet_Eta[jtyp] = 0;
865  else
866  qr_Jet_Eta[jtyp] = -1;
867  } else {
868  qr_Jet_Eta[jtyp] = -2;
869  }
870  //Jet Constituents test
871  if (QReport_JetConstituents[jtyp][0]) {
872  if (QReport_JetConstituents[jtyp][0]->getStatus() == 100 || QReport_JetConstituents[jtyp][0]->getStatus() == 200)
873  qr_Jet_Constituents[jtyp][0] = 1;
874  else if (QReport_JetConstituents[jtyp][0]->getStatus() == 300)
875  qr_Jet_Constituents[jtyp][0] = 0;
876  else
877  qr_Jet_Constituents[jtyp][0] = -1;
878  } else {
879  qr_Jet_Constituents[jtyp][0] = -2;
880  }
881 
882  if (QReport_JetConstituents[jtyp][1]) {
883  if (QReport_JetConstituents[jtyp][1]->getStatus() == 100 || QReport_JetConstituents[jtyp][1]->getStatus() == 200)
884  qr_Jet_Constituents[jtyp][1] = 1;
885  else if (QReport_JetConstituents[jtyp][1]->getStatus() == 300)
886  qr_Jet_Constituents[jtyp][1] = 0;
887  else
888  qr_Jet_Constituents[jtyp][1] = -1;
889  } else {
890  qr_Jet_Constituents[jtyp][1] = -2;
891  }
892  //Jet EMFrac test
893  if (QReport_JetEFrac[jtyp][0]) {
894  if (QReport_JetEFrac[jtyp][0]->getStatus() == 100 || QReport_JetEFrac[jtyp][0]->getStatus() == 200)
895  qr_Jet_EFrac[jtyp][0] = 1;
896  else if (QReport_JetEFrac[jtyp][0]->getStatus() == 300)
897  qr_Jet_EFrac[jtyp][0] = 0;
898  else
899  qr_Jet_EFrac[jtyp][0] = -1;
900  } else {
901  qr_Jet_EFrac[jtyp][0] = -2;
902  }
903 
904  if (QReport_JetEFrac[jtyp][1]) {
905  if (QReport_JetEFrac[jtyp][1]->getStatus() == 100 || QReport_JetEFrac[jtyp][1]->getStatus() == 200)
906  qr_Jet_EFrac[jtyp][1] = 1;
907  else if (QReport_JetEFrac[jtyp][1]->getStatus() == 300)
908  qr_Jet_EFrac[jtyp][1] = 0;
909  else
910  qr_Jet_EFrac[jtyp][1] = -1;
911  } else {
912  qr_Jet_EFrac[jtyp][1] = -2;
913  }
914 
915  if (verbose_) {
916  printf("====================Jet Type %d QTest Report Summary========================\n", jtyp);
917  printf("Eta: Phi: Pt 1: 2: Const/Ntracks 1: 2: EFrac/tracknhits 1: 2:\n");
918 
919  printf("%2.2f %2.2f %2.2f %2.2f %2.2f %2.2f %2.2f %2.2f\n",
920  qr_Jet_Eta[jtyp],
921  qr_Jet_Phi[jtyp],
922  qr_Jet_Pt[jtyp][0],
923  qr_Jet_Pt[jtyp][1],
924  qr_Jet_Constituents[jtyp][0],
925  qr_Jet_Constituents[jtyp][1],
926  qr_Jet_EFrac[jtyp][0],
927  qr_Jet_EFrac[jtyp][1]);
928  }
929  //certification result for Jet
930 
931  //Only apply certain tests, as defined in the config
932  for (int ttyp = 0; ttyp < 2; ++ttyp) {
933  if (!jetTests[jtyp][ttyp]) {
934  qr_Jet_Pt[jtyp][ttyp] = 1;
935  if (ttyp == 1) {
936  qr_Jet_Eta[jtyp] = 1;
937  qr_Jet_Phi[jtyp] = 1;
938  }
939  qr_Jet_EFrac[jtyp][ttyp] = 1;
940  qr_Jet_Constituents[jtyp][ttyp] = 1;
941  }
942  }
943 
944  if ((qr_Jet_EFrac[jtyp][0] == 0) || (qr_Jet_EFrac[jtyp][1] == 0) || (qr_Jet_Constituents[jtyp][1] == 0) ||
945  (qr_Jet_Constituents[jtyp][0] == 0) || (qr_Jet_Eta[jtyp] == 0) || (qr_Jet_Phi[jtyp] == 0) ||
946  (qr_Jet_Pt[jtyp][0] == 0) || (qr_Jet_Pt[jtyp][1] == 0))
947  dc_Jet[jtyp] = 0;
948  else if ((qr_Jet_EFrac[jtyp][0] == -1) && (qr_Jet_EFrac[jtyp][1] == -1) && (qr_Jet_Constituents[jtyp][1] == -1) &&
949  (qr_Jet_Constituents[jtyp][0] == -1) && (qr_Jet_Eta[jtyp] == -1) && (qr_Jet_Phi[jtyp] == -1) &&
950  (qr_Jet_Pt[jtyp][0] == -1) && (qr_Jet_Pt[jtyp][1] == -1))
951  dc_Jet[jtyp] = -1;
952  else if ((qr_Jet_EFrac[jtyp][0] == -2) && (qr_Jet_EFrac[jtyp][1] == -2) && (qr_Jet_Constituents[jtyp][1] == -2) &&
953  (qr_Jet_Constituents[jtyp][0] == -2) && (qr_Jet_Eta[jtyp] == -2) && (qr_Jet_Phi[jtyp] == -2) &&
954  (qr_Jet_Pt[jtyp][0] == -2) && (qr_Jet_Pt[jtyp][1] == -2))
955  dc_Jet[jtyp] = -2;
956  else
957  dc_Jet[jtyp] = 1;
958 
959  if (verbose_)
960  std::cout << "Certifying Jet algo: " << jtyp << " with value: " << dc_Jet[jtyp] << std::endl;
961 
962  CertificationSummaryMap->Fill(2, 4 - jtyp, dc_Jet[jtyp]);
963  reportSummaryMap->Fill(2, 4 - jtyp, dc_Jet[jtyp]);
964  }
965 
966  // There is nothing on the first row for HI, so mark the unfilled
967  if (isHI) {
968  CertificationSummaryMap->Fill(2, 0, -2);
969  reportSummaryMap->Fill(2, 0, -2);
970  }
971 
972  //-----------------------------
973  // MET DQM Data Certification
974  //-----------------------------
975  //
976  // Prepare test histograms
977  //
978  MonitorElement* meMExy[2][2];
979  MonitorElement* meMEt[2];
980  MonitorElement* meSumEt[2];
981  MonitorElement* meMETPhi[2];
982 
983  RunDir = "";
984  if (RunDir.empty())
985  newHistoName = "JetMET/MET/";
986  else
987  newHistoName = RunDir + "/JetMET/Runsummary/MET/";
988 
989  metFolder = "Cleaned";
990 
991  //MEx/MEy monitor elements
992  meMExy[0][0] = iget_.get(newHistoName + "met/" + metFolder + "/MEx");
993  meMExy[0][1] = iget_.get(newHistoName + "met/" + metFolder + "/MEy");
994  meMExy[1][0] = iget_.get(newHistoName + "pfMet/" + metFolder + "/MEx");
995  meMExy[1][1] = iget_.get(newHistoName + "pfMet/" + metFolder + "/MEy");
996 
997  //MET Phi monitor elements
998  meMETPhi[0] = iget_.get(newHistoName + "met/" + metFolder + "/METPhi");
999  meMETPhi[1] = iget_.get(newHistoName + "pfMet/" + metFolder + "/METPhi");
1000  //MET monitor elements
1001  meMEt[0] = iget_.get(newHistoName + "met/" + metFolder + "/MET");
1002  meMEt[1] = iget_.get(newHistoName + "pfMet/" + metFolder + "/MET");
1003  //SumET monitor elements
1004  meSumEt[0] = iget_.get(newHistoName + "met/" + metFolder + "/SumET");
1005  meSumEt[1] = iget_.get(newHistoName + "pfMet/" + metFolder + "/SumET");
1006 
1007  //----------------------------------------------------------------------------
1008  //--- Extract quality test results and fill data certification results for MET
1009  //----------------------------------------------------------------------------
1010 
1011  // 2 types of MET {CaloMET, PfMET} // It is 5 if CaloMETNoHF is included, 4 for MuonCorMET
1012  // removed 3rd type of TcMET
1013  // 2 types of tests Mean test/Kolmogorov test
1014  const QReport* QReport_MExy[2][2][2] = {{{nullptr}}};
1015  const QReport* QReport_MEt[2][2] = {{nullptr}};
1016  const QReport* QReport_SumEt[2][2] = {{nullptr}};
1017  //2 types of tests phiQTest and Kolmogorov test
1018  const QReport* QReport_METPhi[2][2] = {{nullptr}};
1019 
1020  float qr_MET_MExy[2][2][2] = {{{-999.}}};
1021  float qr_MET_MEt[2][2] = {{-999.}};
1022  float qr_MET_SumEt[2][2] = {{-999.}};
1023  float qr_MET_METPhi[2][2] = {{-999.}};
1024  float dc_MET[2] = {-999.};
1025 
1026  // J.Piedra, 27/02/212
1027  // removed MuCorrMET & TcMET --> loop up to 2 instead of 4, remove already from definition
1028  for (int mtyp = 0; mtyp < 2; ++mtyp) {
1029  //Mean test results
1030  if (meMExy[mtyp][0] && meMExy[mtyp][0]->getRootObject()) {
1031  QReport_MExy[mtyp][0][0] = meMExy[mtyp][0]->getQReport("meanMExyTest");
1032  QReport_MExy[mtyp][1][0] = meMExy[mtyp][0]->getQReport("KolmogorovTest");
1033  }
1034  if (meMExy[mtyp][1] && meMExy[mtyp][1]->getRootObject()) {
1035  QReport_MExy[mtyp][0][1] = meMExy[mtyp][1]->getQReport("meanMExyTest");
1036  QReport_MExy[mtyp][1][1] = meMExy[mtyp][1]->getQReport("KolmogorovTest");
1037  }
1038  if (meMEt[mtyp] && meMEt[mtyp]->getRootObject()) {
1039  QReport_MEt[mtyp][0] = meMEt[mtyp]->getQReport("meanMETTest");
1040  QReport_MEt[mtyp][1] = meMEt[mtyp]->getQReport("KolmogorovTest");
1041  }
1042 
1043  if (meSumEt[mtyp] && meSumEt[mtyp]->getRootObject()) {
1044  QReport_SumEt[mtyp][0] = meSumEt[mtyp]->getQReport("meanSumETTest");
1045  QReport_SumEt[mtyp][1] = meSumEt[mtyp]->getQReport("KolmogorovTest");
1046  }
1047 
1048  if (meMETPhi[mtyp] && meMETPhi[mtyp]->getRootObject()) {
1049  QReport_METPhi[mtyp][0] = meMETPhi[mtyp]->getQReport("phiQTest");
1050  QReport_METPhi[mtyp][1] = meMETPhi[mtyp]->getQReport("KolmogorovTest");
1051  }
1052  for (int testtyp = 0; testtyp < 2; ++testtyp) {
1053  //MEx test
1054  if (QReport_MExy[mtyp][testtyp][0]) {
1055  if (QReport_MExy[mtyp][testtyp][0]->getStatus() == 100 || QReport_MExy[mtyp][testtyp][0]->getStatus() == 200)
1056  qr_MET_MExy[mtyp][testtyp][0] = 1;
1057  else if (QReport_MExy[mtyp][testtyp][0]->getStatus() == 300)
1058  qr_MET_MExy[mtyp][testtyp][0] = 0;
1059  else
1060  qr_MET_MExy[mtyp][testtyp][0] = -1;
1061  } else
1062  qr_MET_MExy[mtyp][testtyp][0] = -2;
1063  //MEy test
1064  if (QReport_MExy[mtyp][testtyp][1]) {
1065  if (QReport_MExy[mtyp][testtyp][1]->getStatus() == 100 || QReport_MExy[mtyp][testtyp][1]->getStatus() == 200)
1066  qr_MET_MExy[mtyp][testtyp][1] = 1;
1067  else if (QReport_MExy[mtyp][testtyp][1]->getStatus() == 300)
1068  qr_MET_MExy[mtyp][testtyp][1] = 0;
1069  else
1070  qr_MET_MExy[mtyp][testtyp][1] = -1;
1071  } else
1072  qr_MET_MExy[mtyp][testtyp][1] = -2;
1073 
1074  //MEt test
1075  if (QReport_MEt[mtyp][testtyp]) {
1076  if (QReport_MEt[mtyp][testtyp]->getStatus() == 100 || QReport_MEt[mtyp][testtyp]->getStatus() == 200)
1077  qr_MET_MEt[mtyp][testtyp] = 1;
1078  else if (QReport_MEt[mtyp][testtyp]->getStatus() == 300)
1079  qr_MET_MEt[mtyp][testtyp] = 0;
1080  else
1081  qr_MET_MEt[mtyp][testtyp] = -1;
1082  } else {
1083  qr_MET_MEt[mtyp][testtyp] = -2;
1084  }
1085  //SumEt test
1086  if (QReport_SumEt[mtyp][testtyp]) {
1087  if (QReport_SumEt[mtyp][testtyp]->getStatus() == 100 || QReport_SumEt[mtyp][testtyp]->getStatus() == 200)
1088  qr_MET_SumEt[mtyp][testtyp] = 1;
1089  else if (QReport_SumEt[mtyp][testtyp]->getStatus() == 300)
1090  qr_MET_SumEt[mtyp][testtyp] = 0;
1091  else
1092  qr_MET_SumEt[mtyp][testtyp] = -1;
1093  } else {
1094  qr_MET_SumEt[mtyp][testtyp] = -2;
1095  }
1096  //METPhi test
1097  if (QReport_METPhi[mtyp][testtyp]) {
1098  if (QReport_METPhi[mtyp][testtyp]->getStatus() == 100 || QReport_METPhi[mtyp][testtyp]->getStatus() == 200)
1099  qr_MET_METPhi[mtyp][testtyp] = 1;
1100  else if (QReport_METPhi[mtyp][testtyp]->getStatus() == 300)
1101  qr_MET_METPhi[mtyp][testtyp] = 0;
1102  else
1103  qr_MET_METPhi[mtyp][testtyp] = -1;
1104  } else {
1105  qr_MET_METPhi[mtyp][testtyp] = -2;
1106  }
1107  }
1108 
1109  if (verbose_) {
1110  //certification result for MET
1111  printf("====================MET Type %d QTest Report Summary========================\n", mtyp);
1112  printf("MEx test MEy test MEt test: SumEt test: METPhi test:\n");
1113  for (int tt = 0; tt < 2; ++tt) {
1114  printf("%2.2f %2.2f %2.2f %2.2f %2.2f\n",
1115  qr_MET_MExy[mtyp][tt][0],
1116  qr_MET_MExy[mtyp][tt][1],
1117  qr_MET_MEt[mtyp][tt],
1118  qr_MET_SumEt[mtyp][tt],
1119  qr_MET_METPhi[mtyp][tt]);
1120  }
1121  printf("===========================================================================\n");
1122  }
1123 
1124  //Only apply certain tests, as defined in the config
1125  for (int ttyp = 0; ttyp < 2; ++ttyp) {
1126  if (!metTests[mtyp][ttyp]) {
1127  qr_MET_MExy[mtyp][ttyp][0] = 1;
1128  qr_MET_MExy[mtyp][ttyp][1] = 1;
1129  qr_MET_MEt[mtyp][ttyp] = 1;
1130  qr_MET_SumEt[mtyp][ttyp] = 1;
1131  qr_MET_METPhi[mtyp][ttyp] = 1;
1132  }
1133  }
1134 
1135  if ((qr_MET_MExy[mtyp][0][0] == 0) || (qr_MET_MExy[mtyp][0][1] == 0) || (qr_MET_MEt[mtyp][0] == 0) ||
1136  (qr_MET_SumEt[mtyp][0] == 0) || (qr_MET_METPhi[mtyp][0] == 0) || (qr_MET_MExy[mtyp][1][0] == 0) ||
1137  (qr_MET_MExy[mtyp][1][1] == 0) || (qr_MET_MEt[mtyp][1] == 0) || (qr_MET_SumEt[mtyp][1] == 0) ||
1138  (qr_MET_METPhi[mtyp][1] == 0))
1139  dc_MET[mtyp] = 0;
1140  else if ((qr_MET_MExy[mtyp][0][0] == -1) && (qr_MET_MExy[mtyp][0][1] == -1) && (qr_MET_MEt[mtyp][0] == -1) &&
1141  (qr_MET_SumEt[mtyp][0] == -1) && (qr_MET_METPhi[mtyp][0] == -1) && (qr_MET_MExy[mtyp][1][0] == -1) &&
1142  (qr_MET_MExy[mtyp][1][1] == -1) && (qr_MET_MEt[mtyp][1] == -1) && (qr_MET_SumEt[mtyp][1] == -1) &&
1143  (qr_MET_METPhi[mtyp][1] == -1))
1144  dc_MET[mtyp] = -1;
1145  else if ((qr_MET_MExy[mtyp][0][0] == -2) && (qr_MET_MExy[mtyp][0][1] == -2) && (qr_MET_MEt[mtyp][0] == -2) &&
1146  (qr_MET_SumEt[mtyp][0] == -2) && (qr_MET_METPhi[mtyp][0] == -2) && (qr_MET_MExy[mtyp][1][0] == -2) &&
1147  (qr_MET_MExy[mtyp][1][1] == -2) && (qr_MET_MEt[mtyp][1] == -2) && (qr_MET_SumEt[mtyp][1] == -2) &&
1148  (qr_MET_METPhi[mtyp][1] == -2))
1149  dc_MET[mtyp] = -2;
1150  else
1151  dc_MET[mtyp] = 1;
1152 
1153  if (verbose_)
1154  std::cout << "Certifying MET algo: " << mtyp << " with value: " << dc_MET[mtyp] << std::endl;
1155  CertificationSummaryMap->Fill(1, 4 - mtyp, dc_MET[mtyp]);
1156  reportSummaryMap->Fill(1, 4 - mtyp, dc_MET[mtyp]);
1157  }
1158 
1159  // There is nothing on the first three rows for HI, so mark them unfilled
1160  if (isHI) {
1161  for (int i = 0; i < 3; i++) {
1162  CertificationSummaryMap->Fill(1, i, -2);
1163  reportSummaryMap->Fill(1, i, -2);
1164  }
1165  }
1166 
1167  //----------------------------------------------------------------------------
1168  //--- Extract quality test results and fill data certification results for MET
1169  //----------------------------------------------------------------------------
1170  // Commenting out unused but initialized variables. [Suchandra Dutta]
1171  float dc_CT[3] = {-2.};
1172  dc_CT[0] = -2.;
1173  dc_CT[1] = -2.;
1174  dc_CT[2] = -2.;
1175 
1176  for (int cttyp = 0; cttyp < 3; ++cttyp) {
1177  if (verbose_)
1178  std::cout << "Certifying CaloTowers with value: " << dc_CT[cttyp] << std::endl;
1179  CertificationSummaryMap->Fill(0, 4 - cttyp, dc_CT[cttyp]);
1180  reportSummaryMap->Fill(0, 4 - cttyp, dc_CT[cttyp]);
1181  }
1182  ibook_.setCurrentFolder("");
1183 }

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookFloat(), CertificationSummary, CertificationSummaryMap, gather_cfg::cout, etaBin_, etaMax_, etaMin_, dqm::impl::MonitorElement::Fill(), folderName, dqm::implementation::IGetter::get(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getNbinsX(), dqm::impl::MonitorElement::getQReport(), dqm::legacy::MonitorElement::getRootObject(), dqm::implementation::IGetter::getSubdirs(), dqm::legacy::MonitorElement::getTH2F(), mps_fire::i, InMemory_, inputJetLabelMiniAOD_, inputJetLabelRECO_, inputMETLabelMiniAOD_, inputMETLabelRECO_, inputMETLabelRECOUncleaned_, createfilelist::int, isHI, dqmiolumiharvest::j, jetAlgo, jetTests, edm::InputTag::label(), mChargedHadronEtFraction_MiniAOD_over_Reco, mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco, mChargedMultiplicity_MiniAOD_over_Reco, mCHFrac_MiniAOD_over_Reco, mCHFracVSpT_Barrel_MiniAOD_over_Reco, mDPhi_MiniAOD_over_Reco, mEta_MiniAOD_over_Reco, mEta_uncor_MiniAOD_over_Reco, metFolder, metTests, mHFEFracVSpT_Forward_MiniAOD_over_Reco, mHFEMEtFraction_MiniAOD_over_Reco, mHFHadronEtFraction_MiniAOD_over_Reco, mHFHFracVSpT_Forward_MiniAOD_over_Reco, mJetEnergyCorr_MiniAOD_over_Reco, mJetEnergyCorrVSeta_MiniAOD_over_Reco, mLooseJIDPassFractionVSeta_MiniAOD_over_Reco, mMET_EffCSCTightHalo2015Filter, mMET_EffCSCTightHaloFilter, mMET_EffEcalDeadCellBoundaryFilter, mMET_EffEcalDeadCellTriggerFilter, mMET_EffeeBadScFilter, mMET_EffHBHEIsoNoiseFilter, mMET_EffHBHENoiseFilter, mMET_EffHcalStripHaloFilter, mMET_logx_MiniAOD_over_Reco, mMET_MiniAOD_over_Reco, mMET_nVtx_profile_MiniAOD_over_Reco, mMETPhi_MiniAOD_over_Reco, mMEy_MiniAOD_over_Reco, mMuonMultiplicity_MiniAOD_over_Reco, mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco, mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco, mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco, mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco, mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco, mNeutralFraction_MiniAOD_over_Reco, mNeutralHadronEtFraction_MiniAOD_over_Reco, mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco, mNeutralMultiplicity_MiniAOD_over_Reco, mNHFrac_MiniAOD_over_Reco, mNHFracVSpT_EndCap_MiniAOD_over_Reco, mNjets_MiniAOD_over_Reco, mPhFrac_MiniAOD_over_Reco, mPhFracVSpT_Barrel_MiniAOD_over_Reco, mPhi_MiniAOD_over_Reco, mPhi_uncor_MiniAOD_over_Reco, mPhotonEtFraction_MiniAOD_over_Reco, mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco, mPt_Barrel_MiniAOD_over_Reco, mPt_EndCap_MiniAOD_over_Reco, mPt_Forward_MiniAOD_over_Reco, mPt_MiniAOD_over_Reco, mPt_uncor_MiniAOD_over_Reco, mSumET_logx_MiniAOD_over_Reco, mSumET_MiniAOD_over_Reco, mSumET_nVtx_profile_MiniAOD_over_Reco, nbinsPV_, nPVMax_, nPVMin_, ptBin_, ptMax_, ptMin_, reportSummary, reportSummaryMap, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), dqm::impl::MonitorElement::setOption(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::tt, and verbose_.

Member Data Documentation

◆ caloJetKSTest

bool DataCertificationJetMET::caloJetKSTest
private

Definition at line 72 of file DataCertificationJetMET.h.

◆ caloJetMeanTest

bool DataCertificationJetMET::caloJetMeanTest
private

Definition at line 71 of file DataCertificationJetMET.h.

◆ caloMETKSTest

bool DataCertificationJetMET::caloMETKSTest
private

Definition at line 78 of file DataCertificationJetMET.h.

◆ caloMETMeanTest

bool DataCertificationJetMET::caloMETMeanTest
private

Definition at line 77 of file DataCertificationJetMET.h.

◆ CertificationSummary

MonitorElement* DataCertificationJetMET::CertificationSummary
private

Definition at line 37 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ CertificationSummaryMap

MonitorElement* DataCertificationJetMET::CertificationSummaryMap
private

Definition at line 39 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ conf_

edm::ParameterSet DataCertificationJetMET::conf_
private

Definition at line 43 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET().

◆ etaBin_

int DataCertificationJetMET::etaBin_
private

Definition at line 61 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ etaMax_

double DataCertificationJetMET::etaMax_
private

Definition at line 63 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ etaMin_

double DataCertificationJetMET::etaMin_
private

Definition at line 62 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ folderName

std::string DataCertificationJetMET::folderName
private

Definition at line 69 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ fs_

edm::Service<TFileService> DataCertificationJetMET::fs_
private

Definition at line 44 of file DataCertificationJetMET.h.

◆ InMemory_

bool DataCertificationJetMET::InMemory_
private

Definition at line 46 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ inputJetLabelMiniAOD_

edm::InputTag DataCertificationJetMET::inputJetLabelMiniAOD_
private

Definition at line 55 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ inputJetLabelRECO_

edm::InputTag DataCertificationJetMET::inputJetLabelRECO_
private

Definition at line 54 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ inputMETLabelMiniAOD_

edm::InputTag DataCertificationJetMET::inputMETLabelMiniAOD_
private

Definition at line 53 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ inputMETLabelRECO_

edm::InputTag DataCertificationJetMET::inputMETLabelRECO_
private

Definition at line 51 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ inputMETLabelRECOUncleaned_

edm::InputTag DataCertificationJetMET::inputMETLabelRECOUncleaned_
private

Definition at line 52 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ isData

bool DataCertificationJetMET::isData
private

Definition at line 47 of file DataCertificationJetMET.h.

◆ isHI

bool DataCertificationJetMET::isHI
private

Definition at line 87 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ jetAlgo

std::string DataCertificationJetMET::jetAlgo
private

Definition at line 49 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ jetTests

bool DataCertificationJetMET::jetTests[5][2]
private

Definition at line 84 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ jptJetKSTest

bool DataCertificationJetMET::jptJetKSTest
private

Definition at line 76 of file DataCertificationJetMET.h.

◆ jptJetMeanTest

bool DataCertificationJetMET::jptJetMeanTest
private

Definition at line 75 of file DataCertificationJetMET.h.

◆ mChargedHadronEtFraction_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mChargedHadronEtFraction_MiniAOD_over_Reco
private

Definition at line 106 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
private

Definition at line 113 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mChargedMultiplicity_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mChargedMultiplicity_MiniAOD_over_Reco
private

Definition at line 145 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mCHFrac_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mCHFrac_MiniAOD_over_Reco
private

Definition at line 142 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mCHFracVSpT_Barrel_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mCHFracVSpT_Barrel_MiniAOD_over_Reco
private

Definition at line 137 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mDPhi_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mDPhi_MiniAOD_over_Reco
private

Definition at line 127 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mEta_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mEta_MiniAOD_over_Reco
private

Definition at line 119 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mEta_uncor_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mEta_uncor_MiniAOD_over_Reco
private

Definition at line 123 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ metFolder

std::string DataCertificationJetMET::metFolder
private

Definition at line 48 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ metTests

bool DataCertificationJetMET::metTests[5][2]
private

Definition at line 85 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ mHFEFracVSpT_Forward_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mHFEFracVSpT_Forward_MiniAOD_over_Reco
private

Definition at line 141 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mHFEMEtFraction_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mHFEMEtFraction_MiniAOD_over_Reco
private

Definition at line 110 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mHFHadronEtFraction_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mHFHadronEtFraction_MiniAOD_over_Reco
private

Definition at line 109 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mHFHFracVSpT_Forward_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mHFHFracVSpT_Forward_MiniAOD_over_Reco
private

Definition at line 140 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mJetEnergyCorr_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mJetEnergyCorr_MiniAOD_over_Reco
private

Definition at line 125 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mJetEnergyCorrVSeta_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mJetEnergyCorrVSeta_MiniAOD_over_Reco
private

Definition at line 126 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mLooseJIDPassFractionVSeta_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mLooseJIDPassFractionVSeta_MiniAOD_over_Reco
private

Definition at line 128 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffCSCTightHalo2015Filter

MonitorElement* DataCertificationJetMET::mMET_EffCSCTightHalo2015Filter
private

Definition at line 96 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffCSCTightHaloFilter

MonitorElement* DataCertificationJetMET::mMET_EffCSCTightHaloFilter
private

Definition at line 91 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffEcalDeadCellBoundaryFilter

MonitorElement* DataCertificationJetMET::mMET_EffEcalDeadCellBoundaryFilter
private

Definition at line 94 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffEcalDeadCellTriggerFilter

MonitorElement* DataCertificationJetMET::mMET_EffEcalDeadCellTriggerFilter
private

Definition at line 93 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffeeBadScFilter

MonitorElement* DataCertificationJetMET::mMET_EffeeBadScFilter
private

Definition at line 92 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffHBHEIsoNoiseFilter

MonitorElement* DataCertificationJetMET::mMET_EffHBHEIsoNoiseFilter
private

Definition at line 95 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffHBHENoiseFilter

MonitorElement* DataCertificationJetMET::mMET_EffHBHENoiseFilter
private

Definition at line 90 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_EffHcalStripHaloFilter

MonitorElement* DataCertificationJetMET::mMET_EffHcalStripHaloFilter
private

Definition at line 97 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_logx_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMET_logx_MiniAOD_over_Reco
private

Definition at line 104 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMET_MiniAOD_over_Reco
private

Definition at line 100 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMET_nVtx_profile_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMET_nVtx_profile_MiniAOD_over_Reco
private

Definition at line 111 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMETPhi_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMETPhi_MiniAOD_over_Reco
private

Definition at line 103 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMEy_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMEy_MiniAOD_over_Reco
private

Definition at line 101 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMuonMultiplicity_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMuonMultiplicity_MiniAOD_over_Reco
private

Definition at line 147 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco
private

Definition at line 136 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco
private

Definition at line 132 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco
private

Definition at line 133 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco
private

Definition at line 134 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco
private

Definition at line 135 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNeutralFraction_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNeutralFraction_MiniAOD_over_Reco
private

Definition at line 148 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNeutralHadronEtFraction_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNeutralHadronEtFraction_MiniAOD_over_Reco
private

Definition at line 107 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
private

Definition at line 114 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNeutralMultiplicity_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNeutralMultiplicity_MiniAOD_over_Reco
private

Definition at line 146 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNHFrac_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNHFrac_MiniAOD_over_Reco
private

Definition at line 143 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNHFracVSpT_EndCap_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNHFracVSpT_EndCap_MiniAOD_over_Reco
private

Definition at line 138 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mNjets_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mNjets_MiniAOD_over_Reco
private

Definition at line 121 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPhFrac_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPhFrac_MiniAOD_over_Reco
private

Definition at line 144 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPhFracVSpT_Barrel_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPhFracVSpT_Barrel_MiniAOD_over_Reco
private

Definition at line 139 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPhi_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPhi_MiniAOD_over_Reco
private

Definition at line 120 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPhi_uncor_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPhi_uncor_MiniAOD_over_Reco
private

Definition at line 124 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPhotonEtFraction_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPhotonEtFraction_MiniAOD_over_Reco
private

Definition at line 108 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco
private

Definition at line 115 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPt_Barrel_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPt_Barrel_MiniAOD_over_Reco
private

Definition at line 129 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPt_EndCap_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPt_EndCap_MiniAOD_over_Reco
private

Definition at line 130 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPt_Forward_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPt_Forward_MiniAOD_over_Reco
private

Definition at line 131 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPt_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPt_MiniAOD_over_Reco
private

Definition at line 118 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mPt_uncor_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mPt_uncor_MiniAOD_over_Reco
private

Definition at line 122 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mSumET_logx_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mSumET_logx_MiniAOD_over_Reco
private

Definition at line 105 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mSumET_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mSumET_MiniAOD_over_Reco
private

Definition at line 102 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ mSumET_nVtx_profile_MiniAOD_over_Reco

MonitorElement* DataCertificationJetMET::mSumET_nVtx_profile_MiniAOD_over_Reco
private

Definition at line 112 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ nbinsPV_

int DataCertificationJetMET::nbinsPV_
private

Definition at line 57 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ nPVMax_

double DataCertificationJetMET::nPVMax_
private

Definition at line 59 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ nPVMin_

double DataCertificationJetMET::nPVMin_
private

Definition at line 58 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ pfJetKSTest

bool DataCertificationJetMET::pfJetKSTest
private

Definition at line 74 of file DataCertificationJetMET.h.

◆ pfJetMeanTest

bool DataCertificationJetMET::pfJetMeanTest
private

Definition at line 73 of file DataCertificationJetMET.h.

◆ pfMETKSTest

bool DataCertificationJetMET::pfMETKSTest
private

Definition at line 80 of file DataCertificationJetMET.h.

◆ pfMETMeanTest

bool DataCertificationJetMET::pfMETMeanTest
private

Definition at line 79 of file DataCertificationJetMET.h.

◆ ptBin_

int DataCertificationJetMET::ptBin_
private

Definition at line 65 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ ptMax_

double DataCertificationJetMET::ptMax_
private

Definition at line 67 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ ptMin_

double DataCertificationJetMET::ptMin_
private

Definition at line 66 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), and dqmEndJob().

◆ reportSummary

MonitorElement* DataCertificationJetMET::reportSummary
private

Definition at line 36 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ reportSummaryMap

MonitorElement* DataCertificationJetMET::reportSummaryMap
private

Definition at line 38 of file DataCertificationJetMET.h.

Referenced by dqmEndJob().

◆ tcMETKSTest

bool DataCertificationJetMET::tcMETKSTest
private

Definition at line 82 of file DataCertificationJetMET.h.

◆ tcMETMeanTest

bool DataCertificationJetMET::tcMETMeanTest
private

Definition at line 81 of file DataCertificationJetMET.h.

◆ verbose_

int DataCertificationJetMET::verbose_
private

Definition at line 45 of file DataCertificationJetMET.h.

Referenced by DataCertificationJetMET(), dqmEndJob(), and ~DataCertificationJetMET().

DataCertificationJetMET::mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco
MonitorElement * mMVAPUJIDDiscriminant_mediumPt_EndCap_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:135
DataCertificationJetMET::folderName
std::string folderName
Definition: DataCertificationJetMET.h:69
mps_fire.i
i
Definition: mps_fire.py:428
DataCertificationJetMET::mMET_EffHcalStripHaloFilter
MonitorElement * mMET_EffHcalStripHaloFilter
Definition: DataCertificationJetMET.h:97
DataCertificationJetMET::mMuonMultiplicity_MiniAOD_over_Reco
MonitorElement * mMuonMultiplicity_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:147
DataCertificationJetMET::mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco
MonitorElement * mMVAPUJIDDiscriminant_lowPt_Forward_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:134
dqm::implementation::IBooker::bookFloat
MonitorElement * bookFloat(TString const &name, FUNC onbooking=NOOP())
Definition: DQMStore.h:80
DataCertificationJetMET::mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
MonitorElement * mNeutralHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:114
DataCertificationJetMET::mEta_uncor_MiniAOD_over_Reco
MonitorElement * mEta_uncor_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:123
DataCertificationJetMET::mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco
MonitorElement * mMVAPUJIDDiscriminant_lowPt_EndCap_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:133
groupFilesInBlocks.tt
int tt
Definition: groupFilesInBlocks.py:144
DataCertificationJetMET::inputMETLabelRECOUncleaned_
edm::InputTag inputMETLabelRECOUncleaned_
Definition: DataCertificationJetMET.h:52
dqm::impl::MonitorElement::setOption
virtual void setOption(const char *option)
Definition: MonitorElement.cc:887
DataCertificationJetMET::InMemory_
bool InMemory_
Definition: DataCertificationJetMET.h:46
DataCertificationJetMET::mNeutralHadronEtFraction_MiniAOD_over_Reco
MonitorElement * mNeutralHadronEtFraction_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:107
gather_cfg.cout
cout
Definition: gather_cfg.py:144
DataCertificationJetMET::mPt_Barrel_MiniAOD_over_Reco
MonitorElement * mPt_Barrel_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:129
DataCertificationJetMET::mMET_EffCSCTightHalo2015Filter
MonitorElement * mMET_EffCSCTightHalo2015Filter
Definition: DataCertificationJetMET.h:96
DataCertificationJetMET::ptMax_
double ptMax_
Definition: DataCertificationJetMET.h:67
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
dqm::implementation::IGetter::getSubdirs
virtual DQM_DEPRECATED std::vector< std::string > getSubdirs() const
Definition: DQMStore.cc:678
dqm::legacy::MonitorElement
Definition: MonitorElement.h:461
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
DataCertificationJetMET::mMET_EffCSCTightHaloFilter
MonitorElement * mMET_EffCSCTightHaloFilter
Definition: DataCertificationJetMET.h:91
DataCertificationJetMET::mPt_EndCap_MiniAOD_over_Reco
MonitorElement * mPt_EndCap_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:130
DataCertificationJetMET::mPhotonEtFraction_MiniAOD_over_Reco
MonitorElement * mPhotonEtFraction_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:108
DataCertificationJetMET::verbose_
int verbose_
Definition: DataCertificationJetMET.h:45
DataCertificationJetMET::mChargedHadronEtFraction_MiniAOD_over_Reco
MonitorElement * mChargedHadronEtFraction_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:106
DataCertificationJetMET::mMETPhi_MiniAOD_over_Reco
MonitorElement * mMETPhi_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:103
DataCertificationJetMET::mSumET_logx_MiniAOD_over_Reco
MonitorElement * mSumET_logx_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:105
DataCertificationJetMET::CertificationSummaryMap
MonitorElement * CertificationSummaryMap
Definition: DataCertificationJetMET.h:39
DataCertificationJetMET::mLooseJIDPassFractionVSeta_MiniAOD_over_Reco
MonitorElement * mLooseJIDPassFractionVSeta_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:128
DataCertificationJetMET::etaMin_
double etaMin_
Definition: DataCertificationJetMET.h:62
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
DataCertificationJetMET::reportSummary
MonitorElement * reportSummary
Definition: DataCertificationJetMET.h:36
DataCertificationJetMET::mPhi_MiniAOD_over_Reco
MonitorElement * mPhi_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:120
DataCertificationJetMET::mHFEFracVSpT_Forward_MiniAOD_over_Reco
MonitorElement * mHFEFracVSpT_Forward_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:141
DataCertificationJetMET::mDPhi_MiniAOD_over_Reco
MonitorElement * mDPhi_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:127
DataCertificationJetMET::nPVMin_
double nPVMin_
Definition: DataCertificationJetMET.h:58
DataCertificationJetMET::mMET_MiniAOD_over_Reco
MonitorElement * mMET_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:100
dqm::legacy::MonitorElement::getRootObject
TObject * getRootObject() const override
Definition: MonitorElement.h:469
DataCertificationJetMET::mHFHadronEtFraction_MiniAOD_over_Reco
MonitorElement * mHFHadronEtFraction_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:109
DataCertificationJetMET::mEta_MiniAOD_over_Reco
MonitorElement * mEta_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:119
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
DataCertificationJetMET::mMET_EffEcalDeadCellTriggerFilter
MonitorElement * mMET_EffEcalDeadCellTriggerFilter
Definition: DataCertificationJetMET.h:93
DataCertificationJetMET::mCHFrac_MiniAOD_over_Reco
MonitorElement * mCHFrac_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:142
DataCertificationJetMET::ptMin_
double ptMin_
Definition: DataCertificationJetMET.h:66
DataCertificationJetMET::isHI
bool isHI
Definition: DataCertificationJetMET.h:87
DataCertificationJetMET::mMET_EffEcalDeadCellBoundaryFilter
MonitorElement * mMET_EffEcalDeadCellBoundaryFilter
Definition: DataCertificationJetMET.h:94
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DataCertificationJetMET::inputJetLabelMiniAOD_
edm::InputTag inputJetLabelMiniAOD_
Definition: DataCertificationJetMET.h:55
dqm::impl::MonitorElement::getQReport
const MonitorElementData::QReport * getQReport(const std::string &qtname) const
get QReport corresponding to <qtname> (null pointer if QReport does not exist)
Definition: MonitorElement.cc:481
DataCertificationJetMET::mPhFracVSpT_Barrel_MiniAOD_over_Reco
MonitorElement * mPhFracVSpT_Barrel_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:139
DataCertificationJetMET::etaMax_
double etaMax_
Definition: DataCertificationJetMET.h:63
DataCertificationJetMET::mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco
MonitorElement * mMVAPUJIDDiscriminant_highPt_Barrel_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:136
DataCertificationJetMET::nPVMax_
double nPVMax_
Definition: DataCertificationJetMET.h:59
DataCertificationJetMET::mPt_uncor_MiniAOD_over_Reco
MonitorElement * mPt_uncor_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:122
DataCertificationJetMET::mNjets_MiniAOD_over_Reco
MonitorElement * mNjets_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:121
DataCertificationJetMET::mJetEnergyCorr_MiniAOD_over_Reco
MonitorElement * mJetEnergyCorr_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:125
DataCertificationJetMET::inputJetLabelRECO_
edm::InputTag inputJetLabelRECO_
Definition: DataCertificationJetMET.h:54
DataCertificationJetMET::conf_
edm::ParameterSet conf_
Definition: DataCertificationJetMET.h:43
MonitorElementData::QReport
Definition: MonitorElementCollection.h:55
DataCertificationJetMET::mNHFrac_MiniAOD_over_Reco
MonitorElement * mNHFrac_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:143
DataCertificationJetMET::mPhFrac_MiniAOD_over_Reco
MonitorElement * mPhFrac_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:144
createfilelist.int
int
Definition: createfilelist.py:10
dqm::impl::MonitorElement::setBinLabel
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:771
DataCertificationJetMET::mPt_Forward_MiniAOD_over_Reco
MonitorElement * mPt_Forward_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:131
DataCertificationJetMET::ptBin_
int ptBin_
Definition: DataCertificationJetMET.h:65
DataCertificationJetMET::mCHFracVSpT_Barrel_MiniAOD_over_Reco
MonitorElement * mCHFracVSpT_Barrel_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:137
DataCertificationJetMET::mJetEnergyCorrVSeta_MiniAOD_over_Reco
MonitorElement * mJetEnergyCorrVSeta_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:126
DataCertificationJetMET::jetTests
bool jetTests[5][2]
Definition: DataCertificationJetMET.h:84
DataCertificationJetMET::mChargedMultiplicity_MiniAOD_over_Reco
MonitorElement * mChargedMultiplicity_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:145
DataCertificationJetMET::reportSummaryMap
MonitorElement * reportSummaryMap
Definition: DataCertificationJetMET.h:38
DataCertificationJetMET::mNeutralFraction_MiniAOD_over_Reco
MonitorElement * mNeutralFraction_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:148
DataCertificationJetMET::mMET_EffHBHENoiseFilter
MonitorElement * mMET_EffHBHENoiseFilter
Definition: DataCertificationJetMET.h:90
DataCertificationJetMET::mPhi_uncor_MiniAOD_over_Reco
MonitorElement * mPhi_uncor_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:124
DataCertificationJetMET::mMET_EffeeBadScFilter
MonitorElement * mMET_EffeeBadScFilter
Definition: DataCertificationJetMET.h:92
DataCertificationJetMET::metFolder
std::string metFolder
Definition: DataCertificationJetMET.h:48
DataCertificationJetMET::CertificationSummary
MonitorElement * CertificationSummary
Definition: DataCertificationJetMET.h:37
DataCertificationJetMET::etaBin_
int etaBin_
Definition: DataCertificationJetMET.h:61
DataCertificationJetMET::metTests
bool metTests[5][2]
Definition: DataCertificationJetMET.h:85
DataCertificationJetMET::mSumET_MiniAOD_over_Reco
MonitorElement * mSumET_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:102
dqm::impl::MonitorElement::setBinContent
virtual void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:691
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
dqm::impl::MonitorElement::getNbinsX
virtual int getNbinsX() const
get # of bins in X-axis
Definition: MonitorElement.cc:574
DataCertificationJetMET::mNeutralMultiplicity_MiniAOD_over_Reco
MonitorElement * mNeutralMultiplicity_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:146
DataCertificationJetMET::mHFEMEtFraction_MiniAOD_over_Reco
MonitorElement * mHFEMEtFraction_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:110
dqm::implementation::IGetter::get
virtual MonitorElement * get(std::string const &fullpath) const
Definition: DQMStore.cc:651
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
DataCertificationJetMET::mSumET_nVtx_profile_MiniAOD_over_Reco
MonitorElement * mSumET_nVtx_profile_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:112
DataCertificationJetMET::mNHFracVSpT_EndCap_MiniAOD_over_Reco
MonitorElement * mNHFracVSpT_EndCap_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:138
DataCertificationJetMET::mMEy_MiniAOD_over_Reco
MonitorElement * mMEy_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:101
DataCertificationJetMET::nbinsPV_
int nbinsPV_
Definition: DataCertificationJetMET.h:57
DataCertificationJetMET::inputMETLabelRECO_
edm::InputTag inputMETLabelRECO_
Definition: DataCertificationJetMET.h:51
DataCertificationJetMET::mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
MonitorElement * mChargedHadronEtFraction_nVtx_profile_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:113
DataCertificationJetMET::inputMETLabelMiniAOD_
edm::InputTag inputMETLabelMiniAOD_
Definition: DataCertificationJetMET.h:53
DataCertificationJetMET::mMET_nVtx_profile_MiniAOD_over_Reco
MonitorElement * mMET_nVtx_profile_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:111
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
DataCertificationJetMET::mMET_EffHBHEIsoNoiseFilter
MonitorElement * mMET_EffHBHEIsoNoiseFilter
Definition: DataCertificationJetMET.h:95
DataCertificationJetMET::mMET_logx_MiniAOD_over_Reco
MonitorElement * mMET_logx_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:104
DataCertificationJetMET::mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco
MonitorElement * mMVAPUJIDDiscriminant_lowPt_Barrel_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:132
dqm::impl::MonitorElement::getBinContent
virtual double getBinContent(int binx) const
get content of bin (1-D)
Definition: MonitorElement.cc:592
DataCertificationJetMET::mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco
MonitorElement * mPhotonEtFraction_nVtx_profile_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:115
edm::InputTag
Definition: InputTag.h:15
DataCertificationJetMET::mPt_MiniAOD_over_Reco
MonitorElement * mPt_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:118
DataCertificationJetMET::jetAlgo
std::string jetAlgo
Definition: DataCertificationJetMET.h:49
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
DataCertificationJetMET::mHFHFracVSpT_Forward_MiniAOD_over_Reco
MonitorElement * mHFHFracVSpT_Forward_MiniAOD_over_Reco
Definition: DataCertificationJetMET.h:140
dqm::legacy::MonitorElement::getTH2F
virtual TH2F * getTH2F() const
Definition: MonitorElement.h:490
Generated for CMSSW Reference Manual by doxygen 1.8.16