RooUtil::CutTree Class Reference

#include <cutflowutil.h>

Public Member Functions
void	addCut (TString n)
void	addEventList (int run, int lumi, unsigned long long evt)
void	addHist1D (TH1D *h, std::function< float()> var, TString syst)
void	addHist1DVec (TH1D *h, std::function< std::vector< float >()> var, std::function< std::vector< float >()> wgt, TString syst)
void	addHist2D (TH2F *h, std::function< float()> varx, std::function< float()> vary, TString syst)
void	addHist2DVec (TH2F *h, std::function< std::vector< float >()> varx, std::function< std::vector< float >()> vary, std::function< std::vector< float >()> elemwgt, TString syst)
void	addSyst (TString syst)
void	addSyst (TString syst, std::vector< TString > patterns, std::vector< TString > vetopatterns=std::vector< TString >())
void	clear ()
void	clear_passbits ()
void	clearEventList ()
	CutTree (TString n)
void	evaluate (RooUtil::TTreeX &tx, TString cutsystname="", bool doeventlist=false, bool aggregated_pass=true, float aggregated_weight=1)
void	evaluate_use_internal_variable (RooUtil::TTreeX &tx, TString cutsystname="", bool doeventlist=false, bool aggregated_pass=true, float aggregated_weight=1)
void	evaluate_use_lambda (RooUtil::TTreeX &tx, TString cutsystname="", bool doeventlist=false, bool aggregated_pass=true, float aggregated_weight=1)
void	evaluate_use_ttreex (RooUtil::TTreeX &tx, TString cutsystname="", bool doeventlist=false, bool aggregated_pass=true, float aggregated_weight=1)
void	fillHistograms (TString syst, float extrawgt)
CutTree &	getCut (TString n)
std::vector< TString >	getCutList (TString n, std::vector< TString > cut_list=std::vector< TString >())
std::vector< TString >	getCutListBelow (TString n, std::vector< TString > cut_list=std::vector< TString >())
CutTree *	getCutPointer (TString n)
std::vector< TString >	getEndCuts (std::vector< TString > endcuts=std::vector< TString >())
void	printCuts (int indent=0, std::vector< int > multichild=std::vector< int >())
void	printEventList ()
void	sortEventList ()
void	writeEventList (TString ofilename)
	~CutTree ()

Public Attributes
std::vector< CutTree * >	children
std::vector< std::tuple< int, int, unsigned long long > >	eventlist
std::map< TString, std::vector< std::tuple< TH1D *, std::function< float()> > > >	hists1d
std::map< TString, std::vector< std::tuple< TH1D *, std::function< std::vector< float >)>, std::function< std::vector< float >)> > > >	hists1dvec
std::map< TString, std::vector< std::tuple< TH2F *, std::function< float()>, std::function< float()> > > >	hists2d
std::map< TString, std::vector< std::tuple< TH2F *, std::function< std::vector< float >)>, std::function< std::vector< float >)>, std::function< std::vector< float >)> > > >	hists2dvec
TString	name
CutTree *	parent
std::vector< CutTree * >	parents
int	pass
bool	pass_this_cut
std::function< bool()>	pass_this_cut_func
std::vector< TString >	systcutnames
std::vector< CutTree * >	systcuts
std::vector< int >	systpasses
std::map< TString, CutTree * >	systs
std::vector< float >	systweights
float	weight
float	weight_this_cut
std::function< float()>	weight_this_cut_func

Detailed Description

Definition at line 76 of file cutflowutil.h.

Constructor & Destructor Documentation

CutTree()

RooUtil::CutTree::CutTree ( TString  n )

inline

Definition at line 112 of file cutflowutil.h.

Referenced by addCut(), and addSyst().

: name(n), parent(0), pass(false), weight(0) {}

~CutTree()

RooUtil::CutTree::~CutTree ( )

inline

Definition at line 113 of file cutflowutil.h.

References submitPVValidationJobs::child, and children.

               {
      for (auto& child : children) {
        if (child)
          delete child;
      }
    }

Member Function Documentation

addCut()

void RooUtil::CutTree::addCut ( TString  n )

inline

Definition at line 181 of file cutflowutil.h.

References children, CutTree(), create_idmaps::n, and getGTfromDQMFile::obj.

                           {
      CutTree* obj = new CutTree(n);
      obj->parent = this;
      obj->parents.push_back(this);
      children.push_back(obj);
    }

addEventList()

void RooUtil::CutTree::addEventList ( int  run, int  lumi, unsigned long long  evt  )

inline

Definition at line 516 of file cutflowutil.h.

References eventlist, and writedatasetfile::run.

                                                                 {
      eventlist.push_back(std::make_tuple(run, lumi, evt));
    }

addHist1D()

void RooUtil::CutTree::addHist1D ( TH1D *  h, std::function< float()>  var, TString  syst  )

inline

Definition at line 203 of file cutflowutil.h.

References h, hists1d, push_back(), and ALCARECOEcalPhiSym_cff::var.

                                                                     {
      if (syst.IsNull())
        hists1d["Nominal"].push_back(std::make_tuple(h, var));
      else
        hists1d[syst].push_back(std::make_tuple(h, var));
    }

addHist1DVec()

void RooUtil::CutTree::addHist1DVec ( TH1D *  h, std::function< std::vector< float >()>  var, std::function< std::vector< float >()>  wgt, TString  syst  )

inline

Definition at line 209 of file cutflowutil.h.

References h, hists1dvec, push_back(), and ALCARECOEcalPhiSym_cff::var.

                                    {
      if (syst.IsNull())
        hists1dvec["Nominal"].push_back(std::make_tuple(h, var, wgt));
      else
        hists1dvec[syst].push_back(std::make_tuple(h, var, wgt));
    }

addHist2D()

void RooUtil::CutTree::addHist2D ( TH2F *  h, std::function< float()>  varx, std::function< float()>  vary, TString  syst  )

inline

Definition at line 218 of file cutflowutil.h.

References h, hists2d, and push_back().

                                                                                                {
      if (syst.IsNull())
        hists2d["Nominal"].push_back(std::make_tuple(h, varx, vary));
      else
        hists2d[syst].push_back(std::make_tuple(h, varx, vary));
    }

addHist2DVec()

void RooUtil::CutTree::addHist2DVec ( TH2F *  h, std::function< std::vector< float >()>  varx, std::function< std::vector< float >()>  vary, std::function< std::vector< float >()>  elemwgt, TString  syst  )

inline

Definition at line 224 of file cutflowutil.h.

References h, hists2dvec, and push_back().

                                    {
      if (syst.IsNull())
        hists2dvec["Nominal"].push_back(std::make_tuple(h, varx, vary, elemwgt));
      else
        hists2dvec[syst].push_back(std::make_tuple(h, varx, vary, elemwgt));
    }

addSyst() [1/2]

void RooUtil::CutTree::addSyst ( TString  syst )

inline

Definition at line 187 of file cutflowutil.h.

References children, CutTree(), getGTfromDQMFile::obj, parent, parents, systcutnames, systcuts, systpasses, systs, and systweights.

Referenced by addSyst().

                               {
      // If already added ignore
      if (systs.find(syst) != systs.end())
        return;
      // Syst CutTree object knows the parents, and children, however, the children does not know the syst-counter-part parent, nor the parent knows the syste-counter-part children.
      CutTree* obj = new CutTree(this->name + syst);
      systs[syst] = obj;
      systcutnames.push_back(syst);
      systcuts.push_back(obj);
      systpasses.push_back(1);
      systweights.push_back(1);
      obj->children = this->children;
      obj->parents = this->parents;
      obj->parent = this->parent;
    }

addSyst() [2/2]

void RooUtil::CutTree::addSyst ( TString  syst, std::vector< TString >  patterns, std::vector< TString >  vetopatterns = std::vector<TString>()  )

inline

Definition at line 328 of file cutflowutil.h.

References addSyst(), children, name, topSingleLeptonDQM_PU_cfi::pattern, and relval_cleanedupgrade::veto.

                                                                         {
      for (auto& pattern : patterns)
        if (name.Contains(pattern)) {
          bool veto = false;
          for (auto& vetopattern : vetopatterns) {
            if (name.Contains(vetopattern))
              veto = true;
          }
          if (not veto)
            addSyst(syst);
        }
      for (auto& child : children)
        child->addSyst(syst, patterns, vetopatterns);
    }

clear()

void RooUtil::CutTree::clear ( void  )

inline

Definition at line 322 of file cutflowutil.h.

References children, and pass.

                 {
      pass = false;
      weight = 0;
      for (auto& child : children)
        child->clear();
    }

clear_passbits()

void RooUtil::CutTree::clear_passbits ( )

inline

Definition at line 344 of file cutflowutil.h.

References children, and pass.

Referenced by evaluate_use_internal_variable(), and evaluate_use_lambda().

                          {
      pass = 0;
      weight = 0;
      for (auto& child : children)
        child->clear_passbits();
    }

clearEventList()

void RooUtil::CutTree::clearEventList ( )

inline

Definition at line 515 of file cutflowutil.h.

References eventlist.

{ eventlist.clear(); }

evaluate()

void RooUtil::CutTree::evaluate ( RooUtil::TTreeX &  tx, TString  cutsystname = "", bool  doeventlist = false, bool  aggregated_pass = true, float  aggregated_weight = 1  )

inline

Definition at line 350 of file cutflowutil.h.

References evaluate_use_internal_variable(), evaluate_use_lambda(), and evaluate_use_ttreex().

                                               {
#ifdef USE_TTREEX
      evaluate_use_ttreex(tx, cutsystname, doeventlist, aggregated_pass, aggregated_weight);
#else
#ifdef USE_CUTLAMBDA
      evaluate_use_lambda(tx, cutsystname, doeventlist, aggregated_pass, aggregated_weight);
#else
      evaluate_use_internal_variable(tx, cutsystname, doeventlist, aggregated_pass, aggregated_weight);
#endif
#endif
    }

evaluate_use_internal_variable()

void RooUtil::CutTree::evaluate_use_internal_variable ( RooUtil::TTreeX &  tx, TString  cutsystname = "", bool  doeventlist = false, bool  aggregated_pass = true, float  aggregated_weight = 1  )

inline

Definition at line 425 of file cutflowutil.h.

References children, clear_passbits(), eventlist, RooUtil::TTreeX::getBranch(), RooUtil::TTreeX::hasBranch(), parent, pass, pass_this_cut, systs, and weight_this_cut.

Referenced by evaluate().

                                                                     {
      if (!parent) {
        clear_passbits();
        pass = 1;
        weight = 1;
      } else {
        if (cutsystname.IsNull()) {
          pass = pass_this_cut && aggregated_pass;
          weight = weight_this_cut * aggregated_weight;
          if (!pass)
            return;
        } else {
          if (systs.find(cutsystname) == systs.end()) {
            pass = pass_this_cut && aggregated_pass;
            weight = weight_this_cut * aggregated_weight;
            if (!pass)
              return;
          } else {
            pass = systs[cutsystname]->pass_this_cut && aggregated_pass;
            weight = systs[cutsystname]->weight_this_cut * aggregated_weight;
            if (!pass)
              return;
          }
        }
      }
      if (doeventlist and pass and cutsystname.IsNull()) {
        if (tx.hasBranch<int>("run") && tx.hasBranch<int>("lumi") && tx.hasBranch<unsigned long long>("evt")) {
          eventlist.push_back(std::make_tuple(
              tx.getBranch<int>("run"), tx.getBranch<int>("lumi"), tx.getBranch<unsigned long long>("evt")));
        }
      }
      for (auto& child : children)
        child->evaluate_use_internal_variable(tx, cutsystname, doeventlist, pass, weight);
    }

evaluate_use_lambda()

void RooUtil::CutTree::evaluate_use_lambda ( RooUtil::TTreeX &  tx, TString  cutsystname = "", bool  doeventlist = false, bool  aggregated_pass = true, float  aggregated_weight = 1  )

inline

Definition at line 365 of file cutflowutil.h.

References children, clear_passbits(), eventlist, RooUtil::TTreeX::getBranch(), RooUtil::TTreeX::hasBranch(), mps_check::msg, name, parent, pass, pass_this_cut_func, systs, RooUtil::warning(), and weight_this_cut_func.

Referenced by evaluate().

                                                          {
      if (!parent) {
        clear_passbits();
        pass = 1;
        weight = 1;
      } else {
        if (cutsystname.IsNull()) {
          if (pass_this_cut_func) {
            pass = pass_this_cut_func() && aggregated_pass;
            weight = weight_this_cut_func() * aggregated_weight;
            if (!pass)
              return;
          } else {
            TString msg = "cowardly passing the event because cut and weight func not set! cut name = " + name;
            warning(msg);
            pass = aggregated_pass;
            weight = aggregated_weight;
          }
        } else {
          if (systs.find(cutsystname) == systs.end()) {
            if (pass_this_cut_func) {
              pass = pass_this_cut_func() && aggregated_pass;
              weight = weight_this_cut_func() * aggregated_weight;
              if (!pass)
                return;
            } else {
              TString msg = "cowardly passing the event because cut and weight func not set! cut name = " + name;
              warning(msg);
              pass = aggregated_pass;
              weight = aggregated_weight;
            }
          } else {
            if (systs[cutsystname]->pass_this_cut_func) {
              pass = systs[cutsystname]->pass_this_cut_func() && aggregated_pass;
              weight = systs[cutsystname]->weight_this_cut_func() * aggregated_weight;
              if (!pass)
                return;
            } else {
              TString msg = "cowardly passing the event because cut and weight func not set! cut name = " + name +
                            " syst name = " + cutsystname;
              warning(msg);
              pass = aggregated_pass;
              weight = aggregated_weight;
            }
          }
        }
      }
      if (doeventlist and pass and cutsystname.IsNull()) {
        if (tx.hasBranch<int>("run") && tx.hasBranch<int>("lumi") && tx.hasBranch<unsigned long long>("evt")) {
          eventlist.push_back(std::make_tuple(
              tx.getBranch<int>("run"), tx.getBranch<int>("lumi"), tx.getBranch<unsigned long long>("evt")));
        }
      }
      for (auto& child : children)
        child->evaluate_use_lambda(tx, cutsystname, doeventlist, pass, weight);
    }

evaluate_use_ttreex()

void RooUtil::CutTree::evaluate_use_ttreex ( RooUtil::TTreeX &  tx, TString  cutsystname = "", bool  doeventlist = false, bool  aggregated_pass = true, float  aggregated_weight = 1  )

inline

Definition at line 463 of file cutflowutil.h.

References children, eventlist, RooUtil::TTreeX::getBranch(), RooUtil::TTreeX::hasBranch(), name, parent, pass, and systs.

Referenced by evaluate().

                                                          {
      if (!parent) {
        pass = tx.getBranch<bool>(name);
        weight = tx.getBranch<float>(name + "_weight");
      } else {
        if (cutsystname.IsNull()) {
          if (!tx.hasBranch<bool>(name))
            return;
          pass = tx.getBranch<bool>(name) && aggregated_pass;
          weight = tx.getBranch<float>(name + "_weight") * aggregated_weight;
        } else {
          if (systs.find(cutsystname) == systs.end()) {
            if (!tx.hasBranch<bool>(name))
              return;
            pass = tx.getBranch<bool>(name) && aggregated_pass;
            weight = tx.getBranch<float>(name + "_weight") * aggregated_weight;
          } else {
            if (!tx.hasBranch<bool>(name + cutsystname))
              return;
            pass = tx.getBranch<bool>(name + cutsystname) && aggregated_pass;
            weight = tx.getBranch<float>(name + cutsystname + "_weight") * aggregated_weight;
          }
        }
      }
      if (doeventlist and pass and cutsystname.IsNull()) {
        if (tx.hasBranch<int>("run") && tx.hasBranch<int>("lumi") && tx.hasBranch<unsigned long long>("evt")) {
          eventlist.push_back(std::make_tuple(
              tx.getBranch<int>("run"), tx.getBranch<int>("lumi"), tx.getBranch<unsigned long long>("evt")));
        }
      }
      for (auto& child : children)
        child->evaluate_use_ttreex(tx, cutsystname, doeventlist, pass, weight);
    }

fillHistograms()

void RooUtil::CutTree::fillHistograms ( TString  syst, float  extrawgt  )

inline

Definition at line 520 of file cutflowutil.h.

References children, h, hists1d, hists1dvec, hists2d, hists2dvec, mps_fire::i, mps_check::msg, or, pass, THist, mkLumiAveragedPlots::tuple, and RooUtil::warning().

                                                      {
      // If the cut didn't pass then stop
      if (!pass)
        return;

      if (hists1d.size() != 0 or hists2d.size() != 0 or hists2dvec.size() != 0 or hists1dvec.size() != 0) {
        TString systkey = syst.IsNull() ? "Nominal" : syst;
        for (auto& tuple : hists1d[systkey]) {
          THist* h = std::get<0>(tuple);
          std::function<float()> vardef = std::get<1>(tuple);
          h->Fill(vardef(), weight * extrawgt);
        }
        for (auto& tuple : hists2d[systkey]) {
          TH2F* h = std::get<0>(tuple);
          std::function<float()> varxdef = std::get<1>(tuple);
          std::function<float()> varydef = std::get<2>(tuple);
          h->Fill(varxdef(), varydef(), weight * extrawgt);
        }
        for (auto& tuple : hists1dvec[systkey]) {
          THist* h = std::get<0>(tuple);
          std::function<std::vector<float>()> vardef = std::get<1>(tuple);
          std::function<std::vector<float>()> wgtdef = std::get<2>(tuple);
          std::vector<float> varx = vardef();
          std::vector<float> elemwgts;
          if (wgtdef)
            elemwgts = wgtdef();
          for (unsigned int i = 0; i < varx.size(); ++i) {
            if (wgtdef)
              h->Fill(varx[i], weight * extrawgt * elemwgts[i]);
            else
              h->Fill(varx[i], weight * extrawgt);
          }
        }
        for (auto& tuple : hists2dvec[systkey]) {
          TH2F* h = std::get<0>(tuple);
          std::function<std::vector<float>()> varxdef = std::get<1>(tuple);
          std::function<std::vector<float>()> varydef = std::get<2>(tuple);
          std::function<std::vector<float>()> wgtdef = std::get<3>(tuple);
          std::vector<float> varx = varxdef();
          std::vector<float> vary = varydef();
          if (varx.size() != vary.size()) {
            TString msg =
                "the vector input to be looped over do not have same length for x and y! check the variable definition "
                "for histogram ";
            msg += h->GetName();
            warning(msg);
          }
          std::vector<float> elemwgts;
          if (wgtdef)
            elemwgts = wgtdef();
          for (unsigned int i = 0; i < varx.size(); ++i) {
            if (wgtdef)
              h->Fill(varx[i], vary[i], weight * extrawgt * elemwgts[i]);
            else
              h->Fill(varx[i], vary[i], weight * extrawgt);
          }
        }
      }
      for (auto& child : children)
        child->fillHistograms(syst, extrawgt);
    }

getCut()

CutTree& RooUtil::CutTree::getCut ( TString  n )

inline

Definition at line 263 of file cutflowutil.h.

References DummyCfis::c, RooUtil::error(), getCutPointer(), and create_idmaps::n.

Referenced by getCutList(), and getCutListBelow().

                               {
      CutTree* c = getCutPointer(n);
      if (c) {
        return *c;
      } else {
        RooUtil::error(TString::Format("Asked for %s cut, but did not find the cut", n.Data()));
        return *this;
      }
    }

getCutList()

std::vector<TString> RooUtil::CutTree::getCutList ( TString  n, std::vector< TString >  cut_list = std::vector<TString>()  )

inline

Definition at line 272 of file cutflowutil.h.

References DummyCfis::c, getCut(), create_idmaps::n, and groupFilesInBlocks::reverse.

                                                                                                 {
      // Main idea: start from the end node provided by the first argument "n", and work your way up to the root node.
      //
      // The algorithm will first determine whether I am starting from a specific cut requested by the user or within in recursion.
      // If the cut_list.size() == 0, the function is called by the user (since no list is aggregated so far)
      // In that case, first find the pointer to the object we want and set it to "c"
      // If cut_list.size() is non-zero then take this as the cut that I am starting and I go up the chain to aggregate all the cuts prior to the requested cut
      CutTree* c = 0;
      if (cut_list.size() == 0) {
        c = &getCut(n);
        cut_list.push_back(c->name);
      } else {
        c = this;
        cut_list.push_back(n);
      }
      if (c->parent) {
        return (c->parent)->getCutList((c->parent)->name, cut_list);
      } else {
        std::reverse(cut_list.begin(), cut_list.end());
        return cut_list;
      }
    }

getCutListBelow()

std::vector<TString> RooUtil::CutTree::getCutListBelow ( TString  n, std::vector< TString >  cut_list = std::vector<TString>()  )

inline

Definition at line 303 of file cutflowutil.h.

References DummyCfis::c, children, getCut(), and create_idmaps::n.

                                                                                                      {
      // Main idea: start from the node provided by the first argument "n", and work your way down to the ends.
      CutTree* c = 0;
      if (cut_list.size() == 0) {
        c = &getCut(n);
        cut_list.push_back(c->name);
      } else {
        c = this;
        cut_list.push_back(n);
      }
      if (children.size() > 0) {
        for (auto& child : c->children) {
          cut_list = child->getCutListBelow(child->name, cut_list);
        }
        return cut_list;
      } else {
        return cut_list;
      }
    }

getCutPointer()

CutTree* RooUtil::CutTree::getCutPointer ( TString  n )

inline

Definition at line 248 of file cutflowutil.h.

References DummyCfis::c, children, create_idmaps::n, and name.

Referenced by getCut().

                                      {
      // If the name match then return itself
      if (name.EqualTo(n)) {
        return this;
      } else {
        // Otherwise, loop over the children an if a children has the correct one return the found CutTree
        for (auto& child : children) {
          CutTree* c = child->getCutPointer(n);
          if (c)
            return c;
        }
        return 0;
      }
    }

getEndCuts()

std::vector<TString> RooUtil::CutTree::getEndCuts ( std::vector< TString >  endcuts = std::vector<TString>() )

inline

Definition at line 294 of file cutflowutil.h.

References children, and name.

                                                                                     {
      if (children.size() == 0) {
        endcuts.push_back(name);
        return endcuts;
      }
      for (auto& child : children)
        endcuts = child->getEndCuts(endcuts);
      return endcuts;
    }

printCuts()

void RooUtil::CutTree::printCuts ( int  indent = 0, std::vector< int >  multichild = std::vector<int>()  )

inline

Definition at line 119 of file cutflowutil.h.

References children, makeHLTPrescaleTable::delimiter, spr::find(), RecoTauValidation_cfi::header, mps_fire::i, validateAlignments::indent, submitPVResolutionJobs::key, SiStripPI::min, mps_check::msg, name, pass, RooUtil::print(), systs, and w().

                                                                                 {
      struct winsize w;
      ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
      int colsize = std::min(w.ws_col - 100, 600);
      if (indent == 0) {
        TString header = "Cut name";
        int extra = colsize - header.Length();
        for (int i = 0; i < extra; ++i)
          header += " ";
        header += "|pass|weight|systs";
        print(header);
        TString delimiter = "";
        for (int i = 0; i < w.ws_col - 10; ++i)
          delimiter += "=";
        print(delimiter);
      }
      TString msg = "";
      for (int i = 0; i < indent; ++i) {
        if (std::find(multichild.begin(), multichild.end(), i + 1) != multichild.end()) {
          if (indent == i + 1)
            msg += " +";
          else
            msg += " |";
        } else
          msg += "  ";
      }
      msg += name;
      int extrapad = colsize - msg.Length() > 0 ? colsize - msg.Length() : 0;
      for (int i = 0; i < extrapad; ++i)
        msg += " ";
      //msg += TString::Format("| %d | %.5f|", pass, weight);
      msg += TString::Format("| %d | %f|", pass, weight);
      for (auto& key : systs) {
        msg += key.first + " ";
      }
      print(msg);
      if (children.size() > 1)
        multichild.push_back(indent + 1);
      for (auto& child : children) {
        (*child).printCuts(indent + 1, multichild);
      }
    }

printEventList()

void RooUtil::CutTree::printEventList ( )

inline

Definition at line 161 of file cutflowutil.h.

References gather_cfg::cout, eventlist, mps_check::msg, name, RooUtil::print(), and writedatasetfile::run.

                          {
      print(TString::Format("Print event list for the cut = %s", name.Data()));
      for (auto& eventid : eventlist) {
        int run = std::get<0>(eventid);
        int lumi = std::get<1>(eventid);
        unsigned long long evt = std::get<2>(eventid);
        TString msg = TString::Format("%d:%d:%llu", run, lumi, evt);
        std::cout << msg << std::endl;
      }
    }

sortEventList()

void RooUtil::CutTree::sortEventList ( )

inline

Definition at line 500 of file cutflowutil.h.

References a, b, eventlist, and jetUpdater_cfi::sort.

                         {
      std::sort(
          eventlist.begin(),
          eventlist.end(),
          [](const std::tuple<int, int, unsigned long long>& a, const std::tuple<int, int, unsigned long long>& b) {
            if (std::get<0>(a) != std::get<0>(b))
              return std::get<0>(a) < std::get<0>(b);
            else if (std::get<1>(a) != std::get<1>(b))
              return std::get<1>(a) < std::get<1>(b);
            else if (std::get<2>(a) != std::get<2>(b))
              return std::get<2>(a) < std::get<2>(b);
            else
              return true;
          });
    }

writeEventList()

void RooUtil::CutTree::writeEventList ( TString  ofilename )

inline

Definition at line 171 of file cutflowutil.h.

References eventlist, produceTPGParameters_beamv6_transparency_spikekill_2016_script::outFile, writedatasetfile::run, and mkLumiAveragedPlots::tuple.

                                           {
      std::ofstream outFile(ofilename);
      for (auto& tuple : eventlist) {
        int run = std::get<0>(tuple);
        int lumi = std::get<1>(tuple);
        unsigned long long evt = std::get<2>(tuple);
        outFile << run << ":" << lumi << ":" << evt << std::endl;
      }
      outFile.close();
    }

Member Data Documentation

children

std::vector<CutTree*> RooUtil::CutTree::children

Definition at line 81 of file cutflowutil.h.

Referenced by data_sources.node::__str__(), addCut(), addSyst(), data_sources.node::child(), clear(), clear_passbits(), evaluate_use_internal_variable(), evaluate_use_lambda(), evaluate_use_ttreex(), fillHistograms(), getCutListBelow(), getCutPointer(), getEndCuts(), data_sources.node::is_leaf(), data_sources.node::left_child(), printCuts(), data_sources.node::right_child(), and ~CutTree().

eventlist

std::vector<std::tuple<int, int, unsigned long long> > RooUtil::CutTree::eventlist

Definition at line 111 of file cutflowutil.h.

Referenced by addEventList(), clearEventList(), evaluate_use_internal_variable(), evaluate_use_lambda(), evaluate_use_ttreex(), printEventList(), sortEventList(), and writeEventList().

hists1d

std::map<TString, std::vector<std::tuple< TH1D *, std::function<float()> > > > RooUtil::CutTree::hists1d

Definition at line 96 of file cutflowutil.h.

Referenced by addHist1D(), and fillHistograms().

hists1dvec

std::map<TString, std::vector<std::tuple< TH1D *, std::function<std::vector<float>)>, std::function<std::vector<float>)> > > > RooUtil::CutTree::hists1dvec

Definition at line 99 of file cutflowutil.h.

Referenced by addHist1DVec(), and fillHistograms().

hists2d

std::map<TString, std::vector<std::tuple<TH2F*, std::function<float()>, std::function<float()> > > > RooUtil::CutTree::hists2d

Definition at line 100 of file cutflowutil.h.

Referenced by addHist2D(), and fillHistograms().

hists2dvec

std::map<TString, std::vector<std::tuple<TH2F*, std::function<std::vector<float>)>, std::function<std::vector<float>)>, std::function<std::vector<float>)> > > > RooUtil::CutTree::hists2dvec

Definition at line 106 of file cutflowutil.h.

Referenced by addHist2DVec(), and fillHistograms().

name

TString RooUtil::CutTree::name

Definition at line 78 of file cutflowutil.h.

Referenced by dirstructure.Directory::__create_pie_image(), dqm_interfaces.DirID::__eq__(), dirstructure.Directory::__get_full_path(), dirstructure.Comparison::__get_img_name(), dirstructure.Comparison::__make_image(), dirstructure.Directory::__repr__(), dqm_interfaces.DirID::__repr__(), dirstructure.Comparison::__repr__(), config.CFG::__str__(), addSyst(), dirstructure.Directory::calcStats(), validation.Sample::digest(), evaluate_use_lambda(), evaluate_use_ttreex(), utils.StatisticalTest::get_status(), getCutPointer(), getEndCuts(), VIDSelectorBase.VIDSelectorBase::initialize(), dirstructure.Directory::print_report(), printCuts(), and printEventList().

parent

CutTree* RooUtil::CutTree::parent

Definition at line 79 of file cutflowutil.h.

Referenced by addSyst(), evaluate_use_internal_variable(), evaluate_use_lambda(), and evaluate_use_ttreex().

parents

std::vector<CutTree*> RooUtil::CutTree::parents

Definition at line 80 of file cutflowutil.h.

Referenced by addSyst().

pass

int RooUtil::CutTree::pass

Definition at line 85 of file cutflowutil.h.

Referenced by clear(), clear_passbits(), evaluate_use_internal_variable(), evaluate_use_lambda(), evaluate_use_ttreex(), fillHistograms(), and printCuts().

pass_this_cut

bool RooUtil::CutTree::pass_this_cut

Definition at line 89 of file cutflowutil.h.

Referenced by evaluate_use_internal_variable().

pass_this_cut_func

std::function<bool()> RooUtil::CutTree::pass_this_cut_func

Definition at line 91 of file cutflowutil.h.

Referenced by evaluate_use_lambda().

systcutnames

std::vector<TString> RooUtil::CutTree::systcutnames

Definition at line 82 of file cutflowutil.h.

Referenced by addSyst().

systcuts

std::vector<CutTree*> RooUtil::CutTree::systcuts

Definition at line 83 of file cutflowutil.h.

Referenced by addSyst().

systpasses

std::vector<int> RooUtil::CutTree::systpasses

Definition at line 87 of file cutflowutil.h.

Referenced by addSyst().

systs

std::map<TString, CutTree*> RooUtil::CutTree::systs

Definition at line 84 of file cutflowutil.h.

Referenced by addSyst(), evaluate_use_internal_variable(), evaluate_use_lambda(), evaluate_use_ttreex(), and printCuts().

systweights

std::vector<float> RooUtil::CutTree::systweights

Definition at line 88 of file cutflowutil.h.

Referenced by addSyst().

weight

float RooUtil::CutTree::weight

Definition at line 86 of file cutflowutil.h.

Referenced by dirstructure.Directory::calcStats(), dirstructure.Directory::get_fail_rate(), dirstructure.Directory::get_null_rate(), dirstructure.Directory::get_skiped_rate(), dirstructure.Directory::get_success_rate(), and dirstructure.Directory::print_report().

weight_this_cut

float RooUtil::CutTree::weight_this_cut

Definition at line 90 of file cutflowutil.h.

Referenced by evaluate_use_internal_variable().

weight_this_cut_func

std::function<float()> RooUtil::CutTree::weight_this_cut_func

Definition at line 92 of file cutflowutil.h.

Referenced by evaluate_use_lambda().