TrigObjTnPHistColl.h

Go to the documentation of this file.

#ifndef DQM_HLTEvF_TrigObjTnPHistColl_h
#define DQM_HLTEvF_TrigObjTnPHistColl_h

//********************************************************************************
//
// Description:
//   Manages a set of histograms intended for tag and probe efficiency measurements
//   using TriggerObjects stored in TriggerEvent as the input 
//   selection is limited to basic et/eta/phi cuts and trigger filter requirements
//   The idea that this can run on any of the following data formats RAW,RECO,AOD
//   or even as part of the HLT job
//
//   All histograms in a TrigObjTnPHistColl share the same tag defination and 
//   currently the same probe et/eta/phi cuts. The tag trigger requirements may be
//   to pass multiple triggers anded or ored together
//
//   The TrigObjTnPHistColl then has a series of histograms which are filled for 
//   probes which pass a specified filter. For each specified filter, a set of 
//   2D histograms are produced, <var> vs mass where var is configuable via python
//   These histograms may have additional cuts, eg eta cuts which limit them to barrel
//   or endcap

//   This allows us to get the mass spectrum in each bin to allow signal & bkg fits 
//
// Class Structure
//   TrigObjTnPHistColl : master object which manages a series of histograms which 
//                        share a common tag defination. It selects tag and probe pairs
//                        and then sends selected probes to fill the relavent histograms
//
//   FilterSelector : specifies and cuts on the trigger filters an object has to pass.
//                    It allows ANDed and ORing of trigger filter requirements.
//                    It acheives this by grouping the filters in sets of filters (FilterSet)
//                    and an object either has to pass all of those filters in the sets or 
//                    any of those filters in the set.
//                    An object can then be required to pass all defined FilterSets or any of them
//
//   PathSelector : checks that a given path has fired. Was originally supposed to use instead
//                  GenericTriggerEventFlag but that class was awkward to use in the 
//                  concurrentME workflow so PathSelector was created to mimic the required 
//                  functionality. It was a quick port of GenericTriggerEventFlag adapted to 
//                  to work in our desired workflow and may be replaced/reworked in the future
//
//   TrigObjVarF : allows arbitary access to a given float variable of trigger::TriggerObject
//                 it can also return the abs value of that variable if so requested
//  
//   HistFiller : stores the variable a histogram is to be filled with and any cuts the object
//                must additional pass. It then can fill/not fill a histogram using this information
//
//   HistDefs : has all the information necesary to define a histograms to be produced. 
//              The Data sub struct containts the HistFiller object, the binning of the 
//              histogram and name /title suffexs. There is one set of histogram definations
//              for a TrigObjTnPHistColl so each probe filter has identical binning
//              Each booked histogram contains a local copy of the approprate HistFiller
//              
//   HistColl : a collection of histograms to be filled by a probe passing a particular trigger 
//              and kinematic selection. Histograms may have additional further selection on the 
//              probe (eg limiting to the barrel etc). Each histogram is booked using the central 
//              histogram definations and contains a copy of the approprate HistFiller
//
//   ProbeData : a specific filter for a probe object to pass with a collection of histograms to
//               fill managed by HistColl. The filter is not measured by FilterSelector as it is
//               intentionally limited to only a single filter
//
//   TrigObjTnPHistColl : single tag selection and generic requirements for a probe
//      |
//      |--> collection of ProbeData : a set of histos to fill for probes passing a given filter
//              |
//              |--> ProbeData : filter to pass to fill histograms + histograms
//                    |
//                    |--> HistColl : hists for it to be filled
//                           | 
//                           |--> collection of HistFillters+their hists, histfillter fills the hist
//
// Author : Sam Harper , RAL, Aug 2018
//
//***********************************************************************************


#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"

#include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
#include "DQMOffline/Trigger/interface/VarRangeCutColl.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/ConcurrentMonitorElement.h"
#include "DataFormats/HLTReco/interface/TriggerEvent.h"


class TrigObjTnPHistColl {
public:
  
  class FilterSelector {
  public:
    class FilterSet {
    public:
      explicit FilterSet(const edm::ParameterSet& config);
      static edm::ParameterSetDescription makePSetDescription();
      const trigger::Keys getPassingKeys(const trigger::TriggerEvent& trigEvt)const;
                     
    private: 
      std::vector<std::string> filters_;
      bool isAND_;
    };
    
  public:
    explicit FilterSelector(const edm::ParameterSet& config); 
    static edm::ParameterSetDescription makePSetDescription();
    const trigger::Keys getPassingKeys(const trigger::TriggerEvent& trigEvt)const;
  private:
    //helper functions
    static void mergeTrigKeys(trigger::Keys& keys,const trigger::Keys& keysToMerge,bool isAND);
    static void cleanTrigKeys(trigger::Keys& keys);
    
    std::vector<FilterSet> filterSets_;
    bool isAND_;
    
  };

  //A rather late addition to replace GenericTriggerEventFlag as it was incompatible with the 
  //move to concurrentMEs as GenericTriggerEventFlag owns tokens
  //its more or less a direct port of that class, with the functions inspired by it
  //obviously much less feature rich, only handles HLT
  class PathSelector { 
  public:
    PathSelector(const edm::ParameterSet& config);
    static edm::ParameterSetDescription makePSetDescription();
    void init(const HLTConfigProvider& hltConfig);
    bool operator()(const edm::TriggerResults& trigResults,const edm::TriggerNames& trigNames)const;
  private:
    static std::string expandSelectionStr(const std::string& selStr,const HLTConfigProvider& hltConfig,bool isAND,int verbose);
    static std::string expandPath(const std::string& pathPattern, const HLTConfigProvider& hltConfig,bool isAND,int verbose);
    
    std::string selectionStr_; //with wildcard etc
    std::string expandedSelStr_; //with wildcards expanded, set by init
    bool isANDForExpandedPaths_;
    int verbose_;
    bool isInited_;
  };
    
  class TrigObjVarF {
  public:
    explicit TrigObjVarF(std::string varName);
    float operator()(const trigger::TriggerObject& obj)const{
      return isAbs_ ? std::abs((obj.*varFunc_)()) : (obj.*varFunc_)();
    }
  private:
    float (trigger::TriggerObject::*varFunc_)()const;
    bool isAbs_;
  };

  class HistFiller { 
  public:
    explicit HistFiller(const edm::ParameterSet& config);
    static edm::ParameterSetDescription makePSetDescription();
    void operator()(const trigger::TriggerObject& probe,float mass,const ConcurrentMonitorElement& hist)const;    
  private:
    VarRangeCutColl<trigger::TriggerObject> localCuts_;
    TrigObjVarF var_;
  };

  //Histogram Defination, defines the histogram (name,title,bins,how its filled)
  class HistDefs { 
  private:
    class Data { 
    public:
      explicit Data(const edm::ParameterSet& config); 
      static edm::ParameterSetDescription makePSetDescription();
      ConcurrentMonitorElement book(DQMStore::ConcurrentBooker& iBooker,const std::string& name,const std::string& title,const std::vector<float>& massBins)const;
      const HistFiller& filler()const{return histFiller_;}
    private:
      HistFiller histFiller_;
      std::vector<float> bins_;
      std::string nameSuffex_;
      std::string titleSuffex_;
    };  
  public:
    explicit HistDefs(const edm::ParameterSet& config);  
    static edm::ParameterSetDescription makePSetDescription();
    std::vector<std::pair<HistFiller,ConcurrentMonitorElement> > bookHists(DQMStore::ConcurrentBooker& iBooker,const std::string& name,const std::string& title)const;
  private:
    std::vector<Data> histData_;
    std::vector<float> massBins_;
  };

  class HistColl {
  public:
    HistColl(){}
    void bookHists(DQMStore::ConcurrentBooker& iBooker,const std::string& name,
           const std::string& title,const HistDefs& histDefs);
    void fill(const trigger::TriggerObject& probe,float mass)const;
  private:
    std::vector<std::pair<HistFiller,ConcurrentMonitorElement> > hists_;
  };


  class ProbeData {
  public:
    explicit ProbeData(std::string probeFilter):probeFilter_(std::move(probeFilter)){}
    void bookHists(const std::string& tagName,DQMStore::ConcurrentBooker& iBooker,const HistDefs& histDefs);
    void fill(const trigger::size_type tagKey,const trigger::TriggerEvent& trigEvt,const VarRangeCutColl<trigger::TriggerObject>& probeCuts)const;

  private:
    std::string probeFilter_;
    HistColl hists_;
  };
  
public:
  TrigObjTnPHistColl(const edm::ParameterSet& config);
  static edm::ParameterSetDescription makePSetDescription();
  void init(const HLTConfigProvider& hltConfig){evtTrigSel_.init(hltConfig);}
  void bookHists(DQMStore::ConcurrentBooker& iBooker);
  void fill(const trigger::TriggerEvent& trigEvt,
        const edm::TriggerResults& trigResults,
        const edm::TriggerNames& trigNames)const;

private: 
  //helper function, probably should go in a utilty class
  static const trigger::Keys getKeys(const trigger::TriggerEvent& trigEvt,const std::string& filterName);
  
  VarRangeCutColl<trigger::TriggerObject> tagCuts_,probeCuts_;
  FilterSelector tagFilters_;
  std::string collName_;
  std::string folderName_;
  HistDefs histDefs_;
  std::vector<ProbeData> probeHists_; 
  PathSelector evtTrigSel_;

};


#endif