EmDQM.h

Go to the documentation of this file.

#ifndef HLTriggerOffline_Egamma_EmDQM_H
#define HLTriggerOffline_Egamma_EmDQM_H


// Base Class Headers
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "DataFormats/Common/interface/RefToBase.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"
#include "DQMServices/Core/interface/DQMEDAnalyzer.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/HLTReco/interface/TriggerEventWithRefs.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/L1Trigger/interface/L1EmParticle.h"
#include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"
#include "DataFormats/Common/interface/AssociationMap.h"
#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
#include "HepMC/GenParticle.h"
#include "CommonTools/Utils/interface/PtComparator.h"
#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"

#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/foreach.hpp>

#include "TDirectory.h"
#include "TFile.h"
#include "TH1F.h"
#include <memory>
#include <math.h>
#include <iostream>
#include <string>
#include <vector>
#include <Math/VectorUtil.h>

class EmDQM;

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

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

 private:
  EmDQM* dqm;
};

class EmDQM : public DQMEDAnalyzer{
public:

  friend class HistoFiller<reco::ElectronCollection>;
  friend class HistoFiller<reco::RecoEcalCandidateCollection>;
  friend class HistoFiller<l1extra::L1EmParticleCollection>;

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

  ~EmDQM();

  // Operations

  void analyze(const edm::Event & event, const edm::EventSetup&) override;
  void beginJob();
  void endJob();

  void dqmBeginRun(edm::Run const&, edm::EventSetup const&) override;
  void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override;
  void endRun(edm::Run const&, edm::EventSetup const&) override;

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

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

  // run in automatic configuration generation mode
  bool autoConfMode_;
  // parameter set from config file
  const edm::ParameterSet& pset;
  // global parameters
  edm::InputTag triggerObject_;
  unsigned int verbosity_;
  double genEtaAcc_;
  double genEtAcc_;
  bool isData_;
  double ptMax_;
  double ptMin_;
  double etaMax_;
  double phiMax_;
  unsigned int nbins_;
  unsigned int minEtForEtaEffPlot_;
  bool useHumanReadableHistTitles_;
  bool mcMatchedOnly_;
  bool noPhiPlots_;
  bool noIsolationPlots_;

  bool checkGeneratedParticlesRequirement(const edm::Event &event);

  bool checkRecoParticlesRequirement(const edm::Event & event);

  HLTConfigProvider hltConfig_;

  // routines to build validation configuration from HLTConfiguration
  int countSubstring(const std::string&, const std::string&);
  std::vector<std::vector<std::string> > findEgammaPaths();
  std::vector<std::string> getFilterModules(const std::string&);
  double getPrimaryEtCut(const std::string&);
  edm::ParameterSet makePSetForL1SeedFilter(const std::string&);
  edm::ParameterSet makePSetForL1SeedToSuperClusterMatchFilter(const std::string&);
  edm::ParameterSet makePSetForEtFilter(const std::string&);
  edm::ParameterSet makePSetForOneOEMinusOneOPFilter(const std::string&);
  edm::ParameterSet makePSetForPixelMatchFilter(const std::string&);
  edm::ParameterSet makePSetForEgammaGenericFilter(const std::string&);
  edm::ParameterSet makePSetForEgammaGenericQuadraticFilter(const std::string&);
  edm::ParameterSet makePSetForElectronGenericFilter(const std::string&);
  edm::ParameterSet makePSetForEgammaDoubleEtDeltaPhiFilter(const std::string&);

  // set validation configuration parameters for a trigger path
  void SetVarsFromPSet(std::vector<edm::ParameterSet>::iterator);

  // generated parameter set for trigger path
  std::vector<edm::ParameterSet> paramSets;
  // input from generated parameter set
  unsigned int pathIndex;
  std::vector<edm::InputTag> theHLTCollectionLabels;  
  unsigned int numOfHLTCollectionLabels;  // Will be size of above vector
  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::vector<unsigned int> nCandCuts;
  // paramters for generator study
  unsigned int reqNum;
  int   pdgGen;
  // plotting parameters
  double plotEtMin;
  double plotPtMin ;
  double plotPtMax ;

  edm::InputTag gencutCollection_;

  unsigned int gencut_;

  std::vector<std::set<std::string> > hltCollectionLabelsFoundPerPath;
  std::set<std::string> hltCollectionLabelsFound;

  std::vector<std::set<std::string> > hltCollectionLabelsMissedPerPath;
  std::set<std::string> hltCollectionLabelsMissed;


  //          Create Histogram containers
  // Et & eta distributions
  std::vector<std::vector<MonitorElement*> > etahists;
  std::vector<std::vector<MonitorElement*> > phihists;
  std::vector<std::vector<MonitorElement*> > ethists;
  std::vector<std::vector<MonitorElement*> > etahistmatchs;
  std::vector<std::vector<MonitorElement*> > phihistmatchs;
  std::vector<std::vector<MonitorElement*> > ethistmatchs;
  std::vector<std::vector<MonitorElement*> > histEtOfHltObjMatchToGens;
  std::vector<std::vector<MonitorElement*> > histEtaOfHltObjMatchToGens;
  std::vector<std::vector<MonitorElement*> > histPhiOfHltObjMatchToGens;
  // Plots of efficiency per step
  std::vector<MonitorElement*> totals;
  std::vector<MonitorElement*> totalmatchs;
  //generator histograms
  std::vector<MonitorElement*> etgens;
  std::vector<MonitorElement*> etagens;
  std::vector<MonitorElement*> phigens;

  GreaterByPt<reco::Particle> pTComparator_;
  GreaterByPt<reco::GenParticle> pTGenComparator_;

  // tokens for data access
  edm::EDGetTokenT<edm::View<reco::Candidate> > genParticles_token;
  edm::EDGetTokenT<trigger::TriggerEventWithRefs> triggerObject_token;
  edm::EDGetTokenT<edm::TriggerResults> hltResults_token;
  edm::EDGetTokenT<edm::View<reco::Candidate> > gencutColl_fidWenu_token;
  edm::EDGetTokenT<edm::View<reco::Candidate> > gencutColl_fidZee_token;
  edm::EDGetTokenT<edm::View<reco::Candidate> > gencutColl_fidTripleEle_token;
  edm::EDGetTokenT<edm::View<reco::Candidate> > gencutColl_fidGammaJet_token;
  edm::EDGetTokenT<edm::View<reco::Candidate> > gencutColl_fidDiGamma_token;
  edm::EDGetTokenT<edm::View<reco::Candidate> > gencutColl_manualConf_token;

  // static variables
  //
  // trigger types considered
  static const unsigned TYPE_SINGLE_ELE = 0;
  static const unsigned TYPE_DOUBLE_ELE = 1;
  static const unsigned TYPE_SINGLE_PHOTON = 2;
  static const unsigned TYPE_DOUBLE_PHOTON = 3;
  static const unsigned TYPE_TRIPLE_ELE = 4;

  // verbosity levels
  static const unsigned OUTPUT_SILENT = 0;
  static const unsigned OUTPUT_ERRORS = 1;
  static const unsigned OUTPUT_WARNINGS = 2;
  static const unsigned OUTPUT_ALL = 3;
};
#endif