FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter > Class Template Reference

Inheritance diagram for FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >:

Public Member Functions
void	analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, const edm::TriggerResults &triggerResults, const edm::TriggerNames &triggerNames, float weight) override
void	book (DQMStore::IBooker &booker) override
template<class T >
int	count (const edm::Event &iEvent, InputTag &input, StringCutObjectSelector< T > &sel, float weight)
void	fillSingleObjectPlots (const TInputCandidateType &cand, float weight)
std::vector< std::string >	findPathAndFilter (const HLTConfigProvider &hltConfig)
void	getAndStoreTokens (edm::ConsumesCollector &&iC) override
template<>
void	getAndStoreTokens (edm::ConsumesCollector &&iC)
template<>
void	getAndStoreTokens (edm::ConsumesCollector &&iC)
template<>
void	getAndStoreTokens (edm::ConsumesCollector &&iC)
template<>
void	getAndStoreTokens (edm::ConsumesCollector &&iC)
std::vector< TOutputCandidateType >	getBestCombination (std::vector< TOutputCandidateType > &cands)
void	getFilteredCands (TInputCandidateType *, std::vector< TOutputCandidateType > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (reco::Candidate::LorentzVector *, std::vector< reco::Candidate::LorentzVector > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (reco::Track *, std::vector< int > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (reco::GenParticle *, std::vector< int > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (reco::Track *, std::vector< int > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (reco::PFJet *, std::vector< reco::PFJet > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (reco::Candidate::LorentzVector *, std::vector< int > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
template<>
void	getFilteredCands (trigger::TriggerObject *, std::vector< trigger::TriggerObject > &cands, const edm::Event &iEvent, const edm::EventSetup &iSetup, const HLTConfigProvider &hltConfig, const trigger::TriggerEvent &trgEvent, float weight)
	HandlerTemplate (const edm::ParameterSet &iConfig, triggerExpression::Data &eventCache)
	~HandlerTemplate () override=default
Public Member Functions inherited from FSQ::BaseHandler
	BaseHandler ()
	BaseHandler (const edm::ParameterSet &iConfig, triggerExpression::Data &eventCache)
virtual	~BaseHandler ()=default

Private Attributes
int	m_combinedObjectDimension
std::vector< edm::ParameterSet >	m_combinedObjectDrawables
StringCutObjectSelector< std::vector< TOutputCandidateType > >	m_combinedObjectSelection
StringObjectFunction< std::vector< TOutputCandidateType > >	m_combinedObjectSortFunction
std::string	m_dqmhistolabel
std::string	m_filterPartialName
edm::InputTag	m_input
bool	m_isSetup
std::string	m_pathPartialName
std::map< std::string, std::shared_ptr< StringObjectFunction< std::vector< TOutputCandidateType > > > >	m_plottersCombinedObject
std::map< std::string, std::shared_ptr< StringObjectFunction< TInputCandidateType > > >	m_plottersSingleObject
std::map< std::string, int >	m_plotterType
std::vector< edm::ParameterSet >	m_singleObjectDrawables
StringCutObjectSelector< TInputCandidateType >	m_singleObjectSelection
std::map< std::string, edm::EDGetToken >	m_tokens

Static Private Attributes
static const int	CombinedObjectPlotter = 1
static const int	SingleObjectPlotter = 0
	xxx More...

Additional Inherited Members
Public Attributes inherited from FSQ::BaseHandler
std::string	m_dirname
triggerExpression::Data *	m_eventCache
std::unique_ptr< triggerExpression::Evaluator >	m_expression
std::map< std::string, MonitorElement * >	m_histos
edm::ParameterSet	m_pset
std::set< std::string >	m_usedPaths

Detailed Description

template<class TInputCandidateType, class TOutputCandidateType, SpecialFilters filter = None>
class FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >

Definition at line 107 of file FSQDiJetAve.cc.

Constructor & Destructor Documentation

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::HandlerTemplate ( const edm::ParameterSet &  iConfig, triggerExpression::Data &  eventCache  )

inline

Definition at line 131 of file FSQDiJetAve.cc.

References edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           :
            BaseHandler(iConfig, eventCache),
            m_singleObjectSelection(iConfig.getParameter<std::string>("singleObjectsPreselection")),
            m_combinedObjectSelection(iConfig.getParameter<std::string>("combinedObjectSelection")),
            m_combinedObjectSortFunction(iConfig.getParameter<std::string>("combinedObjectSortCriteria"))
        {
             std::string type = iConfig.getParameter<std::string>("handlerType");
             if (type != "FromHLT") {
                m_input = iConfig.getParameter<edm::InputTag>("inputCol");
             }

             m_dqmhistolabel = iConfig.getParameter<std::string>("dqmhistolabel");
             m_filterPartialName = iConfig.getParameter<std::string>("partialFilterName"); // std::string find is used to match filter
             m_pathPartialName  = iConfig.getParameter<std::string>("partialPathName");
             m_combinedObjectDimension = iConfig.getParameter<int>("combinedObjectDimension");
             m_combinedObjectDrawables = iConfig.getParameter<  std::vector< edm::ParameterSet > >("combinedObjectDrawables");
             m_singleObjectDrawables = iConfig.getParameter<  std::vector< edm::ParameterSet > >("singleObjectDrawables");
             m_isSetup = false;
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::~HandlerTemplate ( )

overridedefault

Member Function Documentation

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

void FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const HLTConfigProvider &  hltConfig, const trigger::TriggerEvent &  trgEvent, const edm::TriggerResults &  triggerResults, const edm::TriggerNames &  triggerNames, float  weight  )

inlineoverridevirtual

Implements FSQ::BaseHandler.

Definition at line 296 of file FSQDiJetAve.cc.

References egammaForCoreTracking_cff::cands, runEdmFileComparison::found, mps_fire::i, edm::TriggerNames::size(), edm::TriggerNames::triggerName(), and heppy_batch::val.

        {
            size_t found = 0;
            for (size_t i = 0; i<triggerNames.size(); ++i){
                auto itUsedPaths = m_usedPaths.begin();
                for(; itUsedPaths != m_usedPaths.end(); ++itUsedPaths){ 
                    if (triggerNames.triggerName(i).find(*itUsedPaths)!= std::string::npos ){
                        ++found;
                        break;
                    }
                }

                if (found == m_usedPaths.size()) break;
            }
            if (found != m_usedPaths.size()){
                    edm::LogInfo("FSQDiJetAve") << "One of requested paths not found, skipping event";
                    return;
            }
            if (m_eventCache->configurationUpdated()) {
                m_expression->init(*m_eventCache);
            }
            if (not (*m_expression)(*m_eventCache)) return;

            /*
            std::vector<std::string> pathAndFilter = findPathAndFilter(hltConfig);

            std::string pathFullName = pathAndFilter[0];
            if (pathFullName == "") {
                return;
            }
            unsigned indexNum = triggerNames.triggerIndex(pathFullName);
            if(indexNum >= triggerNames.size()){
                  edm::LogError("FSQDiJetAve") << "Problem determining trigger index for " << pathFullName << " " << m_pathPartialName;
            }
            if (!triggerResults.accept(indexNum)) return;*/

            std::vector<TOutputCandidateType> cands;
            getFilteredCands((TInputCandidateType *)nullptr, cands, iEvent, iSetup, hltConfig, trgEvent, weight);

            if (cands.empty()) return;

            std::vector<TOutputCandidateType> bestCombinationFromCands = getBestCombination(cands);
            if (bestCombinationFromCands.empty()) return;

            // plot 
            std::map<std::string,  MonitorElement*>::iterator it, itE;
            it = m_histos.begin();
            itE = m_histos.end();
            for (;it!=itE;++it){
                if (m_plotterType[it->first]!=CombinedObjectPlotter) continue;
                float val = (*m_plottersCombinedObject[it->first])(bestCombinationFromCands);
                it->second->Fill(val, weight);
            }
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

void FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::book ( DQMStore::IBooker &  booker )

inlineoverridevirtual

Implements FSQ::BaseHandler.

Definition at line 151 of file FSQDiJetAve.cc.

References create_public_pileup_plots::bins, DQMStore::IBooker::book1D(), patCandidates_cff::func, mps_fire::i, DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                    {
            if(!m_isSetup){
                booker.setCurrentFolder(m_dirname);
                m_isSetup = true;
                std::vector< std::vector< edm::ParameterSet > * > todo(2, (std::vector< edm::ParameterSet > * )nullptr);
                todo[CombinedObjectPlotter]=&m_combinedObjectDrawables;
                todo[SingleObjectPlotter]=&m_singleObjectDrawables;
                for (size_t ti =0; ti<todo.size();++ti){
                    for (size_t i = 0; i < todo[ti]->size(); ++i){
                        std::string histoName = m_dqmhistolabel + "_" + todo[ti]->at(i).template getParameter<std::string>("name");
                        std::string expression =   todo[ti]->at(i).template getParameter<std::string>("expression");
                        int bins =    todo[ti]->at(i).template getParameter<int>("bins");
                        double rangeLow  =  todo[ti]->at(i).template getParameter<double>("min");
                        double rangeHigh =  todo[ti]->at(i).template getParameter<double>("max");
                        m_histos[histoName] =  booker.book1D(histoName, histoName, bins, rangeLow, rangeHigh);
                        m_plotterType[histoName] = ti;
                        if (ti == CombinedObjectPlotter){
                            auto * func 
                                    = new StringObjectFunction<std::vector<TOutputCandidateType> >(expression);
                            m_plottersCombinedObject[histoName] =  std::shared_ptr<StringObjectFunction<std::vector<TOutputCandidateType> > >(func);
                        } else {
                            auto  * func 
                                    = new StringObjectFunction< TInputCandidateType> (expression);
                            m_plottersSingleObject[histoName] =  std::shared_ptr<StringObjectFunction<TInputCandidateType> > (func);
                        }
                    }   
                }
            }
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

template<class T >

int FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::count ( const edm::Event &  iEvent, InputTag &  input, StringCutObjectSelector< T > &  sel, float  weight  )

inline

Definition at line 191 of file FSQDiJetAve.cc.

References edm::InputTag::encode(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), electronCleaner_cfi::preselection, triggerObjects_cff::sel, and mps_merge::weight.

                                                                                                          {
           int ret = 0;
           Handle<std::vector< T > > hIn;
           iEvent.getByToken(m_tokens[input.encode()], hIn);
           if(!hIn.isValid()) {
              edm::LogError("FSQDiJetAve") << "product not found: "<<  input.encode();
              return -1;  // return nonsense value
           }
           for (size_t i = 0; i<hIn->size(); ++i) {
                bool preselection = sel(hIn->at(i));
                if (preselection){
                    fillSingleObjectPlots(hIn->at(i), weight);
                    ret+=1;
                }
           }
           return ret;
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

void FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::fillSingleObjectPlots ( const TInputCandidateType &  cand, float  weight  )

inline

Definition at line 210 of file FSQDiJetAve.cc.

References heppy_batch::val.

                                                                                  {
            std::map<std::string,  MonitorElement*>::iterator it, itE;
            it = m_histos.begin();
            itE = m_histos.end();
            for (;it!=itE;++it){
                if (m_plotterType[it->first]!=SingleObjectPlotter) continue;
                float val = (*m_plottersSingleObject[it->first])(cand);
                it->second->Fill(val, weight);
            }
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::vector<std::string > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::findPathAndFilter ( const HLTConfigProvider &  hltConfig )

inline

Definition at line 254 of file FSQDiJetAve.cc.

References mps_fire::i, HLTConfigProvider::moduleEDMType(), HLTConfigProvider::moduleLabels(), HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, and HLTConfigProvider::triggerName().

                                                                                    {
            std::vector<std::string> ret(2,"");
            std::string filterFullName = "";
            std::string pathFullName = "";
            std::vector<std::string> filtersForThisPath;
            //int pathIndex = -1;
            int numPathMatches = 0;
            int numFilterMatches = 0;
            for (size_t i = 0; i < hltConfig.size(); ++i) {
                if (hltConfig.triggerName(i).find(m_pathPartialName) == std::string::npos) continue;
                pathFullName = hltConfig.triggerName(i);
                //pathIndex = i;
                ++numPathMatches;
                std::vector<std::string > moduleLabels = hltConfig.moduleLabels(i);
                for (auto & moduleLabel : moduleLabels){
                    if ("EDFilter" ==  hltConfig.moduleEDMType(moduleLabel)) {
                        filtersForThisPath.push_back(moduleLabel);
                        if ( moduleLabel.find(m_filterPartialName)!= std::string::npos  ){
                            filterFullName = moduleLabel;
                            ++numFilterMatches;
                        }
                    }
                }
            }

            // LogWarning or LogError?
            if (numPathMatches != 1) {
                  edm::LogInfo("FSQDiJetAve") << "Problem: found " << numPathMatches
                    << " paths matching " << m_pathPartialName << std::endl;
                  return ret;   
            }
            ret[0] = pathFullName;
            if (numFilterMatches != 1) {
                  edm::LogError("FSQDiJetAve") << "Problem: found " << numFilterMatches
                    << " filter matching " << m_filterPartialName
                    << " in path "<< m_pathPartialName << std::endl;
                  return ret;
            }
            ret[1] = filterFullName;
            return ret;
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

void FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::getAndStoreTokens ( edm::ConsumesCollector &&  iC )

inlineoverridevirtual

Implements FSQ::BaseHandler.

Definition at line 180 of file FSQDiJetAve.cc.

References edm::InputTag::encode().

                                                                   {
                edm::EDGetTokenT<std::vector<TInputCandidateType>  > tok =  iC.consumes<std::vector<TInputCandidateType> > (m_input);
                m_tokens[m_input.encode()] = edm::EDGetToken(tok);
        }

template<>

void FSQ::HandlerTemplate< reco::Candidate::LorentzVector, reco::Candidate::LorentzVector >::getAndStoreTokens ( edm::ConsumesCollector &&  iC )

virtual

Implements FSQ::BaseHandler.

Definition at line 431 of file FSQDiJetAve.cc.

{
    edm::EDGetTokenT<View<reco::Candidate> > tok =  iC.consumes< View<reco::Candidate>  > (m_input);
    m_tokens[m_input.encode()] = edm::EDGetToken(tok);
}

template<>

void FSQ::HandlerTemplate< reco::Track, int, BestVertexMatching >::getAndStoreTokens ( edm::ConsumesCollector &&  iC )

virtual

Implements FSQ::BaseHandler.

Definition at line 500 of file FSQDiJetAve.cc.

References edm::InputTag::encode().

{
    edm::EDGetTokenT<std::vector<reco::Track>  > tok =  iC.consumes<std::vector<reco::Track> > (m_input);
    m_tokens[m_input.encode()] = edm::EDGetToken(tok);

    edm::InputTag lVerticesTag = m_pset.getParameter<edm::InputTag>("vtxCollection");
    edm::EDGetTokenT<reco::VertexCollection > tok2 =  iC.consumes< reco::VertexCollection  > (lVerticesTag);
    m_tokens[lVerticesTag.encode()] = edm::EDGetToken(tok2);
}

template<>

void FSQ::HandlerTemplate< reco::PFJet, reco::PFJet, ApplyJEC >::getAndStoreTokens ( edm::ConsumesCollector &&  iC )

virtual

Implements FSQ::BaseHandler.

Definition at line 586 of file FSQDiJetAve.cc.

References edm::InputTag::encode().

{
    edm::EDGetTokenT<std::vector<reco::PFJet>  > tok =  iC.consumes<std::vector<reco::PFJet> > (m_input);
    m_tokens[m_input.encode()] = edm::EDGetToken(tok);

    edm::InputTag jetCorTag = m_pset.getParameter<edm::InputTag>("PFJetCorLabel");
    edm::EDGetTokenT<reco::JetCorrector> jetcortoken =  iC.consumes<reco::JetCorrector>(jetCorTag);
    m_tokens[jetCorTag.encode()] = edm::EDGetToken(jetcortoken);

}

template<>

void FSQ::HandlerTemplate< reco::Candidate::LorentzVector, int >::getAndStoreTokens ( edm::ConsumesCollector &&  iC )

virtual

Implements FSQ::BaseHandler.

Definition at line 639 of file FSQDiJetAve.cc.

{
    edm::EDGetTokenT<View<reco::Candidate> > tok =  iC.consumes< View<reco::Candidate>  > (m_input);
    m_tokens[m_input.encode()] = edm::EDGetToken(tok);
}

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::vector<TOutputCandidateType> FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::getBestCombination ( std::vector< TOutputCandidateType > &  cands )

inline

Definition at line 356 of file FSQDiJetAve.cc.

References SoftLeptonByDistance_cfi::distance, mps_fire::i, and tier0::unique().

                                                                                                    {
            int columnSize = cands.size();
            std::vector<int> currentCombination(m_combinedObjectDimension, 0);
            std::vector<int> bestCombination(m_combinedObjectDimension, -1);

            int maxCombinations = 1;
            int cnt = 0;
            while (cnt < m_combinedObjectDimension){
                cnt += 1;
                maxCombinations *= columnSize;
            }

            cnt = 0;
            float bestCombinedCandVal = -1;
            while ( cnt < maxCombinations){
                cnt += 1;

                // 1. Check if current combination contains duplicates
                std::vector<int> currentCombinationCopy(currentCombination);
                std::vector<int>::iterator it;
                std::sort(currentCombinationCopy.begin(), currentCombinationCopy.end());
                it = std::unique(currentCombinationCopy.begin(), currentCombinationCopy.end());
                currentCombinationCopy.resize( std::distance(currentCombinationCopy.begin(),it) );
                bool duplicatesPresent = currentCombination.size() != currentCombinationCopy.size();
                // 2. If no duplicates found - 
                //          - check if current combination passes the cut
                //          - rank current combination
                if (!duplicatesPresent) { // no duplicates, we can consider this combined object
                    std::vector<TOutputCandidateType > currentCombinationFromCands;
                    for (int i = 0; i<m_combinedObjectDimension;++i){
                        currentCombinationFromCands.push_back( cands.at(currentCombination.at(i)));
                    }
                    bool isOK = m_combinedObjectSelection(currentCombinationFromCands);
                    if (isOK){
                        float curVal = m_combinedObjectSortFunction(currentCombinationFromCands);
                        // FIXME
                        if (curVal < 0) {
                            edm::LogError("FSQDiJetAve") << "Problem: ranking function returned negative value: " << curVal << std::endl;
                        } else if (curVal > bestCombinedCandVal){
                            //std::cout << curVal << " " << bestCombinedCandVal << std::endl;
                            bestCombinedCandVal = curVal;
                            bestCombination = currentCombination;
                        }
                    }
                }
                // 3. Prepare next combination to test
                //    note to future self: less error prone method with modulo
                currentCombination.at(m_combinedObjectDimension-1)+=1; // increase last number
                int carry = 0;
                for (int i = m_combinedObjectDimension-1; i>=0; --i){  // iterate over all numbers, check if we are out of range
                    currentCombination.at(i)+= carry;
                    carry = 0;
                    if (currentCombination.at(i)>=columnSize){
                        carry = 1;
                        currentCombination.at(i) = 0;
                    }
                }
            } // combinations loop ends

            std::vector<TOutputCandidateType > bestCombinationFromCands;
            if (!bestCombination.empty() && bestCombination.at(0)>=0){
                for (int i = 0; i<m_combinedObjectDimension;++i){
                          bestCombinationFromCands.push_back( cands.at(bestCombination.at(i)));
                }
            }
            return bestCombinationFromCands;
        }

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

void FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::getFilteredCands ( TInputCandidateType *  , std::vector< TOutputCandidateType > &  cands, const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const HLTConfigProvider &  hltConfig, const trigger::TriggerEvent &  trgEvent, float  weight  )

inline

Definition at line 230 of file FSQDiJetAve.cc.

References edm::InputTag::encode(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), electronCleaner_cfi::preselection, and mps_merge::weight.

        {
               Handle<std::vector<TInputCandidateType> > hIn;
               iEvent.getByToken(m_tokens[m_input.encode()], hIn);

               if(!hIn.isValid()) {
                  edm::LogError("FSQDiJetAve") << "product not found: "<<  m_input.encode();
                  return;  
               }

               for (size_t i = 0; i<hIn->size(); ++i) {
                    bool preselection = m_singleObjectSelection(hIn->at(i));
                    if (preselection){
                        fillSingleObjectPlots(hIn->at(i), weight);
                        cands.push_back(hIn->at(i));
                    }
               }
        }

template<>

void FSQ::HandlerTemplate< reco::Candidate::LorentzVector, reco::Candidate::LorentzVector >::getFilteredCands	(	reco::Candidate::LorentzVector *	,
		std::vector< reco::Candidate::LorentzVector > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 438 of file FSQDiJetAve.cc.

References edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), electronCleaner_cfi::preselection, and mps_merge::weight.

{  
   Handle<View<reco::Candidate> > hIn;
   iEvent.getByToken(m_tokens[m_input.encode()], hIn);
   if(!hIn.isValid()) {
      edm::LogError("FSQDiJetAve") << "product not found: "<<  m_input.encode();
      return;
   }
   for (auto const & i : *hIn) {
        bool preselection = m_singleObjectSelection(i.p4());
        if (preselection){
            fillSingleObjectPlots(i.p4(), weight);
            cands.push_back(i.p4());
        }
   }
}

template<>

void FSQ::HandlerTemplate< reco::Track, int >::getFilteredCands	(	reco::Track *	,
		std::vector< int > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 469 of file FSQDiJetAve.cc.

{  
   cands.clear();
   cands.push_back(count<reco::Track>(iEvent, m_input, m_singleObjectSelection, weight) );
}

template<>

void FSQ::HandlerTemplate< reco::GenParticle, int >::getFilteredCands	(	reco::GenParticle *	,
		std::vector< int > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 482 of file FSQDiJetAve.cc.

{
   cands.clear();
   cands.push_back(count<reco::GenParticle>(iEvent, m_input, m_singleObjectSelection, weight) );
}

template<>

void FSQ::HandlerTemplate< reco::Track, int, BestVertexMatching >::getFilteredCands	(	reco::Track *	,
		std::vector< int > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 512 of file FSQDiJetAve.cc.

References PVValHelper::dxy, PVValHelper::dz, edm::InputTag::encode(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), mathSSE::sqrt(), and electrons_cff::vertices.

{  
    // this is not elegant, but should be thread safe
    static const edm::InputTag lVerticesTag = m_pset.getParameter<edm::InputTag>("vtxCollection");
    static const int lMinNDOF = m_pset.getParameter<int>("minNDOF"); //7
    static const double lMaxZ = m_pset.getParameter<double>("maxZ"); // 15
    static const double lMaxDZ = m_pset.getParameter<double>("maxDZ"); // 0.12
    static const double lMaxDZ2dzsigma = m_pset.getParameter<double>("maxDZ2dzsigma"); // 3
    static const double lMaxDXY = m_pset.getParameter<double>("maxDXY"); // 0.12
    static const double lMaxDXY2dxysigma = m_pset.getParameter<double>("maxDXY2dxysigma"); // 3

    cands.clear();
    cands.push_back(0);

    edm::Handle<reco::VertexCollection> vertices;
    iEvent.getByToken(m_tokens[lVerticesTag.encode()], vertices);

    //double bestvz=-999.9, bestvx=-999.9, bestvy=-999.9;

    double dxy, dz, dzsigma, dxysigma;
    math::XYZPoint vtxPoint(0.0,0.0,0.0);
    double vzErr =0.0, vxErr=0.0, vyErr=0.0;

    // take first vertex passing the criteria
    int bestVtx = -1;
    for (size_t i = 0; i < vertices->size(); ++i){
        if (vertices->at(i).ndof()<lMinNDOF) continue; 
        if (fabs(vertices->at(i).z())> lMaxZ) continue;

        vtxPoint=vertices->at(i).position();
        vzErr=vertices->at(i).zError();
        vxErr=vertices->at(i).xError();
        vyErr=vertices->at(i).yError();
        bestVtx = i;
        break;
    }
    if (bestVtx < 0) return;
    // const reco::Vertex & vtx = vertices->at(bestVtx);

   Handle<std::vector<reco::Track > > hIn;
   iEvent.getByToken(m_tokens[m_input.encode()], hIn);
   if(!hIn.isValid()) {
      edm::LogError("FSQDiJetAve") << "product not found: "<<  m_input.encode();
      return;
   }

   for (auto const & i : *hIn) {
        if (!m_singleObjectSelection(i)) continue;
        dxy=0.0, dz=0.0, dxysigma=0.0, dzsigma=0.0;
        dxy = -1.*i.dxy(vtxPoint);
        dz = i.dz(vtxPoint);
        dxysigma = sqrt(i.dxyError()*i.dxyError()+vxErr*vyErr);
        dzsigma = sqrt(i.dzError()*i.dzError()+vzErr*vzErr);
        
        if(fabs(dz)>lMaxDZ)continue; // TODO...
        if(fabs(dz/dzsigma)>lMaxDZ2dzsigma)continue;
        if(fabs(dxy)>lMaxDXY)continue;
        if(fabs(dxy/dxysigma)>lMaxDXY2dxysigma)continue;
        
        cands.at(0)+=1;
    }//loop over tracks
}

template<>

void FSQ::HandlerTemplate< reco::PFJet, reco::PFJet, ApplyJEC >::getFilteredCands	(	reco::PFJet *	,
		std::vector< reco::PFJet > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 599 of file FSQDiJetAve.cc.

References edm::InputTag::encode(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), electronCleaner_cfi::preselection, and Scenarios_cff::scale.

{  
    cands.clear();
    static const edm::InputTag jetCorTag = m_pset.getParameter<edm::InputTag>("PFJetCorLabel");
    edm::Handle<reco::JetCorrector> pfcorrector;
    iEvent.getByToken(m_tokens[jetCorTag.encode()], pfcorrector);
 
    Handle<std::vector<reco::PFJet> > hIn;
    iEvent.getByToken(m_tokens[m_input.encode()], hIn);

    if(!hIn.isValid()) {
      edm::LogError("FSQDiJetAve") << "product not found: "<<  m_input.encode();
      return;  
    }

    for (auto const & i : *hIn) {
         double scale = pfcorrector->correction(i);
         reco::PFJet newPFJet(scale*i.p4(), i.vertex(), 
                              i.getSpecific(),  i.getJetConstituents());
         
         bool preselection = m_singleObjectSelection(newPFJet);
         if (preselection){
             fillSingleObjectPlots(newPFJet, weight);
             cands.push_back(newPFJet);
         }
    }
}

template<>

void FSQ::HandlerTemplate< reco::Candidate::LorentzVector, int >::getFilteredCands	(	reco::Candidate::LorentzVector *	,
		std::vector< int > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 646 of file FSQDiJetAve.cc.

References edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), electronCleaner_cfi::preselection, and mps_merge::weight.

{  
   cands.clear();
   cands.push_back(0);

   Handle<View<reco::Candidate> > hIn;
   iEvent.getByToken(m_tokens[m_input.encode()], hIn);
   if(!hIn.isValid()) {
      edm::LogError("FSQDiJetAve") << "product not found: "<<  m_input.encode();
      return;
   }
   for (auto const & i : *hIn) {
        bool preselection = m_singleObjectSelection(i.p4());
        if (preselection){
            fillSingleObjectPlots(i.p4(), weight);
            cands.at(0)+=1;
        }
   }
}

template<>

void FSQ::HandlerTemplate< trigger::TriggerObject, trigger::TriggerObject >::getFilteredCands	(	trigger::TriggerObject *	,
		std::vector< trigger::TriggerObject > &	cands,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const HLTConfigProvider &	hltConfig,
		const trigger::TriggerEvent &	trgEvent,
		float	weight
	)

Definition at line 678 of file FSQDiJetAve.cc.

References trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), electronCleaner_cfi::preselection, LaserDQM_cfg::process, trigger::TriggerEvent::sizeFilters(), AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerEvent::usedProcessName().

{
    // 1. Find matching path. Inside matchin path find matching filter
    std::string filterFullName = findPathAndFilter(hltConfig)[1];
    if (filterFullName.empty()) {
        return;
    }

    // 2. Fetch HLT objects saved by selected filter. Save those fullfilling preselection
    //      objects are saved in cands variable
    const std::string& process = trgEvent.usedProcessName(); // broken?
    edm::InputTag hltTag(filterFullName ,"", process);
    
    const int hltIndex = trgEvent.filterIndex(hltTag);
    if ( hltIndex >= trgEvent.sizeFilters() ) {
      edm::LogInfo("FSQDiJetAve") << "Cannot determine hlt index for |" << filterFullName << "|" << process;
      return;
    }

    const trigger::TriggerObjectCollection & toc(trgEvent.getObjects());
    const trigger::Keys & khlt = trgEvent.filterKeys(hltIndex);

    auto kj = khlt.begin();

    for(;kj != khlt.end(); ++kj){
        bool preselection = m_singleObjectSelection(toc[*kj]);
        if (preselection){
            fillSingleObjectPlots(toc[*kj], weight);
            cands.push_back( toc[*kj]);
        }
    }

}

Member Data Documentation

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

const int FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::CombinedObjectPlotter = 1

staticprivate

Definition at line 122 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

int FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_combinedObjectDimension

private

Definition at line 113 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::vector< edm::ParameterSet > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_combinedObjectDrawables

private

Definition at line 124 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

StringCutObjectSelector<std::vector<TOutputCandidateType> > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_combinedObjectSelection

private

Definition at line 116 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

StringObjectFunction<std::vector<TOutputCandidateType> > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_combinedObjectSortFunction

private

Definition at line 117 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::string FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_dqmhistolabel

private

Definition at line 109 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::string FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_filterPartialName

private

Definition at line 111 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

edm::InputTag FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_input

private

Definition at line 127 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

bool FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_isSetup

private

Definition at line 126 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::string FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_pathPartialName

private

Definition at line 110 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::map<std::string, std::shared_ptr<StringObjectFunction<std::vector<TOutputCandidateType> > > > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_plottersCombinedObject

private

Definition at line 118 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::map<std::string, std::shared_ptr<StringObjectFunction<TInputCandidateType > > > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_plottersSingleObject

private

Definition at line 119 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::map<std::string, int > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_plotterType

private

Definition at line 123 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::vector< edm::ParameterSet > FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_singleObjectDrawables

private

Definition at line 125 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

StringCutObjectSelector<TInputCandidateType> FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_singleObjectSelection

private

Definition at line 115 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

std::map<std::string, edm::EDGetToken> FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::m_tokens

private

Definition at line 128 of file FSQDiJetAve.cc.

template<class TInputCandidateType , class TOutputCandidateType , SpecialFilters filter = None>

const int FSQ::HandlerTemplate< TInputCandidateType, TOutputCandidateType, filter >::SingleObjectPlotter = 0

staticprivate

xxx

Definition at line 121 of file FSQDiJetAve.cc.