TopHLTOfflineDQMHelper.h

Go to the documentation of this file.

#ifndef TOPHLTOFFLINEDQMHELPER
#define TOPHLTOFFLINEDQMHELPER

#include <string>
#include <vector>
//#include <math>
#include "TString.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Common/interface/TriggerNames.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"

/*Originally from DQM/Physics package, written by Roger Wolf and Jeremy Andrea*/
inline bool 
acceptHLT(const edm::Event& event, const edm::TriggerResults& triggerTable, const std::string& triggerPath)
{
  bool passed=false;
  const edm::TriggerNames& triggerNames = event.triggerNames(triggerTable);
  for(unsigned int i=0; i<triggerNames.triggerNames().size(); ++i){
    TString name = triggerNames.triggerNames()[i].c_str();
    //std::cout << name << " " << triggerTable.accept(i) << std::endl;
    if(name.Contains(TString(triggerPath.c_str()), TString::kIgnoreCase)) {
      if(triggerTable.accept(i)){
          passed=true;
          break;
      }
    }
  }
  return passed;
}

inline bool 
acceptHLT(const edm::Event& event, const edm::TriggerResults& triggerTable, const std::vector<std::string>& triggerPaths)
{
  bool passed=false;
  for(unsigned int j=0; j<triggerPaths.size(); ++j){
    if(acceptHLT(event, triggerTable, triggerPaths[j])){
      passed=true;
      break;
    }
  }
  return passed;
}


#include "DataFormats/JetReco/interface/Jet.h"
#include "FWCore/Framework/interface/EventSetup.h"

#include "DataFormats/METReco/interface/CaloMET.h"
class CalculateHLT {
 public:
  CalculateHLT(int maxNJets, double wMass);
  ~CalculateHLT(){};
     
  double massWBoson(const std::vector<reco::Jet>& jets);
  double massTopQuark(const std::vector<reco::Jet>& jets); 
/*  double tmassWBoson(const T& mu, const reco::CaloMET& met, const reco::Jet& b);
  double tmassTopQuark(const T& mu, const reco::CaloMET& met, const reco::Jet& b);
  double masslb(const T& mu, const reco::CaloMET& met, const reco::Jet& b);*/

  double tmassWBoson(reco::RecoCandidate* mu, const reco::MET& met, const reco::Jet& b);
  double tmassTopQuark(reco::RecoCandidate* mu, const reco::MET& met, const reco::Jet& b);
  double masslb(reco::RecoCandidate* mu, const reco::MET& met, const reco::Jet& b);
  
 private:
  void operator()(const std::vector<reco::Jet>& jets);
  void operator()(const reco::Jet& bJet, reco::RecoCandidate* lepton, const reco::MET& met);
 private:
  bool failed_;
  int maxNJets_;
  double wMass_;
  double massWBoson_;
  double massTopQuark_;
  double tmassWBoson_;
  double tmassTopQuark_;
  double mlb_;


};


#include "DataFormats/JetReco/interface/JetID.h"
#include "DataFormats/JetReco/interface/PFJet.h"
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/BTauReco/interface/JetTag.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "JetMETCorrections/Objects/interface/JetCorrector.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "JetMETCorrections/Objects/interface/JetCorrectionsRecord.h"
#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"

class SelectionStepHLTBase {
  public:
    virtual bool select(const edm::Event& event) {
      return false;
    };

    virtual bool select(const edm::Event& event, const edm::EventSetup& setup) {
      assert(false);
      return false;
    };
};

template <typename Object> 
class SelectionStepHLT: public SelectionStepHLTBase {
public:
  SelectionStepHLT(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC);
  virtual ~SelectionStepHLT(){};

  virtual bool select(const edm::Event& event);
  virtual bool select(const edm::Event& event, const edm::EventSetup& setup); 
  bool selectVertex(const edm::Event& event);
private:
  edm::EDGetTokenT< edm::View<Object> > src_;
  int min_, max_; 
  edm::EDGetTokenT< edm::ValueMap<float> > electronId_;
  int eidPattern_;
  std::string jetCorrector_;
  edm::EDGetTokenT< reco::JetTagCollection > btagLabel_;
  double btagWorkingPoint_;
  edm::EDGetTokenT< reco::JetIDValueMap > jetIDLabel_;

  edm::EDGetTokenT< edm::View<reco::Vertex> > pvs_; 

  StringCutObjectSelector<Object> select_;
  StringCutObjectSelector<reco::JetID>* jetIDSelect_;
};

template <typename Object> 
SelectionStepHLT<Object>::SelectionStepHLT(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC) :
  src_( iC.consumes< edm::View<Object> >(cfg.getParameter<edm::InputTag>( "src"   ))),
  select_( cfg.getParameter<std::string>("select")),
  jetIDSelect_(0)
{
  // construct min/max if the corresponding params
  // exist otherwise they are initialized with -1
  cfg.exists("min") ? min_= cfg.getParameter<int>("min") : min_= -1;
  cfg.exists("max") ? max_= cfg.getParameter<int>("max") : max_= -1;
  // read electron extras if they exist
  if(cfg.existsAs<edm::ParameterSet>("electronId")){ 
    edm::ParameterSet elecId=cfg.getParameter<edm::ParameterSet>("electronId");
    electronId_= iC.consumes< edm::ValueMap<float> >(elecId.getParameter<edm::InputTag>("src"));
    eidPattern_= elecId.getParameter<int>("pattern");
  }
  // read jet corrector label if it exists
  if(cfg.exists("jetCorrector")){ jetCorrector_= cfg.getParameter<std::string>("jetCorrector"); }
  // read btag information if it exists
  if(cfg.existsAs<edm::ParameterSet>("jetBTagger")){
    edm::ParameterSet jetBTagger=cfg.getParameter<edm::ParameterSet>("jetBTagger");
    btagLabel_= iC.consumes< reco::JetTagCollection >(jetBTagger.getParameter<edm::InputTag>("label"));
    btagWorkingPoint_=jetBTagger.getParameter<double>("workingPoint");
  }
  // read jetID information if it exists
  if(cfg.existsAs<edm::ParameterSet>("jetID")){
    edm::ParameterSet jetID=cfg.getParameter<edm::ParameterSet>("jetID");
    jetIDLabel_ = iC.consumes< reco::JetIDValueMap >(jetID.getParameter<edm::InputTag>("label"));
    jetIDSelect_= new StringCutObjectSelector<reco::JetID>(jetID.getParameter<std::string>("select"));
  }
}

template <typename Object> 
bool SelectionStepHLT<Object>::select(const edm::Event& event)
{
  // fetch input collection
  edm::Handle<edm::View<Object> > src; 
  if( !event.getByToken(src_, src) ) return false;

  // load electronId value map if configured such
  edm::Handle<edm::ValueMap<float> > electronId;
  if(!electronId_.isUninitialized()) {
    if( !event.getByToken(electronId_, electronId) ) return false;
  }

  // determine multiplicity of selected objects
  int n=0;
  for(typename edm::View<Object>::const_iterator obj=src->begin(); obj!=src->end(); ++obj){
    // special treatment for electrons
    if(dynamic_cast<const reco::GsfElectron*>(&*obj)){
      unsigned int idx = obj-src->begin();
      if( electronId_.isUninitialized() ? true : ((int)(*electronId)[src->refAt(idx)] & eidPattern_) ){   
    if(select_(*obj))++n;
      }
    }
    // normal treatment
    else{
      if(select_(*obj))++n;
    }
  }
  bool accept=(min_>=0 ? n>=min_:true) && (max_>=0 ? n<=max_:true);
  return (min_<0 && max_<0) ? (n>0):accept;
}
template <typename Object> 
bool SelectionStepHLT<Object>::selectVertex(const edm::Event& event)
{
  // fetch input collection
  edm::Handle<edm::View<Object> > src; 
  if( !event.getByToken(src_, src) ) return false;

  // load electronId value map if configured such
  edm::Handle<edm::ValueMap<float> > electronId;
  if(!electronId_.isUninitialized()) {
    if( !event.getByToken(electronId_, electronId) ) return false;
  }

  // determine multiplicity of selected objects
  int n=0;
  for(typename edm::View<Object>::const_iterator obj=src->begin(); obj!=src->end(); ++obj){
   
      if(select_(*obj))++n;
  }
  bool accept=(min_>=0 ? n>=min_:true) && (max_>=0 ? n<=max_:true);
  return (min_<0 && max_<0) ? (n>0):accept;
}

template <typename Object> 
bool SelectionStepHLT<Object>::select(const edm::Event& event, const edm::EventSetup& setup)
{
  throw cms::Exception("SelectionStepHLT") << "you fail" << std::endl;
  return false;
}
#endif