SusyNtuple/MCWeighter.h

#ifndef SusyNtuple_MCWeighter_h
#define SusyNtuple_MCWeighter_h

#include "TChain.h"
#include "TString.h"

#include "SUSYTools/SUSYCrossSection.h"
#include "SusyNtuple/SusyDefs.h"

#include <string>

class TH1F;
namespace Susy{ class Event; }


class MCWeighter
{

 public:
  struct SumwMapKey {
    unsigned int dsid;
    int proc;
  SumwMapKey(): dsid(0), proc(0) {}
  SumwMapKey(unsigned int d, int p): dsid(d), proc(p){}
  };

  public:

  //typedef std::pair<unsigned int, int> SumwMapKey;
typedef std::map<SumwMapKey, float> SumwMap;

    //
    // Enums to control weighting options
    //

    // Sumw method
    enum SumwMethod
    {
      Sumw_NT = 0,      // Use sumw stored in the ntuple
      Sumw_MAP          // Use SumwMap (recommended)
      //Sumw_FILE       // Use a text file for sumw (not supported)
    };

    // Xsec method
    enum XsecMethod
    {
      Xsec_NT = 0,      // Use xsec stored in the ntuple
      Xsec_ST           // Use xsec from SUSYTools (recommended)
    };

    // Systematic
    enum WeightSys
    {
      Sys_NOM = 0,
      Sys_XSEC_UP,
      Sys_XSEC_DN,
      Sys_PILEUP_UP,
      Sys_PILEUP_DN,
      Sys_N
    };

    struct ProcessValidator {
    ProcessValidator() : counts_total(0), counts_invalid(0), max_warnings(4), valid(false), last(0) {}
      size_t counts_total;
      size_t counts_invalid;
      size_t max_warnings;
      ProcessValidator& zero_hack(int &value) { value = 0; valid = true; return *this; }
      ProcessValidator& validate(int &value);
      bool valid; 
      int last; 
      std::string summary() const;

      static int convertDefaultSusyNt2DefaultSusyTools(const int &v);
      static const int defaultSusyNt = -1; 
      static const int defaultSusyTools = 0; 

    };

    //
    // Initialization and configuration
    //

    MCWeighter();
    MCWeighter(TTree* tree,
               std::string xsecDir = "$ROOTCOREDIR/data/SUSYTools/mc12_8TeV/");
    ~MCWeighter();


    void buildSumwMap(TTree* tree);
    void clearAndRebuildSumwMap(TTree* tree) { m_sumwMap.clear(); buildSumwMap(tree); }
    void dumpSumwMap() const;
    void dumpXsecCache() const;
    void dumpXsecDb() const;

    void setUseProcSumw(bool useProcSumw=true) { m_useProcSumw = useProcSumw; }
    void setSumwMethod(SumwMethod opt=Sumw_MAP) { m_sumwMethod = opt; }
    void setXsecMethod(XsecMethod opt=Xsec_ST) { m_xsecMethod = opt; }

    float getMCWeight(const Susy::Event* evt, const float lumi = LUMI_A_A3, WeightSys sys=Sys_NOM);
    bool sumwmapHasKey(SumwMapKey k);

    float total_sumw; 
    float getSumw(const Susy::Event* evt);
    SUSY::CrossSectionDB::Process getCrossSection(const Susy::Event* evt);
    float getXsecTimesEff(const Susy::Event* evt, WeightSys sys=Sys_NOM);
    float getPileupWeight(const Susy::Event* evt, WeightSys sys=Sys_NOM);

    MCWeighter& setLabelBinCounter(const std::string &v);

    size_t parseAdditionalXsecFile(const std::string &filename, bool verbose);
    size_t parseAdditionalXsecDirectory(const std::string &dir, bool verbose);
    MCWeighter& setAllowInvalid(bool v);
    MCWeighter& setVerbose(bool v);

    static std::string defaultLabelBinCounter(const unsigned int &dsid, bool verbose);
    static void checkHistoHasBin(const TH1F &histo, const std::string &binLabel);
    static std::string defaultXsecDir() {
      return std::string("$ROOTCOREBIN/data/SUSYTools/mc15_13TeV/");
    }
    static std::vector<std::string> xsecFilesForSimplifiedModels();
    static std::vector<int> dsidsForKnownSimpliedModelSamples(bool verbose);

    static bool isFormattedAsSusyCrossSection(std::string filename, bool verbose);
    static std::vector<int> readDsidsFromSusyCrossSectionFile(std::string filename, bool verbose);
    static bool readDsidsFromSusyCrossSectionLine(const std::string &line, int &dsid, bool verbose);

    static bool isSimplifiedModel(const unsigned int &dsid, bool verbose);
    static const Susy::Event& readFirstEvent(TTree* tree);
    static int extractProcessFromCutflowHistoname(const std::string &histoName, const std::string &prefix);
 private:
    void buildSumwMapFromTree(TTree* tree);
    void buildSumwMapFromChain(TChain* chain);

    bool m_useProcSumw;

    // typedefs, for convenience
    typedef std::pair<int, int> intpair;
    typedef std::map<intpair, SUSY::CrossSectionDB::Process> XSecMap;

    SumwMethod m_sumwMethod;
    XsecMethod m_xsecMethod;

    // Map of (MCID, proc) -> sumw
    SumwMap m_sumwMap;

    SUSY::CrossSectionDB m_xsecDB;
    XSecMap m_xsecCache;

    std::string m_labelBinCounter; 
    size_t m_warningCounter;
    bool m_allowInvalid; 
    ProcessValidator m_procidValidator; 
    bool m_verbose; 
};

inline bool operator<(const MCWeighter::SumwMapKey &a, const MCWeighter::SumwMapKey &b)
{ return a.dsid<b.dsid && a.proc<b.proc; }

#endif