top::EventSelection Class Reference

Perform the event selection on a top::Event object. More...

#include <EventSelection.h>

Collaboration diagram for top::EventSelection:

Public Member Functions
	EventSelection (const std::string &name, const std::vector< std::string > &cutNames, TFile *outputFile, const std::vector< std::unique_ptr< top::ToolLoaderBase > > &toolLoaders, const std::shared_ptr< top::TopConfig > &config, EL::Worker *wk)
	Construct using a vector of cuts. More...
virtual	~EventSelection ()
	Does not do anything. More...
	EventSelection (EventSelection &&other)
	Move constructor. More...
	EventSelection ()=delete
	Default constructor is not allowed. More...
	EventSelection (const EventSelection &)=delete
	Copy is not allowed. More...
EventSelection &	operator= (const EventSelection &)=delete
	Assignment is not allowed. More...
virtual void	countInitial (const float mcEventWeight, const float pileupWeight) const
	Count the number of initial events. More...
virtual void	countGRL (const float mcEventWeight, const float pileupWeight) const
	Count the number of events passing GRL. More...
virtual void	countGoodCalo (const float mcEventWeight, const float pileupWeight) const
	Count the number of events passing Good Calo. More...
virtual void	countPrimaryVertex (const float mcEventWeight, const float pileupWeight) const
	Count the number of events passing Primary Vertex. More...
virtual bool	apply (const top::Event &event) const
	Apply the selection for each event. More...
virtual bool	applyParticleLevel (const top::ParticleLevelEvent &plEvent) const
	Apply the selection for each particle level event. More...
virtual void	finalise () const
	Print some yield information. More...
const std::string	name () const
	Tells you the name of this event selection. More...
std::vector< std::string >	GetFakesMMConfigs () const
	Gives you the lists of the Fakes MM configurations associated to this selection. More...
bool	ToBeSaved () const
	Tells if the event should be saved if it passes this selection. More...

Private Member Functions
virtual void	printCuts ()
	Print a cutflow showing the number of events passing each cut. More...
void	initialiseTopScaleFactorRetriever (const std::shared_ptr< TopConfig > &config)
	Function to setup the tool in one place. More...

Private Attributes
std::vector< std::unique_ptr< EventSelectorBase > >	m_allCuts
	Vector of all the tools that will be used in the analysis. More...
TH1D *	m_cutflow
	The cutflow histogram filled by the tool. More...
TH1D *	m_cutflow_Loose
TH1D *	m_cutflowMCWeights
	Cutflow counting MC weights instead of events. More...
TH1D *	m_cutflowMCWeights_Loose
TH1D *	m_cutflowPUWeights
	Cutflow counting PileUp weights instead of events. More...
TH1D *	m_cutflowPUWeights_Loose
TH1D *	m_cutflowMCPUWeights
	Cutflow counting MC*Pileup weights instead of events. More...
TH1D *	m_cutflowMCPUWeights_Loose
TH1D *	m_cutflowScaleFactors
	Cutflow counting ScaleFactors instead of events. More...
TH1D *	m_cutflowScaleFactors_Loose
TH1D *	m_cutflowParticleLevel
	The particle level cutflow histogram filled by the tool. More...
TH1D *	m_cutflowParticleLevelMCWeights
std::string	m_name
	Name of this selection (you can have multiple selections run in the same job. More...
bool	m_isMC
	To turn on/off confusing messages about mc weights when running on data. More...
std::shared_ptr< TopConfig >	m_config
ScaleFactorRetriever *	m_sfRetriever
	Scale factors. More...
std::size_t	m_nominalHashValue
bool	m_containsInitial
bool	m_containsGRL
bool	m_containsGoodCalo
bool	m_containsPrimaryVertex
unsigned int	m_positionInitial
unsigned int	m_positionGRL
unsigned int	m_positionGoodCalo
unsigned int	m_positionPrimaryVertex
bool	m_toBeSaved

Detailed Description

Perform the event selection on a top::Event object.

Class to perform the event selection and keep track of the number of events passing each cut. It is also responsible for writing out the 4-vectors in the output file if the user so wished.

Definition at line 37 of file EventSelection.h.

Constructor & Destructor Documentation

EventSelection() [1/4]

top::EventSelection::EventSelection	(	const std::string &	name,
		const std::vector< std::string > &	cutNames,
		TFile *	outputFile,
		const std::vector< std::unique_ptr< top::ToolLoaderBase > > &	toolLoaders,
		const std::shared_ptr< top::TopConfig > &	config,
		EL::Worker *	wk
	)

Construct using a vector of cuts.

The user supplies a simple vector of string that contains the cuts that should be applied. The tool will try to load each cut (and quit with and error message if it can't).

It also sets up a histogram which contains all the cuts on the x-axis and each bin is the number of events passing a cut (in order).

Definition at line 34 of file EventSelection.cxx.

                                                                                          :
    m_cutflow(nullptr),
    m_cutflow_Loose(nullptr),
    m_cutflowMCWeights(nullptr),
    m_cutflowMCWeights_Loose(nullptr),
    m_cutflowPUWeights(nullptr),
    m_cutflowPUWeights_Loose(nullptr),
    m_cutflowMCPUWeights(nullptr),
    m_cutflowMCPUWeights_Loose(nullptr),
    m_cutflowScaleFactors(nullptr),
    m_cutflowScaleFactors_Loose(nullptr),
    m_cutflowParticleLevel(nullptr),
    m_cutflowParticleLevelMCWeights(nullptr),
    m_name(name),
    m_isMC(false),
    m_sfRetriever(nullptr),
    m_nominalHashValue(0),
    m_containsInitial(false),
    m_containsGRL(false),
    m_containsGoodCalo(false),
    m_containsPrimaryVertex(false),
    m_positionInitial(0),
    m_positionGRL(0),
    m_positionGoodCalo(0),
    m_positionPrimaryVertex(0),
    m_toBeSaved(false) {
    // We use the nominal hash value so we don't do
    // string comparisions during the event loop
    CP::SystematicSet nominal;
    m_nominalHashValue = nominal.hash();
 
    // need that later for the sf in the cutflow, not especially elegant but works for now
    m_config = config;
    m_isMC = config->isMC();
 
    if (m_isMC) {
      this->initialiseTopScaleFactorRetriever(m_config);
    }
 
    TDirectory* plotDir = outputFile->mkdir(m_name.c_str());
    plotDir->cd();
    if (config->doTightEvents()) {
      m_cutflow = new TH1D("cutflow", (name + " cutflow").c_str(), cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowMCWeights = new TH1D("cutflow_mc", (name + " cutflow MC weights").c_str(),
                                    cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowPUWeights = new TH1D("cutflow_pu", (name + " cutflow PU weights").c_str(),
                                    cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowMCPUWeights = new TH1D("cutflow_mc_pu", (name + " cutflow MC*PU weights").c_str(),
                                      cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowScaleFactors = new TH1D("cutflow_scale_factors", (name + " cutflow ScaleFactors").c_str(),
                                       cutNames.size(), -0.5, cutNames.size() - 0.5);
    }
    if (config->doLooseEvents()) {
      m_cutflow_Loose = new TH1D("cutflow_Loose", (name + " cutflow_Loose").c_str(),
                                 cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowMCWeights_Loose = new TH1D("cutflow_mc_Loose",
                                          (name + " cutflow_Loose MC weights").c_str(),
                                          cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowPUWeights_Loose = new TH1D("cutflow_pu_Loose",
                                          (name + " cutflow_Loose PU weights").c_str(),
                                          cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowMCPUWeights_Loose = new TH1D("cutflow_mc_pu_Loose",
                                            (name + " cutflow_Loose MC*PU weights").c_str(),
                                            cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowScaleFactors_Loose = new TH1D("cutflow_scale_factors_Loose",
                                             (name + " cutflow_Loose ScaleFactors").c_str(),
                                             cutNames.size(), -0.5, cutNames.size() - 0.5);
    }
 
    if (config->doTopParticleLevel()) {
      m_cutflowParticleLevel = new TH1D("cutflow_particle_level",
                                        (name + " cutflow_particle_level").c_str(),
                                        cutNames.size(), -0.5, cutNames.size() - 0.5);
      m_cutflowParticleLevelMCWeights = new TH1D("cutflow_particle_level_mc",
                                                 (name + " cutflow_particle_level_mc").c_str(),
                                                 cutNames.size(), -0.5, cutNames.size() - 0.5);
    }
 
    unsigned int i(0);
    for (const auto& currentCutName : cutNames) {
      //look through all the libraries and load any tools
      top::EventSelectorBase* tool = nullptr;
      for (const auto& libraryPtr : toolLoaders) {
        tool = libraryPtr->initTool(m_name, currentCutName, outputFile, config, wk);
        if (tool) break;
      }
 
      if (tool != nullptr) {
        m_allCuts.emplace_back(std::move(tool));
      } else {
        throw std::runtime_error("Could not find " + currentCutName);
      }
 
      // Initlal and GRL
      if (currentCutName == "INITIAL") {
        m_containsInitial = true;
        m_positionInitial = i;
      }
 
      if (currentCutName == "GRL") {
        m_containsGRL = true;
        m_positionGRL = i;
      }
 
      if (currentCutName == "GOODCALO") {
        m_containsGoodCalo = true;
        m_positionGoodCalo = i;
      }
 
      if (currentCutName == "PRIVTX") {
        m_containsPrimaryVertex = true;
        m_positionPrimaryVertex = i;
      }
 
      //some cutflow histograms
      if (config->doTightEvents()) {
        m_cutflow->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowMCWeights->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowPUWeights->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowMCPUWeights->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowScaleFactors->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
      }
      if (config->doLooseEvents()) {
        m_cutflow_Loose->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowMCWeights_Loose->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowPUWeights_Loose->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowMCPUWeights_Loose->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
        m_cutflowScaleFactors_Loose->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
      }
 
      if (m_cutflowParticleLevel) {
        m_cutflowParticleLevel->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
      }
 
      if (m_cutflowParticleLevelMCWeights) {
        m_cutflowParticleLevelMCWeights->GetXaxis()->SetBinLabel(i + 1, m_allCuts[i]->name().c_str());
      }
 
      if (currentCutName == "SAVE") {
        m_toBeSaved = true;
      }
 
      ++i;
    }
 
    //be nice to the user and tell them what they enabled
    //at the very start of the run.  It allows them to quit the program
    //if they notice a problem.
    printCuts();
  }

~EventSelection()

virtual top::EventSelection::~EventSelection ( )

inlinevirtual

Does not do anything.

Definition at line 56 of file EventSelection.h.

{}

EventSelection() [2/4]

top::EventSelection::EventSelection

(

EventSelection &&

other

)

Move constructor.

Definition at line 187 of file EventSelection.cxx.

                                                       :
    m_allCuts(std::move(other.m_allCuts)),
    m_cutflow(std::move(other.m_cutflow)),
    m_cutflow_Loose(std::move(other.m_cutflow_Loose)),
    m_cutflowMCWeights(std::move(other.m_cutflowMCWeights)),
    m_cutflowMCWeights_Loose(std::move(other.m_cutflowMCWeights_Loose)),
    m_cutflowPUWeights(std::move(other.m_cutflowPUWeights)),
    m_cutflowPUWeights_Loose(std::move(other.m_cutflowPUWeights_Loose)),
    m_cutflowMCPUWeights(std::move(other.m_cutflowMCPUWeights)),
    m_cutflowMCPUWeights_Loose(std::move(other.m_cutflowMCPUWeights_Loose)),
    m_cutflowScaleFactors(std::move(other.m_cutflowScaleFactors)),
    m_cutflowScaleFactors_Loose(std::move(other.m_cutflowScaleFactors_Loose)),
    m_cutflowParticleLevel(std::move(other.m_cutflowParticleLevel)),
    m_cutflowParticleLevelMCWeights(std::move(other.m_cutflowParticleLevelMCWeights)),
    m_name(std::move(other.m_name)),
    m_isMC(std::move(other.m_isMC)),
    m_config(std::move(other.m_config)),
    m_sfRetriever(nullptr),
    m_nominalHashValue(std::move(other.m_nominalHashValue)),
    m_containsInitial(std::move(other.m_containsInitial)),
    m_containsGRL(std::move(other.m_containsGRL)),
    m_containsGoodCalo(std::move(other.m_containsGoodCalo)),
    m_containsPrimaryVertex(std::move(other.m_containsPrimaryVertex)),
    m_positionInitial(std::move(other.m_positionInitial)),
    m_positionGRL(std::move(other.m_positionGRL)),
    m_positionGoodCalo(std::move(other.m_positionGoodCalo)),
    m_positionPrimaryVertex(std::move(other.m_positionPrimaryVertex)),
    m_toBeSaved(std::move(other.m_toBeSaved)) {
    // need this to calculate the lepton SF for the cutflow
    if (m_isMC) {
      this->initialiseTopScaleFactorRetriever(m_config);
    }
  }

EventSelection() [3/4]

top::EventSelection::EventSelection ( )

delete

Default constructor is not allowed.

EventSelection() [4/4]

top::EventSelection::EventSelection ( const EventSelection &  )

delete

Copy is not allowed.

Member Function Documentation

apply()

bool top::EventSelection::apply ( const top::Event &  event ) const

virtual

Apply the selection for each event.

This loops through all the configured cuts in order and looks to see if the top::Event passes them or not. It fills the cutflow histogram if the events passes.

Parameters

event

This is not modified by the cuts so is const. In the event loop each event is passed to this function and the cuts are applied and the results recorded.

Returns

If the event passes all cuts, or at least all those before SAVE then true will be returned - which means that this event passes the selection - and false otherwise. The selection flag will be set accordingly. In case of true if SAVE is present then the event will be saved.

Definition at line 301 of file EventSelection.cxx.

                                                        {
    unsigned int i(0);
    bool passEvent(false);
 
    for (const auto& currentCut : m_allCuts) {
      const bool passed = currentCut->apply(event);
 
      if (!passed) break;
 
      double mcweight = 1.;
      double puweight = 1.;
      double leptonSF = 1.;
 
      if (m_isMC) {
          mcweight = event.m_info->auxdataConst<float>("AnalysisTop_eventWeight");
 
          if (top::ScaleFactorRetriever::hasPileupSF(event)) puweight = top::ScaleFactorRetriever::pileupSF(event);
 
          leptonSF = m_sfRetriever->leptonSF(event, top::topSFSyst::nominal);
      }
 
      //add cutflow information for the nominal (not systematic) selection
      //For data we have (sometimes) the same event with loose and tight
      //The cutflow is just the "analysis" -> tight to avoid double counting
      if (event.m_hashValue == m_nominalHashValue) {
        bool countThisCut(true);
        if (m_containsInitial && i == m_positionInitial) {
          countThisCut = false;
        }
        if (m_containsGRL && i == m_positionGRL) {
          countThisCut = false;
        }
        if (m_containsGoodCalo && i == m_positionGoodCalo) {
          countThisCut = false;
        }
        if (m_containsPrimaryVertex && i == m_positionPrimaryVertex) {
          countThisCut = false;
        }
        if (countThisCut) {
          if (m_config->doTightEvents() && !event.m_isLoose) {
            m_cutflow->Fill(i);
            m_cutflowMCWeights->Fill(i, mcweight);
            m_cutflowPUWeights->Fill(i, puweight);
            m_cutflowMCPUWeights->Fill(i, mcweight * puweight);
            m_cutflowScaleFactors->Fill(i, leptonSF);
          }
          if (m_config->doLooseEvents() && event.m_isLoose) {
            m_cutflow_Loose->Fill(i);
            m_cutflowMCWeights_Loose->Fill(i, mcweight);
            m_cutflowPUWeights_Loose->Fill(i, puweight);
            m_cutflowMCPUWeights_Loose->Fill(i, mcweight * puweight);
            m_cutflowScaleFactors_Loose->Fill(i, leptonSF);
          }
        }
      }
 
      passEvent |= (currentCut->name() == "SAVE");
      ++i;
    }
 
    // If "SAVE" wasn't found but event passes all cuts, event passes the selection
    passEvent |= (i == m_allCuts.size());
 
    return passEvent;
  }

applyParticleLevel()

bool top::EventSelection::applyParticleLevel ( const top::ParticleLevelEvent &  plEvent ) const

virtual

Apply the selection for each particle level event.

This loops through all the cuts configured for reco (nominal) level to see if the top::ParticleLevelEvent passes them or not. It also fills the particle level cutflow histogram corresponding to the stage up to which the event passes through the event selection.

Parameters

plEvent

This is the particle level event which is in question. It will not be modified by any of the cuts.

Returns

If the event passes all cuts, or at least all those before SAVE then true will be returned - which means that this event passes the selection - and false otherwise. The selection flag will be set accordingly. In case of true if SAVE is present then the event will be saved.

Definition at line 367 of file EventSelection.cxx.

                                                                                    {
    // In principle, this function should never be called for non-active
    // particle level. However, for code safetly, include a null pointer
    // check. Return false here because "do-not-do-particle-level" is equivalent
    // to "do-no-save-particle-level".
    if (not m_cutflowParticleLevel) {
      return false;
    }
    if (not m_cutflowParticleLevelMCWeights) {
      return false;
    }
 
    unsigned int i(0);
    bool passEvent(false);
 
    for (const auto& currentCut : m_allCuts) {
      const bool passed = currentCut->applyParticleLevel(plEvent);
 
      if (!passed) break;
 
      m_cutflowParticleLevel->Fill(i);
 
      double mcweight = plEvent.m_info->mcEventWeight(0);
      m_cutflowParticleLevelMCWeights->Fill(i, mcweight);
 
      passEvent |= (currentCut->name() == "SAVE");
      ++i;
    }
 
    // If "SAVE" wasn't found but event passes all cuts, event passes the selection
    passEvent |= (i == m_allCuts.size());
 
    return passEvent;
  }

countGoodCalo()

void top::EventSelection::countGoodCalo ( const float  mcEventWeight, const float  pileupWeight  ) const

virtual

Count the number of events passing Good Calo.

Definition at line 267 of file EventSelection.cxx.

                                                                                              {
    if (m_containsGoodCalo) {
      if (m_config->doTightEvents()) {
        m_cutflow->Fill(m_positionGoodCalo);
        m_cutflowMCWeights->Fill(m_positionGoodCalo, mcEventWeight);
        m_cutflowPUWeights->Fill(m_positionGoodCalo, pileupWeight);
        m_cutflowMCPUWeights->Fill(m_positionGoodCalo, mcEventWeight * pileupWeight);
      }
      if (m_config->doLooseEvents()) {
        m_cutflow_Loose->Fill(m_positionGoodCalo);
        m_cutflowMCWeights_Loose->Fill(m_positionGoodCalo, mcEventWeight);
        m_cutflowPUWeights_Loose->Fill(m_positionGoodCalo, pileupWeight);
        m_cutflowMCPUWeights_Loose->Fill(m_positionGoodCalo, mcEventWeight * pileupWeight);
      }
    }
  }

countGRL()

void top::EventSelection::countGRL ( const float  mcEventWeight, const float  pileupWeight  ) const

virtual

Count the number of events passing GRL.

Definition at line 250 of file EventSelection.cxx.

                                                                                         {
    if (m_containsGRL) {
      if (m_config->doTightEvents()) {
        m_cutflow->Fill(m_positionGRL);
        m_cutflowMCWeights->Fill(m_positionGRL, mcEventWeight);
        m_cutflowPUWeights->Fill(m_positionGRL, pileupWeight);
        m_cutflowMCPUWeights->Fill(m_positionGRL, mcEventWeight * pileupWeight);
      }
      if (m_config->doLooseEvents()) {
        m_cutflow_Loose->Fill(m_positionGRL);
        m_cutflowMCWeights_Loose->Fill(m_positionGRL, mcEventWeight);
        m_cutflowPUWeights_Loose->Fill(m_positionGRL, pileupWeight);
        m_cutflowMCPUWeights_Loose->Fill(m_positionGRL, mcEventWeight * pileupWeight);
      }
    }
  }

countInitial()

void top::EventSelection::countInitial ( const float  mcEventWeight, const float  pileupWeight  ) const

virtual

Count the number of initial events.

Definition at line 233 of file EventSelection.cxx.

                                                                                             {
    if (m_containsInitial) {
      if (m_config->doTightEvents()) {
        m_cutflow->Fill(m_positionInitial);
        m_cutflowMCWeights->Fill(m_positionInitial, mcEventWeight);
        m_cutflowPUWeights->Fill(m_positionInitial, pileupWeight);
        m_cutflowMCPUWeights->Fill(m_positionInitial, mcEventWeight * pileupWeight);
      }
      if (m_config->doLooseEvents()) {
        m_cutflow_Loose->Fill(m_positionInitial);
        m_cutflowMCWeights_Loose->Fill(m_positionInitial, mcEventWeight);
        m_cutflowPUWeights_Loose->Fill(m_positionInitial, pileupWeight);
        m_cutflowMCPUWeights_Loose->Fill(m_positionInitial, mcEventWeight * pileupWeight);
      }
    }
  }

countPrimaryVertex()

void top::EventSelection::countPrimaryVertex ( const float  mcEventWeight, const float  pileupWeight  ) const

virtual

Count the number of events passing Primary Vertex.

Definition at line 284 of file EventSelection.cxx.

                                                                                                   {
    if (m_containsPrimaryVertex) {
      if (m_config->doTightEvents()) {
        m_cutflow->Fill(m_positionPrimaryVertex);
        m_cutflowMCWeights->Fill(m_positionPrimaryVertex, mcEventWeight);
        m_cutflowPUWeights->Fill(m_positionPrimaryVertex, pileupWeight);
        m_cutflowMCPUWeights->Fill(m_positionPrimaryVertex, mcEventWeight * pileupWeight);
      }
      if (m_config->doLooseEvents()) {
        m_cutflow_Loose->Fill(m_positionPrimaryVertex);
        m_cutflowMCWeights_Loose->Fill(m_positionPrimaryVertex, mcEventWeight);
        m_cutflowPUWeights_Loose->Fill(m_positionPrimaryVertex, pileupWeight);
        m_cutflowMCPUWeights_Loose->Fill(m_positionPrimaryVertex, mcEventWeight * pileupWeight);
      }
    }
  }

finalise()

void top::EventSelection::finalise ( ) const

virtual

Print some yield information.

This is not done in the destructor because we might not have a file open at that point in time.

Definition at line 402 of file EventSelection.cxx.

                                      {
    //2dp, neater output for numbers
    MsgStream& msgInfo = msg(MSG::Level::INFO);
    msgInfo << std::right;
    if (m_isMC) msgInfo << std::fixed << std::setprecision(2);
 
    if (m_config->doTightEvents()) {
      //channel name
      msgInfo << " - " << m_name << " cutflow:\n";
 
      //some headings
      msgInfo << std::setw(7) << "" <<
        std::setw(30) << "cut" <<
        std::setw(15) << "events";
 
      if (m_isMC)
        msgInfo << std::setw(15) << "mc weights" <<
          std::setw(15) << "mc*pu weights" <<
          std::setw(15) << "lepton SF" <<
          std::setw(15) << "b-tag SF";
 
      if (m_cutflowParticleLevel) {
        msgInfo << std::setw(15) << "particle level";
      }
 
      if (m_cutflowParticleLevelMCWeights) {
        msgInfo << std::setw(15) << "particle level mc";
      }
 
      msgInfo << "\n";
 
      //cutflow table content
      for (int i = 1; i <= m_cutflow->GetNbinsX(); ++i) {
        msgInfo << "    " << std::setw(3) << i
          << std::setw(30) << m_cutflow->GetXaxis()->GetBinLabel(i)
          << std::setw(15) << m_cutflow->GetBinContent(i);
 
        if (m_isMC)
          msgInfo << std::setw(15) << m_cutflowMCWeights->GetBinContent(i)
            << std::setw(15) << m_cutflowMCPUWeights->GetBinContent(i)
            << std::setw(15) << m_cutflowScaleFactors->GetBinContent(i);
 
        if (m_cutflowParticleLevel) {
          msgInfo << std::setw(15) << m_cutflowParticleLevel->GetBinContent(i);
        }
 
        if (m_cutflowParticleLevelMCWeights) {
          msgInfo << std::setw(15) << m_cutflowParticleLevelMCWeights->GetBinContent(i);
        }
 
        msgInfo << "\n";
      }
    }
    if (m_config->doLooseEvents()) {
      //channel name
      msgInfo << " - " << m_name << " cutflow (Loose):\n";
 
      //some headings
      msgInfo << std::setw(7) << "" <<
        std::setw(30) << "cut" <<
        std::setw(15) << "events";
 
      if (m_isMC)
        msgInfo << std::setw(15) << "mc weights" <<
          std::setw(15) << "mc*pu weights" <<
          std::setw(15) << "lepton SF" <<
          std::setw(15) << "b-tag SF";
 
      if (m_cutflowParticleLevel) {
        msgInfo << std::setw(15) << "particle level";
      }
 
      if (m_cutflowParticleLevelMCWeights) {
        msgInfo << std::setw(15) << "particle level mc";
      }
 
      msgInfo << "\n";
 
      //cutflow table content
      for (int i = 1; i <= m_cutflow_Loose->GetNbinsX(); ++i) {
        msgInfo << "    " << std::setw(3) << i
          << std::setw(30) << m_cutflow_Loose->GetXaxis()->GetBinLabel(i)
          << std::setw(15) << m_cutflow_Loose->GetBinContent(i);
 
        if (m_isMC)
          msgInfo << std::setw(15) << m_cutflowMCWeights_Loose->GetBinContent(i)
            << std::setw(15) << m_cutflowMCPUWeights_Loose->GetBinContent(i)
            << std::setw(15) << m_cutflowScaleFactors_Loose->GetBinContent(i);
 
        if (m_cutflowParticleLevel) {
          msgInfo << std::setw(15) << m_cutflowParticleLevel->GetBinContent(i);
        }
 
        if (m_cutflowParticleLevelMCWeights) {
          msgInfo << std::setw(15) << m_cutflowParticleLevelMCWeights->GetBinContent(i);
        }
 
        msgInfo << "\n";
      }
    }
    msgInfo << "\n";
    msgInfo.doOutput();
  }

GetFakesMMConfigs()

std::vector< std::string > top::EventSelection::GetFakesMMConfigs

(

)

const

Gives you the lists of the Fakes MM configurations associated to this selection.

Returns

The list of configurations

Definition at line 510 of file EventSelection.cxx.

                                                               {
    std::vector<std::string> configs;
    for (const auto& currentCutName : m_allCuts) {
      if (currentCutName->name() != "FAKESMMCONFIGS") continue;
      else {
        FakesMMConfigs* conf = dynamic_cast<FakesMMConfigs*>(currentCutName.get());
        for (const std::string& s : conf->configurations())
          configs.push_back(s);
      }
    }
    return configs;
  }

initialiseTopScaleFactorRetriever()

void top::EventSelection::initialiseTopScaleFactorRetriever ( const std::shared_ptr< TopConfig > &  config )

private

Function to setup the tool in one place.

Definition at line 221 of file EventSelection.cxx.

                                                                                               {
    // Define this once, and then use it when needed
    if (asg::ToolStore::contains<ScaleFactorRetriever>("top::ScaleFactorRetriever")) {
      m_sfRetriever = asg::ToolStore::get<ScaleFactorRetriever>("top::ScaleFactorRetriever");
    } else {
      top::ScaleFactorRetriever* topSFR = new top::ScaleFactorRetriever("top::ScaleFactorRetriever");
      top::check(asg::setProperty(topSFR, "config", config), "Failed to set config");
      top::check(topSFR->initialize(), "Failed to initalialise");
      m_sfRetriever = topSFR;
    }
  }

name()

const std::string top::EventSelection::name

(

)

const

Tells you the name of this event selection.

Returns

The name of this event selection

Definition at line 506 of file EventSelection.cxx.

                                             {
    return m_name;
  }

operator=()

EventSelection& top::EventSelection::operator= ( const EventSelection &  )

delete

Assignment is not allowed.

printCuts()

void top::EventSelection::printCuts ( )

privatevirtual

Print a cutflow showing the number of events passing each cut.

Definition at line 523 of file EventSelection.cxx.

                                 {
    MsgStream& msgInfo = msg(MSG::Level::INFO);
    msgInfo << "\n - " << m_name << ":\n";
    if (m_config->doTightEvents()) {
      for (int i = 1; i <= m_cutflow->GetNbinsX(); ++i) {
        msgInfo << "    " << std::setw(3) << i
          << std::setw(30) << m_cutflow->GetXaxis()->GetBinLabel(i)
          << "\n";
      }
    } else if (m_config->doLooseEvents()) {
      for (int i = 1; i <= m_cutflow_Loose->GetNbinsX(); ++i) {
        msgInfo << "    " << std::setw(3) << i
          << std::setw(30) << m_cutflow_Loose->GetXaxis()->GetBinLabel(i)
          << "\n";
      }
    }
    msgInfo << std::endl;
    msgInfo.doOutput();
  }

ToBeSaved()

bool top::EventSelection::ToBeSaved ( ) const

inline

Tells if the event should be saved if it passes this selection.

Returns

If one of the cuts is called SAVE, returns true

Definition at line 157 of file EventSelection.h.

{return m_toBeSaved;};

Member Data Documentation

m_allCuts

std::vector<std::unique_ptr<EventSelectorBase> > top::EventSelection::m_allCuts

private

Vector of all the tools that will be used in the analysis.

Definition at line 165 of file EventSelection.h.

m_config

std::shared_ptr<TopConfig> top::EventSelection::m_config

private

Definition at line 201 of file EventSelection.h.

m_containsGoodCalo

bool top::EventSelection::m_containsGoodCalo

private

Definition at line 215 of file EventSelection.h.

m_containsGRL

bool top::EventSelection::m_containsGRL

private

Definition at line 214 of file EventSelection.h.

m_containsInitial

bool top::EventSelection::m_containsInitial

private

Definition at line 213 of file EventSelection.h.

m_containsPrimaryVertex

bool top::EventSelection::m_containsPrimaryVertex

private

Definition at line 216 of file EventSelection.h.

m_cutflow

TH1D* top::EventSelection::m_cutflow

mutableprivate

The cutflow histogram filled by the tool.

Definition at line 168 of file EventSelection.h.

m_cutflow_Loose

TH1D* top::EventSelection::m_cutflow_Loose

mutableprivate

Definition at line 169 of file EventSelection.h.

m_cutflowMCPUWeights

TH1D* top::EventSelection::m_cutflowMCPUWeights

mutableprivate

Cutflow counting MC*Pileup weights instead of events.

Definition at line 180 of file EventSelection.h.

m_cutflowMCPUWeights_Loose

TH1D* top::EventSelection::m_cutflowMCPUWeights_Loose

mutableprivate

Definition at line 181 of file EventSelection.h.

m_cutflowMCWeights

TH1D* top::EventSelection::m_cutflowMCWeights

mutableprivate

Cutflow counting MC weights instead of events.

Definition at line 172 of file EventSelection.h.

m_cutflowMCWeights_Loose

TH1D* top::EventSelection::m_cutflowMCWeights_Loose

mutableprivate

Definition at line 173 of file EventSelection.h.

m_cutflowParticleLevel

TH1D* top::EventSelection::m_cutflowParticleLevel

mutableprivate

The particle level cutflow histogram filled by the tool.

Definition at line 188 of file EventSelection.h.

m_cutflowParticleLevelMCWeights

TH1D* top::EventSelection::m_cutflowParticleLevelMCWeights

mutableprivate

Definition at line 189 of file EventSelection.h.

m_cutflowPUWeights

TH1D* top::EventSelection::m_cutflowPUWeights

mutableprivate

Cutflow counting PileUp weights instead of events.

Definition at line 176 of file EventSelection.h.

m_cutflowPUWeights_Loose

TH1D* top::EventSelection::m_cutflowPUWeights_Loose

mutableprivate

Definition at line 177 of file EventSelection.h.

m_cutflowScaleFactors

TH1D* top::EventSelection::m_cutflowScaleFactors

mutableprivate

Cutflow counting ScaleFactors instead of events.

Definition at line 184 of file EventSelection.h.

m_cutflowScaleFactors_Loose

TH1D* top::EventSelection::m_cutflowScaleFactors_Loose

mutableprivate

Definition at line 185 of file EventSelection.h.

m_isMC

bool top::EventSelection::m_isMC

mutableprivate

To turn on/off confusing messages about mc weights when running on data.

Definition at line 198 of file EventSelection.h.

m_name

std::string top::EventSelection::m_name

private

Name of this selection (you can have multiple selections run in the same job.

Definition at line 195 of file EventSelection.h.

m_nominalHashValue

std::size_t top::EventSelection::m_nominalHashValue

private

Definition at line 209 of file EventSelection.h.

m_positionGoodCalo

unsigned int top::EventSelection::m_positionGoodCalo

private

Definition at line 219 of file EventSelection.h.

m_positionGRL

unsigned int top::EventSelection::m_positionGRL

private

Definition at line 218 of file EventSelection.h.

m_positionInitial

unsigned int top::EventSelection::m_positionInitial

private

Definition at line 217 of file EventSelection.h.

m_positionPrimaryVertex

unsigned int top::EventSelection::m_positionPrimaryVertex

private

Definition at line 220 of file EventSelection.h.

m_sfRetriever

ScaleFactorRetriever* top::EventSelection::m_sfRetriever

private

Scale factors.

Definition at line 204 of file EventSelection.h.

m_toBeSaved

bool top::EventSelection::m_toBeSaved

private

Definition at line 225 of file EventSelection.h.

---

The documentation for this class was generated from the following files:

• EventSelection.h
• EventSelection.cxx