HLTHiggsSubAnalysis Class Reference

#include <HLTHiggsSubAnalysis.h>

Public Types
enum	{ GEN, RECO }
typedef dqm::legacy::DQMStore	DQMStore
typedef dqm::legacy::MonitorElement	MonitorElement

Public Member Functions
void	analyze (const edm::Event &iEvent, const edm::EventSetup &iEventSetup, EVTColContainer *cols)
void	beginJob ()
void	beginRun (const edm::Run &iRun, const edm::EventSetup &iEventSetup)
void	bookHistograms (DQMStore::IBooker &)
const std::vector< unsigned int >	getObjectsType (const std::string &hltpath) const
	Extract what objects need this analysis. More...
	HLTHiggsSubAnalysis (const edm::ParameterSet &pset, const std::string &analysisname, edm::ConsumesCollector &&iC)
	~HLTHiggsSubAnalysis ()

Private Member Functions
void	bookHist (const std::string &source, const std::string &objType, const std::string &variable, DQMStore::IBooker &)
void	bookobjects (const edm::ParameterSet &anpset, edm::ConsumesCollector &iC)
void	fillHist (const std::string &source, const std::string &objType, const std::string &variable, const float &value)
void	initAndInsertJets (const edm::Event &iEvent, EVTColContainer *cols, std::vector< MatchStruct > *matches)
void	initobjects (const edm::Event &iEvent, EVTColContainer *col)
void	InitSelector (const unsigned int &objtype)
void	insertcandidates (const unsigned int &objtype, const EVTColContainer *col, std::vector< MatchStruct > *matches)
void	passJetCuts (std::vector< MatchStruct > *matches, std::map< std::string, bool > &jetCutResult, float &dEtaqq, float &mqq, float &dPhibb, float &CSV1, float &CSV2, float &CSV3)
void	passOtherCuts (const std::vector< MatchStruct > &matches, std::map< std::string, bool > &jetCutResult)

Private Attributes
std::string	_analysisname
std::vector< HLTHiggsPlotter >	_analyzers
bool	_bookHtPlots
std::map< unsigned int, double >	_cutMaxEta
std::map< unsigned int, double >	_cutMinPt
std::map< unsigned int, unsigned int >	_cutMotherId
std::map< unsigned int, std::vector< double > >	_cutsDr
std::map< std::string, MonitorElement * >	_elements
std::map< unsigned int, std::string >	_genCut
	gen/rec objects cuts More...
edm::EDGetTokenT< reco::GenJetCollection >	_genJetLabel
StringCutObjectSelector< reco::GenJet > *	_genJetSelector
edm::EDGetTokenT< reco::GenParticleCollection >	_genParticleLabel
std::map< unsigned int, StringCutObjectSelector< reco::GenParticle > * >	_genSelectorMap
std::string	_histDirectory
HLTConfigProvider	_hltConfig
std::set< std::string >	_hltPaths
	the hlt paths found in the hltConfig More...
std::vector< std::string >	_hltPathsToCheck
	the hlt paths with regular expressions More...
std::string	_hltProcessName
double	_HtJetEtaMax
double	_HtJetPtMin
unsigned int	_minCandidates
	The minimum number of reco/gen candidates needed by the analysis. More...
std::vector< double >	_NminOneCuts
std::vector< double >	_parametersEta
	Some kinematical parameters. More...
std::vector< double >	_parametersHt
std::vector< double >	_parametersPhi
std::vector< double >	_parametersPu
std::vector< double >	_parametersTurnOn
edm::ParameterSet	_pset
edm::EDGetTokenT< std::vector< PileupSummaryInfo > >	_puSummaryInfo
StringCutObjectSelector< reco::CaloMET > *	_recCaloMETSelector
std::map< unsigned int, std::string >	_recCut
StringCutObjectSelector< reco::GsfElectron > *	_recElecSelector
std::map< unsigned int, std::string >	_recLabels
edm::EDGetTokenT< reco::CaloMETCollection >	_recLabelsCaloMET
edm::EDGetTokenT< reco::GsfElectronCollection >	_recLabelsElec
edm::EDGetTokenT< reco::MuonCollection >	_recLabelsMuon
edm::EDGetTokenT< reco::PFJetCollection >	_recLabelsPFJet
edm::EDGetTokenT< reco::PFMETCollection >	_recLabelsPFMET
edm::EDGetTokenT< reco::PFTauCollection >	_recLabelsPFTau
edm::EDGetTokenT< reco::PhotonCollection >	_recLabelsPhoton
StringCutObjectSelector< reco::Muon > *	_recMuonSelector
edm::EDGetTokenT< reco::PFJetCollection >	_recoHtJetLabel
StringCutObjectSelector< reco::PFJet > *	_recPFJetSelector
StringCutObjectSelector< reco::PFMET > *	_recPFMETSelector
StringCutObjectSelector< reco::PFTau > *	_recPFTauSelector
StringCutObjectSelector< reco::Photon > *	_recPhotonSelector
edm::EDGetTokenT< reco::JetTagCollection >	_recTagPFJet
StringCutObjectSelector< reco::Track > *	_recTrackSelector
std::map< std::string, std::string >	_shortpath2long
	Relation between the short version of a path. More...
edm::EDGetTokenT< edm::TriggerResults >	_trigResultsTag
bool	_useNminOneCuts
unsigned int	NptPlots

Detailed Description

Generate histograms for trigger efficiencies Higgs related Documentation available on the CMS TWiki: https://twiki.cern.ch/twiki/bin/view/CMS/HiggsWGHLTValidate

Author

J. Duarte Campderros (based and adapted on J. Klukas, M. Vander Donckt and J. Alcaraz code from the HLTriggerOffline/Muon package)

Definition at line 59 of file HLTHiggsSubAnalysis.h.

Member Typedef Documentation

typedef dqm::legacy::DQMStore HLTHiggsSubAnalysis::DQMStore

Definition at line 61 of file HLTHiggsSubAnalysis.h.

typedef dqm::legacy::MonitorElement HLTHiggsSubAnalysis::MonitorElement

Definition at line 62 of file HLTHiggsSubAnalysis.h.

Member Enumeration Documentation

anonymous enum

Enumerator
GEN
RECO

Definition at line 64 of file HLTHiggsSubAnalysis.h.

{ GEN, RECO };

Constructor & Destructor Documentation

HLTHiggsSubAnalysis::HLTHiggsSubAnalysis	(	const edm::ParameterSet &	pset,
		const std::string &	analysisname,
		edm::ConsumesCollector &&	iC
	)

Definition at line 32 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _bookHtPlots, _cutMaxEta, _cutMinPt, _genCut, _hltPathsToCheck, _HtJetEtaMax, _HtJetPtMin, _minCandidates, _NminOneCuts, _parametersHt, _parametersTurnOn, _pset, _puSummaryInfo, _recCut, _recLabels, _useNminOneCuts, edm::ParameterSet::addParameter(), bookobjects(), edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), beamvalidation::exit(), edm::ParameterSet::getParameter(), EVTColContainer::getTypeString(), edm::ParameterSet::getUntrackedParameter(), NptPlots, and AlCaHLTBitMon_QueryRunRegistry::string.

    : _pset(pset),
      _analysisname(analysisname),
      _minCandidates(0),
      _HtJetPtMin(0),
      _HtJetEtaMax(0),
      _hltProcessName(pset.getParameter<std::string>("hltProcessName")),
      _histDirectory(pset.getParameter<std::string>("histDirectory")),
      _genParticleLabel(iC.consumes<reco::GenParticleCollection>(pset.getParameter<std::string>("genParticleLabel"))),
      _genJetLabel(iC.consumes<reco::GenJetCollection>(pset.getParameter<std::string>("genJetLabel"))),
      _recoHtJetLabel(iC.consumes<reco::PFJetCollection>(
          pset.getUntrackedParameter<std::string>("recoHtJetLabel", "ak4PFJetsCHS"))),
      _parametersEta(pset.getParameter<std::vector<double>>("parametersEta")),
      _parametersPhi(pset.getParameter<std::vector<double>>("parametersPhi")),
      _parametersPu(pset.getParameter<std::vector<double>>("parametersPu")),
      _parametersHt(0),
      _parametersTurnOn(pset.getParameter<std::vector<double>>("parametersTurnOn")),
      _trigResultsTag(iC.consumes<edm::TriggerResults>(edm::InputTag("TriggerResults", "", _hltProcessName))),
      _genJetSelector(nullptr),
      _recMuonSelector(nullptr),
      _recElecSelector(nullptr),
      _recCaloMETSelector(nullptr),
      _recPFMETSelector(nullptr),
      _recPFTauSelector(nullptr),
      _recPhotonSelector(nullptr),
      _recPFJetSelector(nullptr),
      _recTrackSelector(nullptr),
      _NminOneCuts(0),
      _useNminOneCuts(false) {
  // Specific parameters for this analysis
  edm::ParameterSet anpset = pset.getParameter<edm::ParameterSet>(analysisname);
  // Collections labels (but genparticles already initialized)
  // initializing _recLabels data member)
  if (anpset.exists("parametersTurnOn")) {
    _parametersTurnOn = anpset.getParameter<std::vector<double>>("parametersTurnOn");
    _pset.addParameter("parametersTurnOn", _parametersTurnOn);
  }
  this->bookobjects(anpset, iC);
  // Generic objects: Initialization of cuts
  for (std::map<unsigned int, std::string>::const_iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
    const std::string objStr = EVTColContainer::getTypeString(it->first);
    _genCut[it->first] = pset.getParameter<std::string>(objStr + "_genCut");
    _recCut[it->first] = pset.getParameter<std::string>(objStr + "_recCut");
    _cutMinPt[it->first] = pset.getParameter<double>(objStr + "_cutMinPt");
    _cutMaxEta[it->first] = pset.getParameter<double>(objStr + "_cutMaxEta");
  }
  //--- Updating parameters if has to be modified for this particular specific analysis
  for (std::map<unsigned int, std::string>::const_iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
    const std::string objStr = EVTColContainer::getTypeString(it->first);
    if (anpset.existsAs<std::string>(objStr + "_genCut", false)) {
      _genCut[it->first] = anpset.getUntrackedParameter<std::string>(objStr + "_genCut");
    }
    if (anpset.existsAs<std::string>(objStr + "_recCut", false)) {
      _recCut[it->first] = anpset.getUntrackedParameter<std::string>(objStr + "_recCut");
    }
    if (anpset.existsAs<double>(objStr + "_cutMinPt", false)) {
      _cutMinPt[it->first] = anpset.getUntrackedParameter<double>(objStr + "_cutMinPt");
    }
    if (anpset.existsAs<double>(objStr + "_cutMaxEta", false)) {
      _cutMaxEta[it->first] = anpset.getUntrackedParameter<double>(objStr + "_cutMaxEta");
    }
  }
  _hltPathsToCheck = anpset.getParameter<std::vector<std::string>>("hltPathsToCheck");
  _minCandidates = anpset.getParameter<unsigned int>("minCandidates");

  std::vector<double> default_parametersHt;
  default_parametersHt.push_back(100);
  default_parametersHt.push_back(0);
  default_parametersHt.push_back(1000);
  _parametersHt = pset.getUntrackedParameter<std::vector<double>>("parametersHt", default_parametersHt);

  _HtJetPtMin = anpset.getUntrackedParameter<double>("HtJetPtMin", -1);
  _HtJetEtaMax = anpset.getUntrackedParameter<double>("HtJetEtaMax", -1);

  if (_HtJetPtMin > 0 && _HtJetEtaMax > 0)
    _bookHtPlots = true;
  else
    _bookHtPlots = false;

  if (pset.exists("pileUpInfoLabel")) {
    _puSummaryInfo = iC.consumes<std::vector<PileupSummaryInfo>>(pset.getParameter<std::string>("pileUpInfoLabel"));
  }

  if (anpset.existsAs<std::vector<double>>("NminOneCuts", false)) {
    _NminOneCuts = anpset.getUntrackedParameter<std::vector<double>>("NminOneCuts");
    if (_NminOneCuts.size() < 9 + _minCandidates) {
      edm::LogError("HiggsValidation") << "In HLTHiggsSubAnalysis::HLTHiggsSubAnalysis, "
                                       << "Incoherence found in the python configuration file!!\nThe SubAnalysis '"
                                       << _analysisname << "' has a vector NminOneCuts with size "
                                       << _NminOneCuts.size() << ", while it needs to be at least of size "
                                       << (9 + _minCandidates) << ".";
      exit(-1);
    }
    if ((_NminOneCuts[0] || _NminOneCuts[1]) && _minCandidates < 4) {
      edm::LogError("HiggsValidation") << "In HLTHiggsSubAnalysis::HLTHiggsSubAnalysis, "
                                       << "Incoherence found in the python configuration file!!\nThe SubAnalysis '"
                                       << _analysisname
                                       << "' has a vector NminOneCuts with a dEtaqq of mqq cut on the least b-tagged "
                                          "jets of the first 4 jets while only requiring "
                                       << _minCandidates << " jets.";
      exit(-1);
    }
    if (_NminOneCuts[5] && _minCandidates < 3) {
      edm::LogError("HiggsValidation") << "In HLTHiggsSubAnalysis::HLTHiggsSubAnalysis, "
                                       << "Incoherence found in the python configuration file!!\nThe SubAnalysis '"
                                       << _analysisname
                                       << "' has a vector NminOneCuts with a CSV3 cut while only requiring "
                                       << _minCandidates << " jets.";
      exit(-1);
    }
    if ((_NminOneCuts[2] || _NminOneCuts[4]) && _minCandidates < 2) {
      edm::LogError("HiggsValidation") << "In HLTHiggsSubAnalysis::HLTHiggsSubAnalysis, "
                                       << "Incoherence found in the python configuration file!!\nThe SubAnalysis '"
                                       << _analysisname
                                       << "' has a vector NminOneCuts with a dPhibb or CSV2 cut using the second most "
                                          "b-tagged jet while only requiring "
                                       << _minCandidates << " jet.";
      exit(-1);
    }
    for (std::vector<double>::const_iterator it = _NminOneCuts.begin(); it != _NminOneCuts.end(); ++it) {
      if (*it) {
        _useNminOneCuts = true;
        break;
      }
    }
  }
  //    NptPlots = ( _useNminOneCuts ? _minCandidates : 2 );
  NptPlots = _minCandidates;
}

HLTHiggsSubAnalysis::~HLTHiggsSubAnalysis

(

)

Definition at line 164 of file HLTHiggsSubAnalysis.cc.

References _genJetSelector, _genSelectorMap, _recCaloMETSelector, _recElecSelector, _recMuonSelector, _recPFJetSelector, _recPFMETSelector, _recPFTauSelector, _recPhotonSelector, _recTrackSelector, and genParticles_cff::map.

                                          {
  for (std::map<unsigned int, StringCutObjectSelector<reco::GenParticle>*>::iterator it = _genSelectorMap.begin();
       it != _genSelectorMap.end();
       ++it) {
    delete it->second;
    it->second = nullptr;
  }
  delete _genJetSelector;
  _genJetSelector = nullptr;
  delete _recMuonSelector;
  _recMuonSelector = nullptr;
  delete _recElecSelector;
  _recElecSelector = nullptr;
  delete _recPhotonSelector;
  _recPhotonSelector = nullptr;
  delete _recCaloMETSelector;
  _recCaloMETSelector = nullptr;
  delete _recPFMETSelector;
  _recPFMETSelector = nullptr;
  delete _recPFTauSelector;
  _recPFTauSelector = nullptr;
  delete _recPFJetSelector;
  _recPFJetSelector = nullptr;
  delete _recTrackSelector;
  _recTrackSelector = nullptr;
}

Member Function Documentation

void HLTHiggsSubAnalysis::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iEventSetup,
		EVTColContainer *	cols
	)

Definition at line 370 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _analyzers, _bookHtPlots, _elements, _genCut, _genJetLabel, _genJetSelector, _genSelectorMap, _hltPathsToCheck, _HtJetEtaMax, _HtJetPtMin, _minCandidates, _NminOneCuts, _puSummaryInfo, _recLabels, _recoHtJetLabel, _shortpath2long, _useNminOneCuts, edm::HLTGlobalStatus::accept(), PVValHelper::eta, fillHist(), GEN, EVTColContainer::genJets, EVTColContainer::genParticles, edm::Event::getByToken(), EVTColContainer::getTypeString(), zMuMuMuonUserData::hltPath, mps_fire::i, initAndInsertJets(), initobjects(), InitSelector(), insertcandidates(), edm::HandleBase::isValid(), dqmiolumiharvest::j, genParticles_cff::map, patCandidatesForDimuonsSequences_cff::matches, MuonErrorMatrixAnalyzer_cfi::maxPt, NptPlots, electrons_cff::objType, passJetCuts(), passOtherCuts(), EVTColContainer::PFJET, EVTColContainer::PFMET, phi, DiDispStaMuonMonitor_cfi::pt, RECO, source, AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, edm::TriggerNames::triggerIndex(), edm::Event::triggerNames(), EVTColContainer::triggerResults, and trigNames.

                                                                                                            {
  // Initialize the collection (the ones which hasn't been initialiazed yet)
  this->initobjects(iEvent, cols);
  // utility map
  std::map<unsigned int, std::string> u2str;
  u2str[GEN] = "gen";
  u2str[RECO] = "rec";

  std::map<unsigned int, double> Htmap;
  Htmap[GEN] = 0.;
  Htmap[RECO] = 0.;

  edm::Handle<std::vector<PileupSummaryInfo>> puInfo;
  iEvent.getByToken(_puSummaryInfo, puInfo);
  int nbMCvtx = -1;
  if (puInfo.isValid()) {
    std::vector<PileupSummaryInfo>::const_iterator PVI;
    for (PVI = puInfo->begin(); PVI != puInfo->end(); ++PVI) {
      if (PVI->getBunchCrossing() == 0) {
        nbMCvtx = PVI->getPU_NumInteractions();
        break;
      }
    }
  }

  // Extract the match structure containing the gen/reco candidates (electron, muons,...)
  // common to all the SubAnalysis
  //---- Generation
  // Make each good gen object into the base cand for a MatchStruct
  std::vector<MatchStruct>* matches = new std::vector<MatchStruct>;
  //  bool alreadyMu = false;
  for (std::map<unsigned int, std::string>::iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
    // Use genJets for jet matchstructs
    if (it->first == EVTColContainer::PFJET) {
      // Skip genJets for N-1 plots
      if (!_useNminOneCuts) {
        // Initialize selectors when first event
        if (!_genJetSelector) {
          _genJetSelector = new StringCutObjectSelector<reco::GenJet>(_genCut[it->first]);
        }
        for (size_t i = 0; i < cols->genJets->size(); ++i) {
          if (_genJetSelector->operator()(cols->genJets->at(i))) {
            matches->push_back(MatchStruct(&cols->genJets->at(i), it->first));
          }
        }
      }
    }
    // Use genParticles
    else {
      // Avoiding the TkMu and Mu case
      /*      if( alreadyMu )
        {
            continue;
        }*/
      // Initialize selectors when first event
      if (!_genSelectorMap[it->first]) {
        _genSelectorMap[it->first] = new StringCutObjectSelector<reco::GenParticle>(_genCut[it->first]);
      }

      for (size_t i = 0; i < cols->genParticles->size(); ++i) {
        if (_genSelectorMap[it->first]->operator()(cols->genParticles->at(i))) {
          matches->push_back(MatchStruct(&cols->genParticles->at(i), it->first));
        }
      }
      /*      if( it->first == EVTColContainer::MUON || it->first == EVTColContainer::TRACK )
        {
            alreadyMu = true;
        }*/
    }
  }
  // Sort the MatchStructs by pT for later filling of turn-on curve
  std::sort(matches->begin(), matches->end(), matchesByDescendingPt());

  // Map to reference the source (gen/reco) with the recoCandidates
  std::map<unsigned int, std::vector<MatchStruct>> sourceMatchMap;  // To be a pointer to delete
  // --- Storing the generating candidates
  sourceMatchMap[GEN] = *matches;

  // Reuse the vector
  matches->clear();
  // --- same for RECO objects

  // Different treatment for jets (b-tag)
  std::map<std::string, bool> nMinOne;
  std::map<std::string, bool> jetCutResult;
  float dEtaqq;
  float mqq;
  float dPhibb;
  float CSV1;
  float CSV2;
  float CSV3;
  bool passAllCuts = false;
  if (_recLabels.find(EVTColContainer::PFJET) != _recLabels.end()) {
    // Initialize jet selector
    this->InitSelector(EVTColContainer::PFJET);
    // Initialize and insert pfJets
    this->initAndInsertJets(iEvent, cols, matches);
    // Make sure to skip events that don't have enough jets
    if (matches->size() < NptPlots) {
      delete matches;
      return;
    }
    // Cuts on multiple jet events (RECO)
    if (_useNminOneCuts) {
      this->passJetCuts(matches, jetCutResult, dEtaqq, mqq, dPhibb, CSV1, CSV2, CSV3);
    }
  }
  // Extraction of the objects candidates
  for (std::map<unsigned int, std::string>::iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
    // Reco selectors (the function takes into account if it was instantiated
    // before or not
    this->InitSelector(it->first);
    // -- Storing the matches
    this->insertcandidates(it->first, cols, matches);
  }

  // Sort the MatchStructs by pT for later filling of turn-on curve
  std::sort(matches->begin(), matches->end(), matchesByDescendingPt());

  if (_useNminOneCuts) {
    // Check non-jet N-1 Cuts
    this->passOtherCuts(*matches, jetCutResult);

    // Make N-1 booleans from jetCutResults
    for (std::map<std::string, bool>::const_iterator it = jetCutResult.begin(); it != jetCutResult.end(); ++it) {
      nMinOne[it->first] = true;
      for (std::map<std::string, bool>::const_iterator it2 = jetCutResult.begin(); it2 != jetCutResult.end(); ++it2) {
        //ignore CSV2,CSV3 cut plotting CSV1
        if (it->first == "CSV1" && it2->first == "CSV3")
          continue;
        if (it->first == "CSV1" && it2->first == "CSV2")
          continue;

        //ignore CSV3 plotting cut CSV2
        if (it->first == "CSV2" && it2->first == "CSV3")
          continue;

        if (it->first != it2->first && !(it2->second)) {
          nMinOne[it->first] = false;
          break;
        }
      }
    }
    bool temp = false;
    for (std::map<std::string, bool>::const_iterator it = nMinOne.begin(); it != nMinOne.end(); ++it) {
      if (temp && it->second) {
        passAllCuts = true;
        break;
      }
      if (it->second)
        temp = true;
    }
  }

  // --- Storing the reco candidates
  sourceMatchMap[RECO] = *matches;
  // --- All the objects are in place
  delete matches;

  // -- Trigger Results
  const edm::TriggerNames& trigNames = iEvent.triggerNames(*(cols->triggerResults));

  if (_bookHtPlots) {
    edm::Handle<reco::PFJetCollection> recoJet;
    iEvent.getByToken(_recoHtJetLabel, recoJet);
    if (recoJet.isValid()) {
      for (reco::PFJetCollection::const_iterator iJet = recoJet->begin(); iJet != recoJet->end(); iJet++) {
        double pt = iJet->pt();
        double eta = iJet->eta();
        if (pt > _HtJetPtMin && fabs(eta) < _HtJetEtaMax) {
          Htmap[RECO] += pt;
        }
      }
    }

    edm::Handle<reco::GenJetCollection> genJet;
    iEvent.getByToken(_genJetLabel, genJet);
    if (genJet.isValid()) {
      for (reco::GenJetCollection::const_iterator iJet = genJet->begin(); iJet != genJet->end(); iJet++) {
        double pt = iJet->pt();
        double eta = iJet->eta();
        if (pt > _HtJetPtMin && fabs(eta) < _HtJetEtaMax) {
          Htmap[GEN] += pt;
        }
      }
    }
  }

  // Filling the histograms if pass the minimum amount of candidates needed by the analysis:
  // GEN + RECO CASE in the same loop
  for (std::map<unsigned int, std::vector<MatchStruct>>::iterator it = sourceMatchMap.begin();
       it != sourceMatchMap.end();
       ++it) {
    // it->first: gen/reco   it->second: matches (std::vector<MatchStruc>)
    if (it->second.size() < _minCandidates)  // FIXME: A bug is potentially here: what about the mixed channels?
    {
      continue;
    }

    // Filling the gen/reco objects (eff-denominators):
    // Just the first two different ones, if there are more
    std::map<unsigned int, int>* countobjects = new std::map<unsigned int, int>;
    // Initializing the count of the used object
    for (std::map<unsigned int, std::string>::iterator co = _recLabels.begin(); co != _recLabels.end(); ++co) {
      if (!(_useNminOneCuts && co->first == EVTColContainer::PFJET && it->first == GEN))  // genJets are not there
        countobjects->insert(std::pair<unsigned int, int>(co->first, 0));
    }
    int counttotal = 0;
    const int totalobjectssize2 = NptPlots * countobjects->size();
    for (size_t j = 0; j < it->second.size(); ++j) {
      const unsigned int objType = it->second[j].objType;
      const std::string objTypeStr = EVTColContainer::getTypeString(objType);

      float pt = (it->second)[j].pt;
      float eta = (it->second)[j].eta;
      float phi = (it->second)[j].phi;

      // PFMET N-1 cut
      if (_useNminOneCuts && objType == EVTColContainer::PFMET && _NminOneCuts[8] && !nMinOne["PFMET"]) {
        continue;
      }

      TString maxPt;
      if ((unsigned)(*countobjects)[objType] < NptPlots) {
        maxPt = "MaxPt";
        maxPt += (*countobjects)[objType] + 1;
        if (_useNminOneCuts && objType == EVTColContainer::PFJET) {
          if (nMinOne[maxPt.Data()]) {
            this->fillHist(u2str[it->first], objTypeStr, maxPt.Data(), pt);
          }
        } else {
          this->fillHist(u2str[it->first], objTypeStr, maxPt.Data(), pt);
        }
        // Filled the high pt ...
        ++((*countobjects)[objType]);
        ++counttotal;
      } else {
        if ((unsigned)(*countobjects)[objType] < _minCandidates) {  // To get correct results for HZZ
          ++((*countobjects)[objType]);
          ++counttotal;
        } else
          continue;  //   Otherwise too many entries in Eta and Phi distributions
      }

      // Jet N-1 Cuts
      if (_useNminOneCuts && objType == EVTColContainer::PFJET) {
        if (passAllCuts) {
          this->fillHist(u2str[it->first], objTypeStr, "Eta", eta);
          this->fillHist(u2str[it->first], objTypeStr, "Phi", phi);
        }
      } else {
        this->fillHist(u2str[it->first], objTypeStr, "Eta", eta);
        this->fillHist(u2str[it->first], objTypeStr, "Phi", phi);
      }

      // Already the minimum two objects has been filled, get out...
      if (counttotal == totalobjectssize2) {
        break;
      }
    }
    delete countobjects;

    if (_useNminOneCuts && it->first == RECO) {
      if (_NminOneCuts[0] && nMinOne["dEtaqq"]) {
        this->fillHist(u2str[it->first], EVTColContainer::getTypeString(EVTColContainer::PFJET), "dEtaqq", dEtaqq);
      }
      if (_NminOneCuts[1] && nMinOne["mqq"]) {
        this->fillHist(u2str[it->first], EVTColContainer::getTypeString(EVTColContainer::PFJET), "mqq", mqq);
      }
      if (_NminOneCuts[2] && nMinOne["dPhibb"]) {
        this->fillHist(u2str[it->first], EVTColContainer::getTypeString(EVTColContainer::PFJET), "dPhibb", dPhibb);
      }
      if (_NminOneCuts[3]) {
        std::string nameCSVplot = "CSV1";
        if (_NminOneCuts[6])
          nameCSVplot = "maxCSV";
        if (nMinOne[nameCSVplot])
          this->fillHist(u2str[it->first], EVTColContainer::getTypeString(EVTColContainer::PFJET), nameCSVplot, CSV1);
      }
      if (_NminOneCuts[4] && nMinOne["CSV2"]) {
        this->fillHist(u2str[it->first], EVTColContainer::getTypeString(EVTColContainer::PFJET), "CSV2", CSV2);
      }
      if (_NminOneCuts[5] && nMinOne["CSV3"]) {
        this->fillHist(u2str[it->first], EVTColContainer::getTypeString(EVTColContainer::PFJET), "CSV3", CSV3);
      }
    }

    //fill the efficiency vs nb of interactions
    std::string nameVtxPlot = "trueVtxDist_" + _analysisname + "_" + u2str[it->first];
    if ((!_useNminOneCuts) || it->first == RECO)
      _elements[nameVtxPlot]->Fill(nbMCvtx);

    //fill the efficiency vs sum pT of jets
    std::string nameHtPlot = "HtDist_" + _analysisname + "_" + u2str[it->first];
    if (_bookHtPlots)
      _elements[nameHtPlot]->Fill(Htmap[it->first]);

    // Calling to the plotters analysis (where the evaluation of the different trigger paths are done)
    std::string SummaryName = "SummaryPaths_" + _analysisname + "_" + u2str[it->first];
    const std::string source = u2str[it->first];
    for (std::vector<HLTHiggsPlotter>::iterator an = _analyzers.begin(); an != _analyzers.end(); ++an) {
      const std::string hltPath = _shortpath2long[an->gethltpath()];
      const std::string fillShortPath = an->gethltpath();
      const bool ispassTrigger = cols->triggerResults->accept(trigNames.triggerIndex(hltPath));

      if (_useNminOneCuts) {
        an->analyze(ispassTrigger, source, it->second, nMinOne, dEtaqq, mqq, dPhibb, CSV1, CSV2, CSV3, passAllCuts);
      } else {
        an->analyze(ispassTrigger, source, it->second, _minCandidates);
      }

      int refOfThePath = -1;
      for (size_t itePath = 0; itePath < _hltPathsToCheck.size(); itePath++) {
        refOfThePath++;
        if (TString(hltPath).Contains(_hltPathsToCheck[itePath]))
          break;
      }
      _elements[SummaryName]->Fill(refOfThePath);
      if (ispassTrigger) {
        _elements[SummaryName + "_passingHLT"]->Fill(refOfThePath, 1);
        if ((!_useNminOneCuts) || it->first == RECO)
          _elements[nameVtxPlot + "_" + fillShortPath]->Fill(nbMCvtx);
        if (_bookHtPlots)
          _elements[nameHtPlot + "_" + fillShortPath]->Fill(Htmap[it->first]);
      } else {
        _elements[SummaryName + "_passingHLT"]->Fill(refOfThePath, 0);
      }
    }
  }
}

void HLTHiggsSubAnalysis::beginJob

(

void

)

Definition at line 191 of file HLTHiggsSubAnalysis.cc.

{}

void HLTHiggsSubAnalysis::beginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iEventSetup
	)

Definition at line 193 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _analyzers, _hltConfig, _hltPaths, _hltPathsToCheck, _hltProcessName, _NminOneCuts, _pset, _recLabels, _shortpath2long, ramdisk_dqm_sourceclient-live_cfg::analyzer, beamvalidation::exit(), spr::find(), newFWLiteAna::found, getObjectsType(), EVTColContainer::getTypeString(), mps_fire::i, HLTConfigProvider::init(), dqmiolumiharvest::j, LogDebug, LogTrace, NptPlots, castor_dqm_sourceclient_file_cfg::path, topSingleLeptonDQM_PU_cfi::pattern, AlCaHLTBitMon_QueryRunRegistry::string, and HLTConfigProvider::triggerNames().

                                                                                  {
  // Initialize the confighlt
  bool changedConfig;
  if (!_hltConfig.init(iRun, iSetup, _hltProcessName, changedConfig)) {
    edm::LogError("HiggsValidations") << "HLTHiggsSubAnalysis::beginRun: "
                                      << "Initializtion of HLTConfigProvider failed!!";
  }

  // Parse the input paths to get them if there are in the table
  // and associate them the last filter of the path (in order to extract the
  _hltPaths.clear();
  for (size_t i = 0; i < _hltPathsToCheck.size(); ++i) {
    bool found = false;
    TPRegexp pattern(_hltPathsToCheck[i]);
    for (size_t j = 0; j < _hltConfig.triggerNames().size(); ++j) {
      std::string thetriggername = _hltConfig.triggerNames()[j];
      if (TString(thetriggername).Contains(pattern)) {
        _hltPaths.insert(thetriggername);
        found = true;
      }
    }
    if (!found) {
      LogDebug("HiggsValidations") << "HLTHiggsSubAnalysis::beginRun, In " << _analysisname
                                   << " subfolder NOT found the path: '" << _hltPathsToCheck[i] << "*'";
    }
  }

  LogTrace("HiggsValidation") << "SubAnalysis: " << _analysisname << "\nHLT Trigger Paths found >>>";
  // Initialize the plotters (analysers for each trigger path)
  _analyzers.clear();
  for (std::set<std::string>::iterator iPath = _hltPaths.begin(); iPath != _hltPaths.end(); ++iPath) {
    // Avoiding the dependence of the version number for
    // the trigger paths
    std::string path = *iPath;
    std::string shortpath = path;
    if (path.rfind("_v") < path.length()) {
      shortpath = path.substr(0, path.rfind("_v"));
    }
    _shortpath2long[shortpath] = path;

    // Objects needed by the HLT path
    const std::vector<unsigned int> objsNeedHLT = this->getObjectsType(shortpath);
    // Sanity check: the object needed by a trigger path should be
    // introduced by the user via config python (_recLabels datamember)
    std::vector<unsigned int> userInstantiate;
    for (std::map<unsigned int, std::string>::iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
      userInstantiate.push_back(it->first);
    }
    for (std::vector<unsigned int>::const_iterator it = objsNeedHLT.begin(); it != objsNeedHLT.end(); ++it) {
      if (std::find(userInstantiate.begin(), userInstantiate.end(), *it) == userInstantiate.end()) {
        edm::LogError("HiggsValidation") << "In HLTHiggsSubAnalysis::beginRun, "
                                         << "Incoherence found in the python configuration file!!\nThe SubAnalysis '"
                                         << _analysisname << "' has been asked to evaluate the trigger path '"
                                         << shortpath << "' (found it in 'hltPathsToCheck') BUT this path"
                                         << " needs a '" << EVTColContainer::getTypeString(*it)
                                         << "' which has not been instantiate ('recVariableLabels'"
                                         << ")";
        exit(-1);
      }
    }
    LogTrace("HiggsValidation") << " --- " << shortpath;

    // the hlt path, the objects (elec,muons,photons,...)
    // needed to evaluate the path are the argumens of the plotter
    HLTHiggsPlotter analyzer(_pset, shortpath, objsNeedHLT, NptPlots, _NminOneCuts);
    _analyzers.push_back(analyzer);
  }
}

void HLTHiggsSubAnalysis::bookHist ( const std::string &  source, const std::string &  objType, const std::string &  variable, DQMStore::IBooker &  ibooker  )

private

Definition at line 862 of file HLTHiggsSubAnalysis.cc.

References _elements, _parametersEta, _parametersPhi, _parametersTurnOn, dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), SelectiveReadoutTask_cfi::edges, EVTColContainer::getTypeString(), h, mps_fire::i, createfilelist::int, SiStripPI::max, min(), Skims_PA_cff::name, seedmultiplicitymonitor_newtracking_cfi::nBins, electrons_cff::objType, CalibrationSummaryClient_cfi::params, EVTColContainer::PFJET, EVTColContainer::PFMET, source, AlCaHLTBitMon_QueryRunRegistry::string, overlapproblemtsosanalyzer_cfi::title, and taus_updatedMVAIds_cff::variable.

Referenced by bookHistograms().

                                                             {
  std::string sourceUpper = source;
  sourceUpper[0] = std::toupper(sourceUpper[0]);
  std::string name = source + objType + variable;
  TH1F* h = nullptr;

  if (variable.find("MaxPt") != std::string::npos) {
    std::string desc;
    if (variable == "MaxPt1")
      desc = "Leading";
    else if (variable == "MaxPt2")
      desc = "Next-to-Leading";
    else
      desc = variable.substr(5, 6) + "th Leading";
    std::string title = "pT of " + desc + " " + sourceUpper + " " + objType;
    const size_t nBinsStandard = _parametersTurnOn.size() - 1;
    size_t nBins = nBinsStandard;
    float* edges = new float[nBinsStandard + 1];
    for (size_t i = 0; i < nBinsStandard + 1; i++) {
      edges[i] = _parametersTurnOn[i];
    }

    std::string jetObj = EVTColContainer::getTypeString(EVTColContainer::PFJET);
    if (objType == jetObj) {
      const size_t nBinsJets = 25;
      nBins = nBinsJets;
      delete[] edges;
      edges = new float[nBinsJets + 1];
      for (size_t i = 0; i < nBinsJets + 1; i++) {
        edges[i] = i * 10;
      }
    }
    if (objType == EVTColContainer::getTypeString(EVTColContainer::PFMET)) {
      const size_t nBinsJets = 30;
      nBins = nBinsJets;
      delete[] edges;
      edges = new float[nBinsJets + 1];
      for (size_t i = 0; i < nBinsJets + 1; i++) {
        edges[i] = i * 10;
      }
    }
    h = new TH1F(name.c_str(), title.c_str(), nBins, edges);
    delete[] edges;
  } else if (variable == "dEtaqq") {
    std::string title = "#Delta #eta_{qq} of " + sourceUpper + " " + objType;
    int nBins = 20;
    double min = 0;
    double max = 4.8;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else if (variable == "mqq") {
    std::string title = "m_{qq} of " + sourceUpper + " " + objType;
    int nBins = 20;
    double min = 0;
    double max = 1000;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else if (variable == "dPhibb") {
    std::string title = "#Delta #phi_{bb} of " + sourceUpper + " " + objType;
    int nBins = 10;
    double min = 0;
    double max = 3.1416;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else if (variable == "CSV1") {
    std::string title = "CSV1 of " + sourceUpper + " " + objType;
    int nBins = 20;
    double min = 0;
    double max = 1;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else if (variable == "CSV2") {
    std::string title = "CSV2 of " + sourceUpper + " " + objType;
    int nBins = 20;
    double min = 0;
    double max = 1;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else if (variable == "CSV3") {
    std::string title = "CSV3 of " + sourceUpper + " " + objType;
    int nBins = 20;
    double min = 0;
    double max = 1;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else if (variable == "maxCSV") {
    std::string title = "max CSV of " + sourceUpper + " " + objType;
    int nBins = 20;
    double min = 0;
    double max = 1;
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  } else {
    std::string symbol = (variable == "Eta") ? "#eta" : "#phi";
    std::string title = symbol + " of " + sourceUpper + " " + objType;
    std::vector<double> params = (variable == "Eta") ? _parametersEta : _parametersPhi;

    int nBins = (int)params[0];
    double min = params[1];
    double max = params[2];
    h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
  }
  h->Sumw2();
  _elements[name] = ibooker.book1D(name, h);
  delete h;
}

void HLTHiggsSubAnalysis::bookHistograms

(

DQMStore::IBooker &

ibooker

)

Definition at line 262 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _analyzers, _bookHtPlots, _elements, _histDirectory, _hltPathsToCheck, _NminOneCuts, _parametersHt, _parametersPu, _recLabels, _useNminOneCuts, ALCARECODTCalibSynchDQM_cff::baseDir, dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), bookHist(), EVTColContainer::getTypeString(), mps_fire::i, createfilelist::int, dqmiolumiharvest::j, MuonErrorMatrixAnalyzer_cfi::maxPt, MTVHistoProducerAlgoForTrackerBlock_cfi::maxPu, HLT_2018_cff::minHt, MTVHistoProducerAlgoForTrackerBlock_cfi::minPu, NptPlots, castor_dqm_sourceclient_file_cfg::path, EVTColContainer::PFJET, dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), source, CalibrationSummaryClient_cfi::sources, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 {
  std::string baseDir = _histDirectory + "/" + _analysisname + "/";
  ibooker.setCurrentFolder(baseDir);
  // Book the gen/reco analysis-dependent histograms (denominators)
  std::vector<std::string> sources(2);
  sources[0] = "gen";
  sources[1] = "rec";

  for (std::map<unsigned int, std::string>::const_iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
    const std::string objStr = EVTColContainer::getTypeString(it->first);
    TString maxPt;

    for (size_t i = 0; i < sources.size(); i++) {
      std::string source = sources[i];
      if (_useNminOneCuts && it->first == EVTColContainer::PFJET) {
        if (source == "gen")
          continue;
        else {
          // N-1 jet plots (dEtaqq, mqq, dPhibb, CSV1, maxCSV_jets, maxCSV_E, PFMET, pt1, pt2, pt3, pt4)
          if (_NminOneCuts[0])
            bookHist(source, objStr, "dEtaqq", ibooker);
          if (_NminOneCuts[1])
            bookHist(source, objStr, "mqq", ibooker);
          if (_NminOneCuts[2])
            bookHist(source, objStr, "dPhibb", ibooker);
          if (_NminOneCuts[3]) {
            if (_NminOneCuts[6])
              bookHist(source, objStr, "maxCSV", ibooker);
            else
              bookHist(source, objStr, "CSV1", ibooker);
          }
          if (_NminOneCuts[4])
            bookHist(source, objStr, "CSV2", ibooker);
          if (_NminOneCuts[5])
            bookHist(source, objStr, "CSV3", ibooker);
        }
      }

      bookHist(source, objStr, "Eta", ibooker);
      bookHist(source, objStr, "Phi", ibooker);
      for (unsigned int i = 0; i < NptPlots; i++) {
        maxPt = "MaxPt";
        maxPt += i + 1;
        bookHist(source, objStr, maxPt.Data(), ibooker);
      }
    }
  }

  // Call the bookHistograms (which books all the path dependent histograms)
  for (std::vector<HLTHiggsPlotter>::iterator it = _analyzers.begin(); it != _analyzers.end(); ++it) {
    it->bookHistograms(ibooker, _useNminOneCuts);
  }
  //booking the histograms for overall trigger efficiencies
  for (size_t i = 0; i < sources.size(); i++) {
    std::string nameGlobalEfficiency = "SummaryPaths_" + _analysisname + "_" + sources[i];

    _elements[nameGlobalEfficiency] = ibooker.book1D(
        nameGlobalEfficiency.c_str(), nameGlobalEfficiency.c_str(), _hltPathsToCheck.size(), 0, _hltPathsToCheck.size());

    std::string nameGlobalEfficiencyPassing = nameGlobalEfficiency + "_passingHLT";
    _elements[nameGlobalEfficiencyPassing] = ibooker.book1D(nameGlobalEfficiencyPassing.c_str(),
                                                            nameGlobalEfficiencyPassing.c_str(),
                                                            _hltPathsToCheck.size(),
                                                            0,
                                                            _hltPathsToCheck.size());

    std::string titlePu = "nb of interations in the event";
    std::string nameVtxPlot = "trueVtxDist_" + _analysisname + "_" + sources[i];
    std::vector<double> paramsPu = _parametersPu;
    int nBinsPu = (int)paramsPu[0];
    double minPu = paramsPu[1];
    double maxPu = paramsPu[2];

    std::string titleHt = "sum of jet pT in the event";
    std::string nameHtPlot = "HtDist_" + _analysisname + "_" + sources[i];
    std::vector<double> paramsHt = _parametersHt;
    int nBinsHt = (int)paramsHt[0];
    double minHt = paramsHt[1];
    double maxHt = paramsHt[2];

    if ((!_useNminOneCuts) || sources[i] == "rec")
      _elements[nameVtxPlot] = ibooker.book1D(nameVtxPlot.c_str(), titlePu.c_str(), nBinsPu, minPu, maxPu);
    if (_bookHtPlots)
      _elements[nameHtPlot] = ibooker.book1D(nameHtPlot.c_str(), titleHt.c_str(), nBinsHt, minHt, maxHt);
    for (size_t j = 0; j < _hltPathsToCheck.size(); j++) {
      //declare the efficiency vs interaction plots
      std::string path = _hltPathsToCheck[j];
      std::string shortpath = path;
      if (path.rfind("_v") < path.length()) {
        shortpath = path.substr(0, path.rfind("_v"));
      }
      std::string titlePassingPu = "nb of interations in the event passing path " + shortpath;
      if ((!_useNminOneCuts) || sources[i] == "rec")
        _elements[nameVtxPlot + "_" + shortpath] =
            ibooker.book1D(nameVtxPlot + "_" + shortpath, titlePassingPu.c_str(), nBinsPu, minPu, maxPu);

      std::string titlePassingHt = "sum of jet pT in the event passing path " + shortpath;
      if (_bookHtPlots)
        _elements[nameHtPlot + "_" + shortpath] =
            ibooker.book1D(nameHtPlot + "_" + shortpath, titlePassingHt.c_str(), nBinsHt, minHt, maxHt);

      //fill the bin labels of the summary plot
      _elements[nameGlobalEfficiency]->setBinLabel(j + 1, shortpath);
      _elements[nameGlobalEfficiencyPassing]->setBinLabel(j + 1, shortpath);
    }
  }
}

void HLTHiggsSubAnalysis::bookobjects ( const edm::ParameterSet &  anpset, edm::ConsumesCollector &  iC  )

private

Definition at line 744 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _genJetSelector, _genSelectorMap, _recLabels, _recLabelsCaloMET, _recLabelsElec, _recLabelsMuon, _recLabelsPFJet, _recLabelsPFMET, _recLabelsPFTau, _recLabelsPhoton, _recTagPFJet, EVTColContainer::CALOMET, edm::ConsumesCollector::consumes(), EVTColContainer::ELEC, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), EVTColContainer::MUON, EVTColContainer::PFJET, EVTColContainer::PFMET, EVTColContainer::PFTAU, EVTColContainer::PHOTON, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by HLTHiggsSubAnalysis().

                                                                                             {
  if (anpset.exists("recMuonLabel")) {
    _recLabels[EVTColContainer::MUON] = anpset.getParameter<std::string>("recMuonLabel");
    _recLabelsMuon = iC.consumes<reco::MuonCollection>(anpset.getParameter<std::string>("recMuonLabel"));
    _genSelectorMap[EVTColContainer::MUON] = nullptr;
  }
  if (anpset.exists("recElecLabel")) {
    _recLabels[EVTColContainer::ELEC] = anpset.getParameter<std::string>("recElecLabel");
    _recLabelsElec = iC.consumes<reco::GsfElectronCollection>(anpset.getParameter<std::string>("recElecLabel"));
    _genSelectorMap[EVTColContainer::ELEC] = nullptr;
  }
  if (anpset.exists("recPhotonLabel")) {
    _recLabels[EVTColContainer::PHOTON] = anpset.getParameter<std::string>("recPhotonLabel");
    _recLabelsPhoton = iC.consumes<reco::PhotonCollection>(anpset.getParameter<std::string>("recPhotonLabel"));
    _genSelectorMap[EVTColContainer::PHOTON] = nullptr;
  }
  if (anpset.exists("recCaloMETLabel")) {
    _recLabels[EVTColContainer::CALOMET] = anpset.getParameter<std::string>("recCaloMETLabel");
    _recLabelsCaloMET = iC.consumes<reco::CaloMETCollection>(anpset.getParameter<std::string>("recCaloMETLabel"));
    _genSelectorMap[EVTColContainer::CALOMET] = nullptr;
  }
  if (anpset.exists("recPFMETLabel")) {
    _recLabels[EVTColContainer::PFMET] = anpset.getParameter<std::string>("recPFMETLabel");
    _recLabelsPFMET = iC.consumes<reco::PFMETCollection>(anpset.getParameter<std::string>("recPFMETLabel"));
    _genSelectorMap[EVTColContainer::PFMET] = nullptr;
  }
  if (anpset.exists("recPFTauLabel")) {
    _recLabels[EVTColContainer::PFTAU] = anpset.getParameter<std::string>("recPFTauLabel");
    _recLabelsPFTau = iC.consumes<reco::PFTauCollection>(anpset.getParameter<std::string>("recPFTauLabel"));
    _genSelectorMap[EVTColContainer::PFTAU] = nullptr;
  }
  if (anpset.exists("recJetLabel")) {
    _recLabels[EVTColContainer::PFJET] = anpset.getParameter<std::string>("recJetLabel");
    _recLabelsPFJet = iC.consumes<reco::PFJetCollection>(anpset.getParameter<std::string>("recJetLabel"));
    if (anpset.exists("jetTagLabel"))
      _recTagPFJet = iC.consumes<reco::JetTagCollection>(anpset.getParameter<std::string>("jetTagLabel"));
    _genJetSelector = nullptr;
  }
  /*if( anpset.exists("recTrackLabel") )
    {
        _recLabels[EVTColContainer::TRACK] = anpset.getParameter<std::string>("recTrackLabel");
        _genSelectorMap[EVTColContainer::TRACK] = 0 ;
    }*/

  if (_recLabels.empty()) {
    edm::LogError("HiggsValidation") << "HLTHiggsSubAnalysis::bookobjects, "
                                     << "Not included any object (recMuonLabel, recElecLabel, ...)  "
                                     << "in the analysis " << _analysisname;
    return;
  }
}

void HLTHiggsSubAnalysis::fillHist ( const std::string &  source, const std::string &  objType, const std::string &  variable, const float &  value  )

private

Definition at line 965 of file HLTHiggsSubAnalysis.cc.

References _elements, Skims_PA_cff::name, source, AlCaHLTBitMon_QueryRunRegistry::string, and taus_updatedMVAIds_cff::variable.

Referenced by analyze().

                                                       {
  std::string sourceUpper = source;
  sourceUpper[0] = toupper(sourceUpper[0]);
  std::string name = source + objType + variable;

  _elements[name]->Fill(value);
}

const std::vector< unsigned int > HLTHiggsSubAnalysis::getObjectsType

(

const std::string &

hltpath

)

const

Extract what objects need this analysis.

Definition at line 702 of file HLTHiggsSubAnalysis.cc.

References EVTColContainer::CALOMET, EVTColContainer::ELEC, EVTColContainer::getTypeString(), mps_fire::i, EVTColContainer::MUON, EVTColContainer::PFJET, EVTColContainer::PFMET, EVTColContainer::PFTAU, EVTColContainer::PHOTON, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginRun().

                                                                                                {
  static const unsigned int objSize = 7;
  static const unsigned int objtriggernames[] = {EVTColContainer::MUON,
                                                 EVTColContainer::ELEC,
                                                 EVTColContainer::PHOTON,
                                                 //      EVTColContainer::TRACK,  // Note is tracker muon
                                                 EVTColContainer::PFTAU,
                                                 EVTColContainer::PFJET,
                                                 EVTColContainer::CALOMET,
                                                 EVTColContainer::PFMET};

  std::set<unsigned int> objsType;
  // The object to deal has to be entered via the config .py
  for (unsigned int i = 0; i < objSize; ++i) {
    std::string objTypeStr = EVTColContainer::getTypeString(objtriggernames[i]);
    // Check if it is needed this object for this trigger
    if (!TString(hltPath).Contains(objTypeStr)) {
      if ((objtriggernames[i] == EVTColContainer::PFJET &&
           TString(hltPath).Contains("WHbbBoost")) ||  // fix for HLT_Ele27_WPLoose_Gsf_WHbbBoost_v
          (objtriggernames[i] == EVTColContainer::PFJET && TString(hltPath).Contains("CSV")) ||  // fix for ZnnHbb PFJET
          (objtriggernames[i] == EVTColContainer::PFMET && TString(hltPath).Contains("MHT")) ||  // fix for ZnnHbb PFMET
          (objtriggernames[i] == EVTColContainer::PHOTON && TString(hltPath).Contains("Diphoton"))) {
        objsType.insert(objtriggernames[i]);  //case of the New Diphoton paths
      }
      continue;
    }
    if ((objtriggernames[i] == EVTColContainer::CALOMET &&
         (TString(hltPath).Contains("PFMET") || TString(hltPath).Contains("MHT"))) ||  // fix for PFMET
        (objtriggernames[i] == EVTColContainer::PFJET && TString(hltPath).Contains("JetIdCleaned") &&
         !TString(hltPath).Contains(TRegexp("Jet[^I]"))) ||                                     // fix for Htaunu
        (objtriggernames[i] == EVTColContainer::MUON && TString(hltPath).Contains("METNoMu")))  // fix for VBFHToInv
    {
      continue;
    }

    objsType.insert(objtriggernames[i]);
  }

  return std::vector<unsigned int>(objsType.begin(), objsType.end());
}

void HLTHiggsSubAnalysis::initAndInsertJets ( const edm::Event &  iEvent, EVTColContainer *  cols, std::vector< MatchStruct > *  matches  )

private

Definition at line 1003 of file HLTHiggsSubAnalysis.cc.

References _recLabelsPFJet, _recPFJetSelector, _recTagPFJet, _useNminOneCuts, TtFullHadHypKinFit_cfi::bTag, edm::Event::getByToken(), EVTColContainer::PFJET, edm::Handle< T >::product(), and EVTColContainer::set().

Referenced by analyze().

                                                                             {
  edm::Handle<reco::PFJetCollection> PFJetHandle;
  iEvent.getByToken(_recLabelsPFJet, PFJetHandle);
  cols->set(PFJetHandle.product());

  edm::Handle<reco::JetTagCollection> JetTagHandle;
  if (_useNminOneCuts) {
    iEvent.getByToken(_recTagPFJet, JetTagHandle);
  }

  for (reco::PFJetCollection::const_iterator it = PFJetHandle->begin(); it != PFJetHandle->end(); ++it) {
    reco::PFJetRef jetRef(PFJetHandle, it - PFJetHandle->begin());
    reco::JetBaseRef jetBaseRef(jetRef);

    if (_recPFJetSelector->operator()(*it)) {
      if (_useNminOneCuts) {
        float bTag = (*(JetTagHandle.product()))[jetBaseRef];
        matches->push_back(MatchStruct(&*it, EVTColContainer::PFJET, bTag));
      } else {
        matches->push_back(MatchStruct(&*it, EVTColContainer::PFJET));
      }
    }
  }
}

void HLTHiggsSubAnalysis::initobjects ( const edm::Event &  iEvent, EVTColContainer *  col  )

private

Definition at line 796 of file HLTHiggsSubAnalysis.cc.

References _genJetLabel, _genParticleLabel, _recLabels, _recLabelsCaloMET, _recLabelsElec, _recLabelsMuon, _recLabelsPFMET, _recLabelsPFTau, _recLabelsPhoton, _trigResultsTag, _useNminOneCuts, EVTColContainer::CALOMET, EVTColContainer::ELEC, EVTColContainer::genJets, EVTColContainer::genParticles, edm::Event::getByToken(), EVTColContainer::isCommonInit(), edm::HandleBase::isValid(), EVTColContainer::MUON, EVTColContainer::PFJET, EVTColContainer::PFMET, EVTColContainer::PFTAU, EVTColContainer::PHOTON, edm::Handle< T >::product(), EVTColContainer::set(), and EVTColContainer::triggerResults.

Referenced by analyze().

                                                                                  {
  /*if( col != 0 && col->isAllInit() )
    {
        // Already init, not needed to do nothing
        return;
    }*/
  if (!col->isCommonInit()) {
    // extract the trigger results (path info, pass,...)
    edm::Handle<edm::TriggerResults> trigResults;
    iEvent.getByToken(_trigResultsTag, trigResults);
    if (trigResults.isValid()) {
      col->triggerResults = trigResults.product();
    }

    // GenParticle collection if is there (genJets only if there need to be jets)
    edm::Handle<reco::GenParticleCollection> genPart;
    iEvent.getByToken(_genParticleLabel, genPart);
    if (genPart.isValid()) {
      col->genParticles = genPart.product();
    }
  }

  for (std::map<unsigned int, std::string>::iterator it = _recLabels.begin(); it != _recLabels.end(); ++it) {
    if (it->first == EVTColContainer::MUON) {
      edm::Handle<reco::MuonCollection> theHandle;
      iEvent.getByToken(_recLabelsMuon, theHandle);
      col->set(theHandle.product());
    } else if (it->first == EVTColContainer::ELEC) {
      edm::Handle<reco::GsfElectronCollection> theHandle;
      iEvent.getByToken(_recLabelsElec, theHandle);
      col->set(theHandle.product());
    } else if (it->first == EVTColContainer::PHOTON) {
      edm::Handle<reco::PhotonCollection> theHandle;
      iEvent.getByToken(_recLabelsPhoton, theHandle);
      col->set(theHandle.product());
    } else if (it->first == EVTColContainer::CALOMET) {
      edm::Handle<reco::CaloMETCollection> theHandle;
      iEvent.getByToken(_recLabelsCaloMET, theHandle);
      col->set(theHandle.product());
    } else if (it->first == EVTColContainer::PFMET) {
      edm::Handle<reco::PFMETCollection> theHandle;
      iEvent.getByToken(_recLabelsPFMET, theHandle);
      col->set(theHandle.product());
    } else if (it->first == EVTColContainer::PFTAU) {
      edm::Handle<reco::PFTauCollection> theHandle;
      iEvent.getByToken(_recLabelsPFTau, theHandle);
      col->set(theHandle.product());
    }
    // PFJets loaded in seperate function initAndInsertJets because they need to be combined with the btags using the Handle (not the product) and for ordering them seperately in the MatchStruct's
    else if (it->first == EVTColContainer::PFJET) {
      if (!_useNminOneCuts) {
        // GenJet collection
        edm::Handle<reco::GenJetCollection> genJet;
        iEvent.getByToken(_genJetLabel, genJet);
        if (genJet.isValid()) {
          col->genJets = genJet.product();
        }
      }
    } else {
      edm::LogError("HiggsValidation") << "HLTHiggsSubAnalysis::initobjects "
                                       << " NOT IMPLEMENTED (yet) ERROR: '" << it->second << "'";
      //return; ??
    }
  }
}

void HLTHiggsSubAnalysis::InitSelector ( const unsigned int &  objtype )

private

Definition at line 977 of file HLTHiggsSubAnalysis.cc.

References _recCaloMETSelector, _recCut, _recElecSelector, _recMuonSelector, _recPFJetSelector, _recPFMETSelector, _recPFTauSelector, _recPhotonSelector, EVTColContainer::CALOMET, EVTColContainer::ELEC, EVTColContainer::MUON, EVTColContainer::PFJET, EVTColContainer::PFMET, EVTColContainer::PFTAU, and EVTColContainer::PHOTON.

Referenced by analyze().

                                                                  {
  if (objtype == EVTColContainer::MUON && _recMuonSelector == nullptr) {
    _recMuonSelector = new StringCutObjectSelector<reco::Muon>(_recCut[objtype]);
  } else if (objtype == EVTColContainer::ELEC && _recElecSelector == nullptr) {
    _recElecSelector = new StringCutObjectSelector<reco::GsfElectron>(_recCut[objtype]);
  } else if (objtype == EVTColContainer::PHOTON && _recPhotonSelector == nullptr) {
    _recPhotonSelector = new StringCutObjectSelector<reco::Photon>(_recCut[objtype]);
  } else if (objtype == EVTColContainer::CALOMET && _recCaloMETSelector == nullptr) {
    _recCaloMETSelector = new StringCutObjectSelector<reco::CaloMET>(_recCut[objtype]);
  } else if (objtype == EVTColContainer::PFMET && _recPFMETSelector == nullptr) {
    _recPFMETSelector = new StringCutObjectSelector<reco::PFMET>(_recCut[objtype]);
  } else if (objtype == EVTColContainer::PFTAU && _recPFTauSelector == nullptr) {
    _recPFTauSelector = new StringCutObjectSelector<reco::PFTau>(_recCut[objtype]);
  } else if (objtype == EVTColContainer::PFJET && _recPFJetSelector == nullptr) {
    _recPFJetSelector = new StringCutObjectSelector<reco::PFJet>(_recCut[objtype]);
  }
  /*else if( objtype == EVTColContainer::TRACK && _recTrackSelector == 0)
    {
        _recTrackSelector = new StringCutObjectSelector<reco::Track>(_recCut[objtype]);
    }*/
  /*  else
    {
FIXME: ERROR NO IMPLEMENTADO
    }*/
}

void HLTHiggsSubAnalysis::insertcandidates ( const unsigned int &  objtype, const EVTColContainer *  col, std::vector< MatchStruct > *  matches  )

private

Definition at line 1145 of file HLTHiggsSubAnalysis.cc.

References _recCaloMETSelector, _recElecSelector, _recMuonSelector, _recPFMETSelector, _recPFTauSelector, _recPhotonSelector, EVTColContainer::CALOMET, EVTColContainer::caloMETs, EVTColContainer::ELEC, EVTColContainer::electrons, mps_fire::i, EVTColContainer::MUON, EVTColContainer::muons, electrons_cff::objType, EVTColContainer::PFMET, EVTColContainer::pfMETs, EVTColContainer::PFTAU, EVTColContainer::pfTaus, EVTColContainer::PHOTON, and EVTColContainer::photons.

Referenced by analyze().

                                                                            {
  if (objType == EVTColContainer::MUON) {
    for (size_t i = 0; i < cols->muons->size(); i++) {
      if (_recMuonSelector->operator()(cols->muons->at(i))) {
        matches->push_back(MatchStruct(&cols->muons->at(i), objType));
      }
    }
  } else if (objType == EVTColContainer::ELEC) {
    for (size_t i = 0; i < cols->electrons->size(); i++) {
      if (_recElecSelector->operator()(cols->electrons->at(i))) {
        matches->push_back(MatchStruct(&cols->electrons->at(i), objType));
      }
    }
  } else if (objType == EVTColContainer::PHOTON) {
    for (size_t i = 0; i < cols->photons->size(); i++) {
      if (_recPhotonSelector->operator()(cols->photons->at(i))) {
        matches->push_back(MatchStruct(&cols->photons->at(i), objType));
      }
    }
  } else if (objType == EVTColContainer::CALOMET) {
    for (size_t i = 0; i < cols->caloMETs->size(); i++) {
      if (_recCaloMETSelector->operator()(cols->caloMETs->at(i))) {
        matches->push_back(MatchStruct(&cols->caloMETs->at(i), objType));
      }
    }
  } else if (objType == EVTColContainer::PFMET) {
    for (size_t i = 0; i < cols->pfMETs->size(); i++) {
      if (_recPFMETSelector->operator()(cols->pfMETs->at(i))) {
        matches->push_back(MatchStruct(&cols->pfMETs->at(i), objType));
      }
    }
  } else if (objType == EVTColContainer::PFTAU) {
    for (size_t i = 0; i < cols->pfTaus->size(); i++) {
      if (_recPFTauSelector->operator()(cols->pfTaus->at(i))) {
        matches->push_back(MatchStruct(&cols->pfTaus->at(i), objType));
      }
    }
  }
  //  else if( objType == EVTColContainer::PFJET )
  //  {
  //  already inserted
  //  }
  /*else if( objType == EVTColContainer::TRACK )
    {
        for(size_t i = 0; i < cols->tracks->size(); i++)
        {
            if(_recTrackSelector->operator()(cols->tracks->at(i)))
            {
                matches->push_back(MatchStruct(&cols->tracks->at(i),objType));
            }
        }
    }*/
  /*
    else FIXME: Control errores
    {
    }
    */
}

void HLTHiggsSubAnalysis::passJetCuts ( std::vector< MatchStruct > *  matches, std::map< std::string, bool > &  jetCutResult, float &  dEtaqq, float &  mqq, float &  dPhibb, float &  CSV1, float &  CSV2, float &  CSV3  )

private

Definition at line 1030 of file HLTHiggsSubAnalysis.cc.

References _NminOneCuts, PVValHelper::eta, mps_fire::i, createfilelist::int, MuonErrorMatrixAnalyzer_cfi::maxPt, ECF_cff::Njets, NptPlots, phi, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                 {  //dEtaqq, mqq, dPhibb, CSV1, CSV2, CSV3, maxCSV_jets, maxCSV_E, PFMET, pt1, pt2, pt3, pt4

  // Perform pt cuts
  std::sort(matches->begin(), matches->end(), matchesByDescendingPt());
  TString maxPt;
  for (unsigned int i = 0; i < NptPlots; i++) {
    maxPt = "MaxPt";
    maxPt += i + 1;
    if ((*matches)[i].pt > _NminOneCuts[9 + i])
      jetCutResult[maxPt.Data()] = true;
    else
      jetCutResult[maxPt.Data()] = false;
  }

  unsigned int NbTag = ((_NminOneCuts[0] || _NminOneCuts[1]) ? 4 : 8);
  if (matches->size() < NbTag)
    NbTag = matches->size();
  // Perform b-tag ordered cuts
  std::sort(matches->begin(), matches->begin() + NbTag, matchesByDescendingBtag());

  if (_NminOneCuts[0]) {
    jetCutResult["dEtaqq"] = false;
    if (matches->size() > 2) {
      dEtaqq = fabs((*matches)[2].eta - (*matches)[3].eta);
      if (dEtaqq > _NminOneCuts[0])
        jetCutResult["dEtaqq"] = true;
    }
  }

  if (_NminOneCuts[1]) {
    jetCutResult["mqq"] = false;
    if (matches->size() > 2) {
      mqq = ((*matches)[2].lorentzVector + (*matches)[3].lorentzVector).M();
      if (mqq > _NminOneCuts[1])
        jetCutResult["mqq"] = true;
    }
  }

  if (_NminOneCuts[2]) {
    jetCutResult["dPhibb"] = false;
    if (matches->size() > 1) {
      dPhibb = fmod(fabs((*matches)[0].phi - (*matches)[1].phi), 3.1416);
      if (dPhibb < _NminOneCuts[2])
        jetCutResult["dPhibb"] = true;
    }
  }

  if (_NminOneCuts[4]) {
    std::string nameCSV2plot = "CSV2";
    jetCutResult[nameCSV2plot] = false;
    if (matches->size() > 1) {
      CSV2 = (*matches)[1].bTag;
      if (CSV2 > _NminOneCuts[4])
        jetCutResult[nameCSV2plot] = true;
    }
  }

  if (_NminOneCuts[5]) {
    std::string nameCSV3plot = "CSV3";
    jetCutResult[nameCSV3plot] = false;
    if (matches->size() > 2) {
      CSV3 = (*matches)[2].bTag;
      if (CSV3 > _NminOneCuts[5])
        jetCutResult[nameCSV3plot] = true;
    }
  }

  if (_NminOneCuts[3]) {
    CSV1 = (*matches)[0].bTag;
    std::string nameCSVplot = "CSV1";
    if (_NminOneCuts[6])
      nameCSVplot = "maxCSV";

    if (CSV1 > _NminOneCuts[3])
      jetCutResult[nameCSVplot] = true;
    else
      jetCutResult[nameCSVplot] = false;

    // max(CSV)
    if (_NminOneCuts[6]) {
      std::sort(matches->begin(), matches->end(), matchesByDescendingPt());
      CSV1 = (*matches)[0].bTag;
      unsigned int Njets = (unsigned int)_NminOneCuts[6];
      if (_NminOneCuts[6] > matches->size())
        Njets = matches->size();
      for (unsigned int i = 1; i < (unsigned int)Njets; ++i) {
        if ((*matches)[i].bTag > CSV1 && (*matches)[i].pt > _NminOneCuts[7])
          CSV1 = (*matches)[i].bTag;
      }
    }
  }
}

void HLTHiggsSubAnalysis::passOtherCuts ( const std::vector< MatchStruct > &  matches, std::map< std::string, bool > &  jetCutResult  )

private

Definition at line 1131 of file HLTHiggsSubAnalysis.cc.

References _NminOneCuts, and EVTColContainer::PFMET.

Referenced by analyze().

                                                                               {
  if (_NminOneCuts[8]) {
    jetCutResult["PFMET"] = false;
    for (std::vector<MatchStruct>::const_iterator it = matches.begin(); it != matches.end(); ++it) {
      if (it->objType == EVTColContainer::PFMET) {
        if (it->pt > _NminOneCuts[8])
          jetCutResult["PFMET"] = true;
        break;
      }
    }
  }
}

Member Data Documentation

std::string HLTHiggsSubAnalysis::_analysisname

private

Definition at line 97 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), beginRun(), bookHistograms(), bookobjects(), and HLTHiggsSubAnalysis().

std::vector<HLTHiggsPlotter> HLTHiggsSubAnalysis::_analyzers

private

Definition at line 170 of file HLTHiggsSubAnalysis.h.

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

bool HLTHiggsSubAnalysis::_bookHtPlots

private

Definition at line 105 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), bookHistograms(), and HLTHiggsSubAnalysis().

std::map<unsigned int, double> HLTHiggsSubAnalysis::_cutMaxEta

private

Definition at line 144 of file HLTHiggsSubAnalysis.h.

Referenced by HLTHiggsSubAnalysis().

std::map<unsigned int, double> HLTHiggsSubAnalysis::_cutMinPt

private

Definition at line 143 of file HLTHiggsSubAnalysis.h.

Referenced by HLTHiggsSubAnalysis().

std::map<unsigned int, unsigned int> HLTHiggsSubAnalysis::_cutMotherId

private

Definition at line 145 of file HLTHiggsSubAnalysis.h.

std::map<unsigned int, std::vector<double> > HLTHiggsSubAnalysis::_cutsDr

private

Definition at line 146 of file HLTHiggsSubAnalysis.h.

std::map<std::string, MonitorElement *> HLTHiggsSubAnalysis::_elements

private

Definition at line 173 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), bookHist(), bookHistograms(), and fillHist().

std::map<unsigned int, std::string> HLTHiggsSubAnalysis::_genCut

private

gen/rec objects cuts

Definition at line 148 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

edm::EDGetTokenT<reco::GenJetCollection> HLTHiggsSubAnalysis::_genJetLabel

private

Definition at line 121 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and initobjects().

StringCutObjectSelector<reco::GenJet>* HLTHiggsSubAnalysis::_genJetSelector

private

Definition at line 154 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), bookobjects(), and ~HLTHiggsSubAnalysis().

edm::EDGetTokenT<reco::GenParticleCollection> HLTHiggsSubAnalysis::_genParticleLabel

private

Definition at line 120 of file HLTHiggsSubAnalysis.h.

Referenced by initobjects().

std::map<unsigned int, StringCutObjectSelector<reco::GenParticle> *> HLTHiggsSubAnalysis::_genSelectorMap

private

The concrete String selectors (use the string cuts introduced via the config python)

Definition at line 153 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), bookobjects(), and ~HLTHiggsSubAnalysis().

std::string HLTHiggsSubAnalysis::_histDirectory

private

Definition at line 108 of file HLTHiggsSubAnalysis.h.

Referenced by bookHistograms().

HLTConfigProvider HLTHiggsSubAnalysis::_hltConfig

private

Definition at line 172 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

std::set<std::string> HLTHiggsSubAnalysis::_hltPaths

private

the hlt paths found in the hltConfig

Definition at line 113 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

std::vector<std::string> HLTHiggsSubAnalysis::_hltPathsToCheck

private

the hlt paths with regular expressions

Definition at line 111 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), beginRun(), bookHistograms(), and HLTHiggsSubAnalysis().

std::string HLTHiggsSubAnalysis::_hltProcessName

private

Definition at line 107 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

double HLTHiggsSubAnalysis::_HtJetEtaMax

private

Definition at line 103 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

double HLTHiggsSubAnalysis::_HtJetPtMin

private

Definition at line 102 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

unsigned int HLTHiggsSubAnalysis::_minCandidates

private

The minimum number of reco/gen candidates needed by the analysis.

Definition at line 100 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

std::vector<double> HLTHiggsSubAnalysis::_NminOneCuts

private

Definition at line 165 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), beginRun(), bookHistograms(), HLTHiggsSubAnalysis(), passJetCuts(), and passOtherCuts().

std::vector<double> HLTHiggsSubAnalysis::_parametersEta

private

Some kinematical parameters.

Definition at line 136 of file HLTHiggsSubAnalysis.h.

Referenced by bookHist().

std::vector<double> HLTHiggsSubAnalysis::_parametersHt

private

Definition at line 139 of file HLTHiggsSubAnalysis.h.

Referenced by bookHistograms(), and HLTHiggsSubAnalysis().

std::vector<double> HLTHiggsSubAnalysis::_parametersPhi

private

Definition at line 137 of file HLTHiggsSubAnalysis.h.

Referenced by bookHist().

std::vector<double> HLTHiggsSubAnalysis::_parametersPu

private

Definition at line 138 of file HLTHiggsSubAnalysis.h.

Referenced by bookHistograms().

std::vector<double> HLTHiggsSubAnalysis::_parametersTurnOn

private

Definition at line 140 of file HLTHiggsSubAnalysis.h.

Referenced by bookHist(), and HLTHiggsSubAnalysis().

edm::ParameterSet HLTHiggsSubAnalysis::_pset

private

Definition at line 95 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun(), and HLTHiggsSubAnalysis().

edm::EDGetTokenT<std::vector<PileupSummaryInfo> > HLTHiggsSubAnalysis::_puSummaryInfo

private

Definition at line 133 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

StringCutObjectSelector<reco::CaloMET>* HLTHiggsSubAnalysis::_recCaloMETSelector

private

Definition at line 157 of file HLTHiggsSubAnalysis.h.

Referenced by InitSelector(), insertcandidates(), and ~HLTHiggsSubAnalysis().

std::map<unsigned int, std::string> HLTHiggsSubAnalysis::_recCut

private

Definition at line 149 of file HLTHiggsSubAnalysis.h.

Referenced by HLTHiggsSubAnalysis(), and InitSelector().

StringCutObjectSelector<reco::GsfElectron>* HLTHiggsSubAnalysis::_recElecSelector

private

Definition at line 156 of file HLTHiggsSubAnalysis.h.

Referenced by InitSelector(), insertcandidates(), and ~HLTHiggsSubAnalysis().

std::map<unsigned int, std::string> HLTHiggsSubAnalysis::_recLabels

private

Definition at line 124 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), beginRun(), bookHistograms(), bookobjects(), HLTHiggsSubAnalysis(), and initobjects().

edm::EDGetTokenT<reco::CaloMETCollection> HLTHiggsSubAnalysis::_recLabelsCaloMET

private

Definition at line 128 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

edm::EDGetTokenT<reco::GsfElectronCollection> HLTHiggsSubAnalysis::_recLabelsElec

private

Definition at line 126 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

edm::EDGetTokenT<reco::MuonCollection> HLTHiggsSubAnalysis::_recLabelsMuon

private

Definition at line 125 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

edm::EDGetTokenT<reco::PFJetCollection> HLTHiggsSubAnalysis::_recLabelsPFJet

private

Definition at line 131 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initAndInsertJets().

edm::EDGetTokenT<reco::PFMETCollection> HLTHiggsSubAnalysis::_recLabelsPFMET

private

Definition at line 129 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

edm::EDGetTokenT<reco::PFTauCollection> HLTHiggsSubAnalysis::_recLabelsPFTau

private

Definition at line 130 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

edm::EDGetTokenT<reco::PhotonCollection> HLTHiggsSubAnalysis::_recLabelsPhoton

private

Definition at line 127 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

StringCutObjectSelector<reco::Muon>* HLTHiggsSubAnalysis::_recMuonSelector

private

Definition at line 155 of file HLTHiggsSubAnalysis.h.

Referenced by InitSelector(), insertcandidates(), and ~HLTHiggsSubAnalysis().

edm::EDGetTokenT<reco::PFJetCollection> HLTHiggsSubAnalysis::_recoHtJetLabel

private

Definition at line 122 of file HLTHiggsSubAnalysis.h.

Referenced by analyze().

StringCutObjectSelector<reco::PFJet>* HLTHiggsSubAnalysis::_recPFJetSelector

private

Definition at line 161 of file HLTHiggsSubAnalysis.h.

Referenced by initAndInsertJets(), InitSelector(), and ~HLTHiggsSubAnalysis().

StringCutObjectSelector<reco::PFMET>* HLTHiggsSubAnalysis::_recPFMETSelector

private

Definition at line 158 of file HLTHiggsSubAnalysis.h.

Referenced by InitSelector(), insertcandidates(), and ~HLTHiggsSubAnalysis().

StringCutObjectSelector<reco::PFTau>* HLTHiggsSubAnalysis::_recPFTauSelector

private

Definition at line 159 of file HLTHiggsSubAnalysis.h.

Referenced by InitSelector(), insertcandidates(), and ~HLTHiggsSubAnalysis().

StringCutObjectSelector<reco::Photon>* HLTHiggsSubAnalysis::_recPhotonSelector

private

Definition at line 160 of file HLTHiggsSubAnalysis.h.

Referenced by InitSelector(), insertcandidates(), and ~HLTHiggsSubAnalysis().

edm::EDGetTokenT<reco::JetTagCollection> HLTHiggsSubAnalysis::_recTagPFJet

private

Definition at line 132 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initAndInsertJets().

StringCutObjectSelector<reco::Track>* HLTHiggsSubAnalysis::_recTrackSelector

private

Definition at line 162 of file HLTHiggsSubAnalysis.h.

Referenced by ~HLTHiggsSubAnalysis().

std::map<std::string, std::string> HLTHiggsSubAnalysis::_shortpath2long

private

Relation between the short version of a path.

Definition at line 116 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and beginRun().

edm::EDGetTokenT<edm::TriggerResults> HLTHiggsSubAnalysis::_trigResultsTag

private

Definition at line 141 of file HLTHiggsSubAnalysis.h.

Referenced by initobjects().

bool HLTHiggsSubAnalysis::_useNminOneCuts

private

Definition at line 166 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), bookHistograms(), HLTHiggsSubAnalysis(), initAndInsertJets(), and initobjects().

unsigned int HLTHiggsSubAnalysis::NptPlots

private

Definition at line 167 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), beginRun(), bookHistograms(), HLTHiggsSubAnalysis(), and passJetCuts().