HLTHiggsSubAnalysis Class Reference

#include <HLTHiggsSubAnalysis.h>

Public Types
enum	{ GEN, RECO }

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 61 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 31 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _bookHtPlots, _cutMaxEta, _cutMinPt, _genCut, _hltPathsToCheck, _HtJetEtaMax, _HtJetPtMin, _minCandidates, _NminOneCuts, _parametersHt, _puSummaryInfo, _recCut, _recLabels, _useNminOneCuts, bookobjects(), edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), cmsRelvalreport::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(0),
    _recMuonSelector(0),
    _recElecSelector(0),
    _recCaloMETSelector(0),
    _recPFMETSelector(0),
    _recPFTauSelector(0),
    _recPhotonSelector(0),
    _recPFJetSelector(0),
    _recTrackSelector(0),
    _NminOneCuts(0),
    _useNminOneCuts(0)
{
    // Specific parameters for this analysis
    edm::ParameterSet anpset = pset.getParameter<edm::ParameterSet>(analysisname);
    // Collections labels (but genparticles already initialized) 
    // initializing _recLabels data member)
    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);
        }
        for(std::vector<double>::const_iterator it = _NminOneCuts.begin(); it != _NminOneCuts.end(); ++it)
        {
            if( *it ) {
                _useNminOneCuts = true;
                break;
            }
        }
    }
    NptPlots = ( _useNminOneCuts ? _minCandidates : 2 );
}

HLTHiggsSubAnalysis::~HLTHiggsSubAnalysis

(

)

Definition at line 141 of file HLTHiggsSubAnalysis.cc.

References _genJetSelector, _genSelectorMap, _recCaloMETSelector, _recElecSelector, _recMuonSelector, _recPFJetSelector, _recPFMETSelector, _recPFTauSelector, _recPhotonSelector, _recTrackSelector, and python.multivaluedict::map().

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

Member Function Documentation

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

Definition at line 363 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(), eta(), fillHist(), GEN, EVTColContainer::genJets, EVTColContainer::genParticles, edm::Event::getByToken(), EVTColContainer::getTypeString(), i, initAndInsertJets(), initobjects(), InitSelector(), insertcandidates(), edm::HandleBase::isValid(), j, python.multivaluedict::map(), NptPlots, passJetCuts(), passOtherCuts(), EVTColContainer::PFJET, EVTColContainer::PFMET, phi, EnergyCorrector::pt, RECO, python.multivaluedict::sort(), 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];
        _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);
                _elements[nameVtxPlot+"_"+fillShortPath.c_str()]->Fill(nbMCvtx);
                if( _bookHtPlots ) _elements[nameHtPlot+"_"+fillShortPath.c_str()]->Fill(Htmap[it->first]);
            }
            else {
                _elements[SummaryName+"_passingHLT"]->Fill(refOfThePath,0);

            }
        }
    }
}

void HLTHiggsSubAnalysis::beginJob

(

void

)

Definition at line 170 of file HLTHiggsSubAnalysis.cc.

{
}

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

Definition at line 176 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _analyzers, _hltConfig, _hltPaths, _hltPathsToCheck, _hltProcessName, _NminOneCuts, _pset, _recLabels, _shortpath2long, cmsRelvalreport::exit, spr::find(), newFWLiteAna::found, getObjectsType(), EVTColContainer::getTypeString(), i, HLTConfigProvider::init(), j, LogDebug, LogTrace, NptPlots, cmsHarvester::path, chain::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 904 of file HLTHiggsSubAnalysis.cc.

References _elements, _parametersEta, _parametersPhi, _parametersTurnOn, DQMStore::IBooker::book1D(), prof2calltree::edges, EVTColContainer::getTypeString(), h, i, bookConverter::max, min(), mergeVDriftHistosByStation::name, EVTColContainer::PFJET, EVTColContainer::PFMET, source, AlCaHLTBitMon_QueryRunRegistry::string, and indexGen::title.

Referenced by bookHistograms().

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

        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 263 of file HLTHiggsSubAnalysis.cc.

References _analysisname, _analyzers, _bookHtPlots, _elements, _histDirectory, _hltPathsToCheck, _NminOneCuts, _parametersHt, _parametersPu, _recLabels, _useNminOneCuts, DQMStore::IBooker::book1D(), bookHist(), EVTColContainer::getTypeString(), i, j, NptPlots, cmsHarvester::path, EVTColContainer::PFJET, DQMStore::IBooker::setCurrentFolder(), source, 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];

        _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;
            _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 756 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] = 0 ;
    }
    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] = 0 ;
    }
    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] = 0 ;
    }
    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] = 0 ;
    }
    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] = 0 ;
    }
    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] = 0 ;
    }
    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 = 0;
    }
    /*if( anpset.exists("recTrackLabel") )
    {
        _recLabels[EVTColContainer::TRACK] = anpset.getParameter<std::string>("recTrackLabel");
        _genSelectorMap[EVTColContainer::TRACK] = 0 ;
    }*/

    if( _recLabels.size() < 1 )
    {
        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 1016 of file HLTHiggsSubAnalysis.cc.

References _elements, mergeVDriftHistosByStation::name, source, and AlCaHLTBitMon_QueryRunRegistry::string.

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 719 of file HLTHiggsSubAnalysis.cc.

References EVTColContainer::CALOMET, EVTColContainer::ELEC, EVTColContainer::getTypeString(), 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("CSV") ) ||   // fix for ZnnHbb PFJET            
                (objtriggernames[i] == EVTColContainer::PFMET && TString(hltPath).Contains("MHT")) )        // fix for ZnnHbb PFMET
                objsType.insert(objtriggernames[i]);
           continue;
        }
        if( objtriggernames[i] == EVTColContainer::CALOMET && (TString(hltPath).Contains("PFMET") || TString(hltPath).Contains("MHT") ) ) continue; // fix for PFMET

        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 1069 of file HLTHiggsSubAnalysis.cc.

References _recLabelsPFJet, _recPFJetSelector, _recTagPFJet, _useNminOneCuts, 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 817 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 1029 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 == 0 )
    {
        _recMuonSelector = new StringCutObjectSelector<reco::Muon>(_recCut[objtype]);
    }
    else if( objtype == EVTColContainer::ELEC && _recElecSelector == 0)
    {
        _recElecSelector = new StringCutObjectSelector<reco::GsfElectron>(_recCut[objtype]);
    }
    else if( objtype == EVTColContainer::PHOTON && _recPhotonSelector == 0)
    {
        _recPhotonSelector = new StringCutObjectSelector<reco::Photon>(_recCut[objtype]);
    }
    else if( objtype == EVTColContainer::CALOMET && _recCaloMETSelector == 0)
    {
        _recCaloMETSelector = new StringCutObjectSelector<reco::CaloMET>(_recCut[objtype]);
    }
    else if( objtype == EVTColContainer::PFMET && _recPFMETSelector == 0)
    {
        _recPFMETSelector = new StringCutObjectSelector<reco::PFMET>(_recCut[objtype]);
    }
    else if( objtype == EVTColContainer::PFTAU && _recPFTauSelector == 0 )
    {
        _recPFTauSelector = new StringCutObjectSelector<reco::PFTau>(_recCut[objtype]);
    }
    else if( objtype == EVTColContainer::PFJET && _recPFJetSelector == 0 )
    {
        _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 1189 of file HLTHiggsSubAnalysis.cc.

References _recCaloMETSelector, _recElecSelector, _recMuonSelector, _recPFMETSelector, _recPFTauSelector, _recPhotonSelector, EVTColContainer::CALOMET, EVTColContainer::caloMETs, EVTColContainer::ELEC, EVTColContainer::electrons, i, EVTColContainer::MUON, EVTColContainer::muons, 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 1101 of file HLTHiggsSubAnalysis.cc.

References _NminOneCuts, eta(), i, NptPlots, phi, python.multivaluedict::sort(), 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] ) {
        dEtaqq =  fabs((*matches)[2].eta - (*matches)[3].eta);
        if( dEtaqq > _NminOneCuts[0] ) jetCutResult["dEtaqq"] = true;
        else jetCutResult["dEtaqq"] = false;
    }
    
    if( _NminOneCuts[1] ) {
        mqq = ((*matches)[2].lorentzVector + (*matches)[3].lorentzVector).M();
        if( mqq > _NminOneCuts[1] ) jetCutResult["mqq"] = true;
        else jetCutResult["mqq"] = false;
    }
    
    if( _NminOneCuts[2] ) {
        dPhibb = fmod(fabs((*matches)[0].phi - (*matches)[1].phi),3.1416);
        if( dPhibb < _NminOneCuts[2] ) jetCutResult["dPhibb"] = true;
        else jetCutResult["dPhibb"] = false;
    }

    if( _NminOneCuts[4] ) {
        CSV2 = (*matches)[1].bTag;
        std::string nameCSV2plot = "CSV2";

        if( CSV2 > _NminOneCuts[4] ) jetCutResult[nameCSV2plot] = true;
        else jetCutResult[nameCSV2plot] = false;
        }

    if( _NminOneCuts[5] ) {
        CSV3 = (*matches)[2].bTag;
        std::string nameCSV3plot = "CSV3";

        if( CSV3 > _NminOneCuts[5] ) jetCutResult[nameCSV3plot] = true;
        else jetCutResult[nameCSV3plot] = false;
        }


    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 1176 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 102 of file HLTHiggsSubAnalysis.h.

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

std::vector<HLTHiggsPlotter> HLTHiggsSubAnalysis::_analyzers

private

Definition at line 175 of file HLTHiggsSubAnalysis.h.

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

bool HLTHiggsSubAnalysis::_bookHtPlots

private

Definition at line 110 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 149 of file HLTHiggsSubAnalysis.h.

Referenced by HLTHiggsSubAnalysis().

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

private

Definition at line 148 of file HLTHiggsSubAnalysis.h.

Referenced by HLTHiggsSubAnalysis().

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

private

Definition at line 150 of file HLTHiggsSubAnalysis.h.

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

private

Definition at line 151 of file HLTHiggsSubAnalysis.h.

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

private

Definition at line 178 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 153 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

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

private

Definition at line 126 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and initobjects().

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

private

Definition at line 159 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 125 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 158 of file HLTHiggsSubAnalysis.h.

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

std::string HLTHiggsSubAnalysis::_histDirectory

private

Definition at line 113 of file HLTHiggsSubAnalysis.h.

Referenced by bookHistograms().

HLTConfigProvider HLTHiggsSubAnalysis::_hltConfig

private

Definition at line 177 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

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

private

the hlt paths found in the hltConfig

Definition at line 118 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

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

private

the hlt paths with regular expressions

Definition at line 116 of file HLTHiggsSubAnalysis.h.

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

std::string HLTHiggsSubAnalysis::_hltProcessName

private

Definition at line 112 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

double HLTHiggsSubAnalysis::_HtJetEtaMax

private

Definition at line 108 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

double HLTHiggsSubAnalysis::_HtJetPtMin

private

Definition at line 107 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 105 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

std::vector<double> HLTHiggsSubAnalysis::_NminOneCuts

private

Definition at line 170 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 141 of file HLTHiggsSubAnalysis.h.

Referenced by bookHist().

std::vector<double> HLTHiggsSubAnalysis::_parametersHt

private

Definition at line 144 of file HLTHiggsSubAnalysis.h.

Referenced by bookHistograms(), and HLTHiggsSubAnalysis().

std::vector<double> HLTHiggsSubAnalysis::_parametersPhi

private

Definition at line 142 of file HLTHiggsSubAnalysis.h.

Referenced by bookHist().

std::vector<double> HLTHiggsSubAnalysis::_parametersPu

private

Definition at line 143 of file HLTHiggsSubAnalysis.h.

Referenced by bookHistograms().

std::vector<double> HLTHiggsSubAnalysis::_parametersTurnOn

private

Definition at line 145 of file HLTHiggsSubAnalysis.h.

Referenced by bookHist().

edm::ParameterSet HLTHiggsSubAnalysis::_pset

private

Definition at line 100 of file HLTHiggsSubAnalysis.h.

Referenced by beginRun().

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

private

Definition at line 138 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and HLTHiggsSubAnalysis().

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

private

Definition at line 162 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 154 of file HLTHiggsSubAnalysis.h.

Referenced by HLTHiggsSubAnalysis(), and InitSelector().

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

private

Definition at line 161 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 129 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 133 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

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

private

Definition at line 131 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

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

private

Definition at line 130 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

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

private

Definition at line 136 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initAndInsertJets().

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

private

Definition at line 134 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

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

private

Definition at line 135 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

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

private

Definition at line 132 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initobjects().

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

private

Definition at line 160 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 127 of file HLTHiggsSubAnalysis.h.

Referenced by analyze().

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

private

Definition at line 166 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 163 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 164 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 165 of file HLTHiggsSubAnalysis.h.

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

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

private

Definition at line 137 of file HLTHiggsSubAnalysis.h.

Referenced by bookobjects(), and initAndInsertJets().

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

private

Definition at line 167 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 121 of file HLTHiggsSubAnalysis.h.

Referenced by analyze(), and beginRun().

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

private

Definition at line 146 of file HLTHiggsSubAnalysis.h.

Referenced by initobjects().

bool HLTHiggsSubAnalysis::_useNminOneCuts

private

Definition at line 171 of file HLTHiggsSubAnalysis.h.

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

unsigned int HLTHiggsSubAnalysis::NptPlots

private

Definition at line 172 of file HLTHiggsSubAnalysis.h.

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