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 Types inherited from FSQ::BaseHandler
typedef dqm::legacy::DQMStore	DQMStore
typedef dqm::legacy::MonitorElement	MonitorElement
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

HandlerTemplate()

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 132 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;
    }

~HandlerTemplate()

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

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

overridedefault

Member Function Documentation

analyze()

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 297 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, newFWLiteAna::found, HltComparatorCreateWorkflow::hltConfig, mps_fire::i, iEvent, L1TEGammaOffline_cfi::triggerNames, 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);
      }
    }

book()

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 152 of file FSQDiJetAve.cc.

References trigObjTnPSource_cfi::bins, dqm::implementation::IBooker::book1D(), EcalMonitorTask_cff::func, HltBtagPostValidation_cff::histoName, mps_fire::i, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and DQMOfflineHeavyIons_cff::todo.

                                                {
      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);
            }
          }
        }
      }
    }

count()

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 mps_fire::i, iEvent, input, edm::HandleBase::isValid(), singleTopDQM_cfi::preselection, runTheMatrix::ret, EgammaValidation_Wenu_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;
    }

fillSingleObjectPlots()

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);
      }
    }

findPathAndFilter()

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 255 of file FSQDiJetAve.cc.

References HltComparatorCreateWorkflow::hltConfig, mps_fire::i, HerwigMaxPtPartonFilter_cfi::moduleLabel, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
      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;
    }

getAndStoreTokens() [1/5]

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);
    }

getAndStoreTokens() [2/5]

template<>

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

virtual

Implements FSQ::BaseHandler.

Definition at line 440 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);
  }

getAndStoreTokens() [3/5]

template<>

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

virtual

Implements FSQ::BaseHandler.

Definition at line 508 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);
  }

getAndStoreTokens() [4/5]

template<>

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

virtual

Implements FSQ::BaseHandler.

Definition at line 600 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);
  }

getAndStoreTokens() [5/5]

template<>

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

virtual

Implements FSQ::BaseHandler.

Definition at line 649 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);
  }

getBestCombination()

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 362 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, HLT_2022v12_cff::distance, mps_fire::i, jetUpdater_cfi::sort, 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;
          currentCombinationFromCands.reserve(m_combinedObjectDimension);
          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;
    }

getFilteredCands() [1/8]

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 231 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, edm::InputTag::encode(), mps_fire::i, iEvent, edm::HandleBase::isValid(), singleTopDQM_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));
        }
      }
    }

getFilteredCands() [2/8]

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 446 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, mps_fire::i, iEvent, edm::HandleBase::isValid(), singleTopDQM_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());
      }
    }
  }

getFilteredCands() [3/8]

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 476 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, and iEvent.

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

getFilteredCands() [4/8]

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 488 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, and iEvent.

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

getFilteredCands() [5/8]

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 518 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, PVValHelper::dxy, PVValHelper::dz, edm::InputTag::encode(), mps_fire::i, iEvent, edm::HandleBase::isValid(), mathSSE::sqrt(), and AlignmentTracksFromVertexSelector_cfi::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
  }

getFilteredCands() [6/8]

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 610 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, edm::InputTag::encode(), mps_fire::i, iEvent, edm::HandleBase::isValid(), singleTopDQM_cfi::preselection, and L1EGammaClusterEmuProducer_cfi::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);
      }
    }
  }

getFilteredCands() [7/8]

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 654 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, mps_fire::i, iEvent, edm::HandleBase::isValid(), singleTopDQM_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;
      }
    }
  }

getFilteredCands() [8/8]

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 685 of file FSQDiJetAve.cc.

References HLT_2022v12_cff::cands, trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), HltComparatorCreateWorkflow::hltConfig, EgHLTOfflineClient_cfi::hltTag, singleTopDQM_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

CombinedObjectPlotter

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

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

staticprivate

Definition at line 123 of file FSQDiJetAve.cc.

m_combinedObjectDimension

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.

m_combinedObjectDrawables

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

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

private

Definition at line 125 of file FSQDiJetAve.cc.

m_combinedObjectSelection

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.

m_combinedObjectSortFunction

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.

m_dqmhistolabel

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.

m_filterPartialName

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.

m_input

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

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

private

Definition at line 128 of file FSQDiJetAve.cc.

m_isSetup

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

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

private

Definition at line 127 of file FSQDiJetAve.cc.

m_pathPartialName

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.

m_plottersCombinedObject

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 119 of file FSQDiJetAve.cc.

m_plottersSingleObject

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 120 of file FSQDiJetAve.cc.

m_plotterType

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

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

private

Definition at line 124 of file FSQDiJetAve.cc.

m_singleObjectDrawables

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

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

private

Definition at line 126 of file FSQDiJetAve.cc.

m_singleObjectSelection

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.

m_tokens

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 129 of file FSQDiJetAve.cc.

SingleObjectPlotter

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

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

staticprivate

xxx

Definition at line 122 of file FSQDiJetAve.cc.