EmDQMReco.h

Go to the documentation of this file.

#ifndef HLTriggerOffline_Egamma_EmDQMReco_H
#define HLTriggerOffline_Egamma_EmDQMReco_H

// Base Class Headers
#include "CommonTools/Utils/interface/PtComparator.h"
#include "DQMServices/Core/interface/DQMEDAnalyzer.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DataFormats/Common/interface/AssociationMap.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/RefToBase.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/HLTReco/interface/TriggerEventWithRefs.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
#include "HepMC/GenParticle.h"
#include "TDirectory.h"
#include <vector>

#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/scoped_ptr.hpp>

class EmDQMReco;

template <class T>
class HistoFillerReco {
public:
  HistoFillerReco(EmDQMReco *d) : dqm(d){};
  ~HistoFillerReco(){};

  void fillHistos(edm::Handle<trigger::TriggerEventWithRefs> &triggerObj,
                  const edm::Event &iEvent,
                  unsigned int n,
                  std::vector<reco::Particle> &sortedReco,
                  bool plotReco,
                  bool plotMonpath);
  std::vector<edm::EDGetTokenT<edm::AssociationMap<edm::OneToValue<T, float>>>> isoNameTokens_;

private:
  EmDQMReco *dqm;
};

class EmDQMReco : public DQMEDAnalyzer {
  //----------------------------------------

  class FourVectorMonitorElements {
  public:
    FourVectorMonitorElements(EmDQMReco *_parent,
                              DQMStore::IBooker &iBooker,
                              const std::string &histogramNameTemplate,
                              const std::string &histogramTitleTemplate);

    void fill(const math::XYZTLorentzVector &momentum);

  private:
    EmDQMReco *parent;

    MonitorElement *etMonitorElement;
    MonitorElement *etaMonitorElement;
    MonitorElement *phiMonitorElement;
  };
  //----------------------------------------

public:
  friend class HistoFillerReco<reco::ElectronCollection>;
  friend class HistoFillerReco<reco::RecoEcalCandidateCollection>;
  friend class HistoFillerReco<l1extra::L1EmParticleCollection>;

  explicit EmDQMReco(const edm::ParameterSet &pset);

  ~EmDQMReco() override;

  // Operations
  void analyze(const edm::Event &event, const edm::EventSetup &) override;
  void dqmBeginRun(const edm::Run &, const edm::EventSetup &) override;
  void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override;

private:
  // Input from cfg file

  std::vector<edm::InputTag> theHLTCollectionLabels;

  unsigned int numOfHLTCollectionLabels;  // Will be size of above vector

  bool useHumanReadableHistTitles;
  std::vector<std::string> theHLTCollectionHumanNames;  // Human-readable names for the collections
  // edm::InputTag theL1Seed;
  std::vector<int> theHLTOutputTypes;
  std::vector<bool> plotiso;
  std::vector<std::vector<edm::InputTag>> isoNames;  // there has to be a better solution
  std::vector<std::pair<double, double>> plotBounds;
  std::string theHltName;
  HLTConfigProvider hltConfig_;
  bool isHltConfigInitialized_;

  //          Read from configuration file                  //
  // parameters for generator study
  unsigned int reqNum;
  int pdgGen;
  double recoEtaAcc;
  double recoEtAcc;
  // plotting paramters
  double plotEtaMax;
  double plotPtMin;
  double plotPtMax;
  double plotPhiMax;

  unsigned int plotBins;

  // preselction cuts
  // edm::InputTag recocutCollection_;
  unsigned int recocut_;

  std::string triggerNameRecoMonPath;

  std::string processNameRecoMonPath;

  edm::EDGetTokenT<reco::GsfElectronCollection> recoElectronsInput;
  edm::EDGetTokenT<std::vector<reco::SuperCluster>> recoObjectsEBT;
  edm::EDGetTokenT<std::vector<reco::SuperCluster>> recoObjectsEET;
  edm::EDGetTokenT<edm::TriggerResults> hltResultsT;
  edm::EDGetTokenT<trigger::TriggerEventWithRefs> triggerObjT;
  //          Create Histograms                             //

  // std::vector<MonitorElement*> etahist;
  //  std::vector<MonitorElement*> ethist;
  //  std::vector<MonitorElement*> phiHist;

  boost::ptr_vector<FourVectorMonitorElements> standardHist;

  //  std::vector<MonitorElement*> etahistmatchreco;
  //  std::vector<MonitorElement*> ethistmatchreco;
  //  std::vector<MonitorElement*> phiHistMatchReco;
  boost::ptr_vector<FourVectorMonitorElements> histMatchReco;

  //  std::vector<MonitorElement*> etahistmatchrecomonpath;
  //  std::vector<MonitorElement*> ethistmatchrecomonpath;
  //  std::vector<MonitorElement*> phiHistMatchRecoMonPath;
  boost::ptr_vector<FourVectorMonitorElements> histMatchRecoMonPath;

  //  std::vector<MonitorElement*> histEtOfHltObjMatchToReco;
  //  std::vector<MonitorElement*> histEtaOfHltObjMatchToReco;
  //  std::vector<MonitorElement*> histPhiOfHltObjMatchToReco;
  boost::ptr_vector<FourVectorMonitorElements> histHltObjMatchToReco;

  std::vector<MonitorElement *> etahistiso;
  std::vector<MonitorElement *> ethistiso;
  std::vector<MonitorElement *> phiHistIso;

  std::vector<MonitorElement *> etahistisomatchreco;
  std::vector<MonitorElement *> ethistisomatchreco;
  std::vector<MonitorElement *> phiHistIsoMatchReco;

  std::vector<MonitorElement *> histEtIsoOfHltObjMatchToReco;
  std::vector<MonitorElement *> histEtaIsoOfHltObjMatchToReco;
  std::vector<MonitorElement *> histPhiIsoOfHltObjMatchToReco;
  MonitorElement *totalreco;
  MonitorElement *totalmatchreco;

  //  MonitorElement* etreco;
  //  MonitorElement* etareco;
  //  MonitorElement* phiReco;
  boost::scoped_ptr<FourVectorMonitorElements> histReco;

  //  MonitorElement* etrecomonpath;
  //  MonitorElement* etarecomonpath;
  //  MonitorElement* phiRecoMonPath;
  boost::scoped_ptr<FourVectorMonitorElements> histRecoMonpath;

  //  MonitorElement* etahistmonpath;
  //  MonitorElement* ethistmonpath;
  //  MonitorElement* phiHistMonPath;
  boost::scoped_ptr<FourVectorMonitorElements> histMonpath;
  int eventnum;
  // int prescale;

  // interface to DQM framework
  std::string dirname_;

  HistoFillerReco<reco::ElectronCollection> *histoFillerEle;
  HistoFillerReco<reco::RecoEcalCandidateCollection> *histoFillerClu;
  HistoFillerReco<l1extra::L1EmParticleCollection> *histoFillerL1NonIso;
  HistoFillerReco<reco::RecoEcalCandidateCollection> *histoFillerPho;
  HistoFillerReco<l1extra::L1EmParticleCollection> *histoFillerL1Iso;

  // template <class T> void
  // fillHistos(edm::Handle<trigger::TriggerEventWithRefs>&,const edm::Event&
  // ,unsigned int, std::vector<reco::Particle>&, bool, bool);
  GreaterByPt<reco::Particle> pTComparator_;
  GreaterByPt<reco::GsfElectron> pTRecoComparator_;

  //----------------------------------------
};
#endif