analysis::tools::MuonAnalyser Class Reference

#include <MuonAnalyser.h>

Inheritance diagram for analysis::tools::MuonAnalyser:

Public Member Functions
virtual bool	analysisWithMuons ()
float	btag (const Muon &, const std::string &)
virtual void	fillMuonHistograms ()
	MuonAnalyser ()
	constructors More...
	MuonAnalyser (int argc, char *argv[])
virtual void	muonHistograms (const std::string &, const int &n=1)
std::vector< std::shared_ptr< Muon > >	muons ()
virtual bool	onlineL1MuonMatching (const int &)
virtual bool	onlineL3MuonMatching (const int &)
std::vector< std::shared_ptr< Muon > >	onlineMatchedMuons ()
virtual bool	onlineMuonMatching ()
std::vector< std::shared_ptr< Muon > >	selectedMuons ()
virtual bool	selectionMuon (const int &)
virtual bool	selectionMuonDr (const int &r1, const int &r2)
	Given the rankings r1 and r2 of two jets, it returns whether the jets passes the delta_R selection; the threshold delta is passed by the configuration file. More...
virtual bool	selectionMuonDr (const int &r1, const int &r2, const float &delta)
	Given the rankings r1 and r2 of two jets, it returns whether the jets passes the delta_R selection; the threshold delta is passed as an argument (if delta <= 0, |delta| = delta_min; else |delta| = delta_max ) More...
virtual bool	selectionMuonId ()
virtual bool	selectionMuons ()
virtual bool	selectionNMuons ()
	~MuonAnalyser ()
	desctructor More...
Public Member Functions inherited from analysis::tools::BaseAnalyser
void	actionApplyPileupWeight (const int &var=0)
	apply pileup weight given a systematic variation More...
void	analyserTree ()
	root tree More...
std::shared_ptr< Analysis >	analysis ()
	returns pointer to Analysis object More...
	BaseAnalyser ()
	constructor More...
	BaseAnalyser (int argc, char *argv[])
	constructor More...
std::string	basename (const std::string &)
	returns the basename of a path More...
std::map< std::string, std::shared_ptr< TGraphAsymmErrors > >	btagEfficiencies () const
std::shared_ptr< Config >	config ()
	returns pointer to Config object More...
float	crossSection () const
	returns cross section More...
int	cutflow ()
	get cutflow index More...
void	cutflow (const int &)
	set cutflow index More...
void	cutflow (const std::string &label, const bool &ok=true)
	create and update cutflow entry in the cutflow histogram More...
virtual bool	event (const int &)
	event entry to be readout and processed More...
void	fillAnalyserTree ()
	fill root tree More...
void	fillPileupHistogram ()
	fills pileup histogram More...
void	generatorWeight ()
	generator weight More...
bool	genJetsAnalysis () const
	returns whether analysis of gen jets can be done More...
bool	genParticlesAnalysis () const
	returns whether analysis of gen particles can be done More...
std::shared_ptr< TH1F >	histogram (const std::string &)
	returns a given 1D histogram More...
std::map< std::string, std::shared_ptr< TH1F > >	histograms ()
	returns all 1D histograms More...
virtual void	histograms (const std::string &, const int &)
	create n histograms of a given type More...
int	nEvents ()
	number of events to be processed More...
std::shared_ptr< TFile >	output ()
	returns pointer to output root file More...
void	pileupHistogram ()
	creates pileup histogram More...
float	pileupWeight (const float &truepu, const int &var) const
	returns pileup weight given the true pileup and uncertainty variation in values of sigma More...
std::shared_ptr< PileupWeight >	pileupWeights () const
	returns pointer to pileup weights (MC-only) More...
void	scale (const float &)
	sets a scale More...
int	seed ()
	returns a seed for random number generator More...
int	seed (const std::string &)
	reads a file containing a seed and returns the seed or -1 if fails More...
void	seed (const int &)
	sets a seed for random number generators More...
bool	triggerEmulated (const std::string &)
	return status of an emulated l1 trigger More...
virtual bool	triggerEmulation (const std::string &, const int &, const float &, const float &, const std::string &)
	emulate l1 trigger More...
std::map< std::string, bool >	triggersEmulated ()
	return status of all emulated l1 triggers More...
float	trueInteractions () const
	returns true number of interactions More...
float	weight ()
	returns event weight More...
void	weight (const float &)
	sets event weight More...
virtual	~BaseAnalyser ()
	desctructor More...

Protected Attributes
std::map< std::string, std::shared_ptr< BTagCalibrationReader > >	bsf_reader_
std::vector< std::shared_ptr< Muon > >	muons_
bool	muonsanalysis_
std::vector< std::shared_ptr< Muon > >	onlineMatchedMuons_
std::vector< std::shared_ptr< Muon > >	selectedMuons_
Protected Attributes inherited from analysis::tools::BaseAnalyser
std::shared_ptr< TTree >	analyser_tree_
	output tree More...
std::shared_ptr< Analysis >	analysis_
	Analysis objects. More...
std::map< std::string, std::shared_ptr< TGraphAsymmErrors > >	btageff_
std::shared_ptr< Config >	config_
	Config objects. More...
int	cutflow_
	Cutflow index. More...
bool	genjetsanalysis_
bool	genpartsanalysis_
std::map< std::string, std::shared_ptr< TH1F > >	h1_
	1D histograms mapping More...
std::map< std::string, std::shared_ptr< TH2F > >	h2_
	2D histograms mapping More...
std::shared_ptr< TFile >	hout_
	output root file More...
bool	isData_
	flag for DATA sample More...
bool	isMC_
	flag for MC sample More...
bool	istruepu_
	true pileup More...
std::string	puw_label_
	pileup weight label More...
std::shared_ptr< PileupWeight >	puweights_
	pileup weight More...
float	scale_
	overall scaling More...
int	seed_
	seed value More...
std::map< std::string, bool >	trg_emul_
	emulated triggers More...
float	weight_
	event weight More...
float	xsection_
	cross section More...

Detailed Description

Definition at line 35 of file MuonAnalyser.h.

Constructor & Destructor Documentation

MuonAnalyser::MuonAnalyser

(

)

constructors

Definition at line 19 of file MuonAnalyser.cc.

{
}

MuonAnalyser::MuonAnalyser	(	int	argc,
		char *	argv[]
	)

Definition at line 24 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::analysis_, analysis::tools::BaseAnalyser::config_, and muonsanalysis_.

                                                  : BaseAnalyser(argc,argv)
{
   // Physics objects
   // Muons
   muonsanalysis_  = ( analysis_->addTree<Muon> ("Muons",config_->muonsCollection()) != nullptr  && config_ -> nMuonsMin() > 0 );

}

MuonAnalyser::~MuonAnalyser

(

)

desctructor

Definition at line 32 of file MuonAnalyser.cc.

{
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
}

Member Function Documentation

bool MuonAnalyser::analysisWithMuons ( )

virtual

Definition at line 44 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::analysis_, analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, muons(), muons_, muonsanalysis_, onlineMatchedMuons_, selectedMuons_, analysis::tools::BaseAnalyser::triggerEmulation(), and analysis::tools::BaseAnalyser::weight_.

Referenced by analysis::tools::Analyser::event().

{
   muons_.clear();
   selectedMuons_.clear();
   onlineMatchedMuons_.clear();

   // trigger emulation
   // L1 muons
   std::string triggerObjectsL1Muons;
   if ( config_->triggerObjectsL1Muons() != "" )
   {
      triggerObjectsL1Muons = config_->triggerObjectsL1Muons();
      if ( config_->triggerEmulateL1Muons() != "" &&  config_->triggerEmulateL1MuonsNMin() > 0 )
      {
         int nmin = config_->triggerEmulateL1MuonsNMin();
         float ptmin = config_->triggerEmulateL1MuonsPtMin();
         float etamax = config_->triggerEmulateL1MuonsEtaMax();
         std::string newL1Muons = config_->triggerEmulateL1Muons();
         triggerEmulation(triggerObjectsL1Muons,nmin,ptmin,etamax,newL1Muons);
         triggerObjectsL1Muons = newL1Muons;
      }
   }

   // L3 muons
   std::string triggerObjectsL3Muons;
   if ( config_->triggerObjectsL3Muons() != "" )
   {
      triggerObjectsL3Muons = config_->triggerObjectsL3Muons();
      if ( config_->triggerEmulateL3Muons() != "" &&  config_->triggerEmulateL3MuonsNMin() > 0 )
      {
         int nmin = config_->triggerEmulateL3MuonsNMin();
         float ptmin = config_->triggerEmulateL3MuonsPtMin();
         float etamax = config_->triggerEmulateL3MuonsEtaMax();
         std::string newL3Muons = config_->triggerEmulateL3Muons();
         triggerEmulation(triggerObjectsL3Muons,nmin,ptmin,etamax,newL3Muons);
         triggerObjectsL3Muons = newL3Muons;
      }
   }


   if ( ! muonsanalysis_ ) return false;

   ++cutflow_;
   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
   {
      h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Using Muon collection: %s",(config_->muonsCollection()).c_str()));
   }
   h1_["cutflow"] -> Fill(cutflow_,weight_);


   if ( config_->triggerObjectsL1Muons() != "" )
   {
      analysis_->match<Muon,TriggerObject>("Muons",triggerObjectsL1Muons,config_->triggerMatchL1MuonsDrMax());

   }

   if ( config_->triggerObjectsL3Muons() != "" )
   {
      analysis_->match<Muon,TriggerObject>("Muons",triggerObjectsL3Muons,config_->triggerMatchL3MuonsDrMax());
   }

   auto muons = analysis_->collection<Muon>("Muons");
   for ( int j = 0 ; j < muons->size() ; ++j )  muons_.push_back(std::make_shared<Muon>(muons->at(j)));

   selectedMuons_ = muons_;

   return true;
}

float analysis::tools::MuonAnalyser::btag	(	const Muon &	,
		const std::string &
	)

void MuonAnalyser::fillMuonHistograms ( )

virtual

Definition at line 406 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::h1_, and selectedMuons_.

{
   int n = config_->nMuonsMin();

   for ( int j = 0; j < n; ++j )
   {
      h1_[Form("pt_muon%d",j+1)] -> Fill(selectedMuons_[j]->pt());
      h1_[Form("eta_muon%d",j+1)] -> Fill(selectedMuons_[j]->eta());
      h1_[Form("phi_muon%d",j+1)] -> Fill(selectedMuons_[j]->phi());
   }

}

void MuonAnalyser::muonHistograms ( const std::string &  obj, const int &  n = 1  )

virtual

Definition at line 133 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::h1_.

{
   if ( obj == "muon" )
   {
      for ( int j = 0; j < n; ++j )
      {
         h1_[Form("pt_%s%d"  , obj.c_str(),j+1)]    = std::make_shared<TH1F>(Form("pt_%s%d"  , obj.c_str(),j+1)   , "" ,100 , 0   , 1000  );
         h1_[Form("eta_%s%d" , obj.c_str(),j+1)]    = std::make_shared<TH1F>(Form("eta_%s%d" , obj.c_str(),j+1)   , "" , 60 , -3, 3 );
         h1_[Form("phi_%s%d" , obj.c_str(),j+1)]    = std::make_shared<TH1F>(Form("phi_%s%d" , obj.c_str(),j+1)   , "" , 64 , -3.2, 3.2 );
      }

   }
}

std::vector< std::shared_ptr< Muon > > MuonAnalyser::muons

(

)

Definition at line 114 of file MuonAnalyser.cc.

References muons_.

Referenced by analysisWithMuons().

{
   return muons_;
}

bool MuonAnalyser::onlineL1MuonMatching ( const int &  r )

virtual

Definition at line 335 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

{
   int j = r-1;
   if ( config_->triggerObjectsL1Muons() == "" ) return true;

   ++cutflow_;

   std::string triggerObjectsL1Muons = config_->triggerObjectsL1Muons();
   if ( config_->triggerEmulateL1Muons() != "" &&  config_->triggerEmulateL1MuonsNMin() > 0 )
   {
      triggerObjectsL1Muons = config_->triggerEmulateL1Muons();
   }


   if ( r > config_->nMuonsMin() )
   {
      std::cout << "*Warning* MuonAnalyser::onlineL1MuonMatching(): asking for matching of unselected muon. Returning false!" << std::endl;
      return false;  // asking for a match beyond the selection, that's wrong, therefore false
   }
   if ( selectedMuons_.size() == 0 )
   {
      std::cout << "*Warning* MuonAnalyser::onlineL1MuonMatching(): selectedMuons is empty. Returning false!" << std::endl;
      return false;  // asking for a match beyond the selection, that's wrong, therefore false
   }

   if ( ! selectedMuons_[j]->matched(triggerObjectsL1Muons) ) return false;

   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
      h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muon %d: L1 muon match (deltaR < %4.3f)",r,config_-> triggerMatchL1MuonsDrMax()));

   h1_["cutflow"] -> Fill(cutflow_,weight_);

   return true;
}

bool MuonAnalyser::onlineL3MuonMatching ( const int &  r )

virtual

Definition at line 370 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

{
   int j = r-1;
   if ( config_->triggerObjectsL3Muons() == "" ) return true;

   ++cutflow_;

   std::string triggerObjectsL3Muons = config_->triggerObjectsL3Muons();
   if ( config_->triggerEmulateL3Muons() != "" &&  config_->triggerEmulateL3MuonsNMin() > 0 )
   {
      triggerObjectsL3Muons = config_->triggerEmulateL3Muons();
   }

   if ( r > config_->nMuonsMin() )
   {
      std::cout << "*Warning* MuonAnalyser::onlineL3MuonMatching(): asking for matching of unselected muon. Returning false!" << std::endl;
      return false;  // asking for a match beyond the selection, that's wrong, therefore false
   }
   if ( selectedMuons_.size() == 0 )
   {
      std::cout << "*Warning* MuonAnalyser::onlineL3MuonMatching(): selectedMuons is empty. Returning false!" << std::endl;
      return false;  // asking for a match beyond the selection, that's wrong, therefore false
   }

   if ( ! selectedMuons_[j]->matched(triggerObjectsL3Muons) ) return false;

   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
      h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muon %d: L3 muon match  (deltaR < %4.3f)",r,config_-> triggerMatchL3MuonsDrMax()));

   h1_["cutflow"] -> Fill(cutflow_,weight_);

   return true;
}

std::vector< std::shared_ptr< Muon > > MuonAnalyser::onlineMatchedMuons

(

)

Definition at line 124 of file MuonAnalyser.cc.

References onlineMatchedMuons_.

{
   return onlineMatchedMuons_;
}

bool MuonAnalyser::onlineMuonMatching ( )

virtual

Definition at line 309 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, muonsanalysis_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

Referenced by main(), and analysis::mssmhbb::MssmHbbAnalyser::muonSelection().

{
   if ( ! muonsanalysis_ ) return true;  // will skip this selection

   if ( config_->triggerObjectsL1Muons() == "" && config_->triggerObjectsL3Muons() == ""  ) return true;

   ++cutflow_;
   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
      h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muons selected: Online muon matching: L1 (deltaR < %4.3f) and L3 (deltaR < %4.3f)",config_-> triggerMatchL1MuonsDrMax(),config_-> triggerMatchL3MuonsDrMax()));

   auto muon = std::begin(selectedMuons_);
   while ( muon != std::end(selectedMuons_) )
   {
      if ( !((*muon)->matched(config_->triggerObjectsL1Muons()) && (*muon)->matched(config_->triggerObjectsL3Muons()) ))
         muon = selectedMuons_.erase(muon);
      else
         ++muon;
   }

   if ( (int)selectedMuons_.size() < config_->nMuonsMin() ) return false;

   h1_["cutflow"] -> Fill(cutflow_,weight_);

   return true;
}

std::vector< std::shared_ptr< Muon > > MuonAnalyser::selectedMuons

(

)

Definition at line 119 of file MuonAnalyser.cc.

References selectedMuons_.

{
   return selectedMuons_;
}

bool MuonAnalyser::selectionMuon ( const int &  r )

virtual

Definition at line 148 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

{
   bool isgood = true;
   ++cutflow_;
   int m = r-1;

   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
   {
      if ( config_->muonsPtMax().size() > 0 && config_->muonsPtMax()[m] > config_->muonsPtMin()[m] )
         h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muon %d: pt > %5.1f GeV and pt < %5.1f GeV and |eta| < %3.1f",r,config_->muonsPtMin()[m], config_->muonsPtMax()[m],config_->muonsEtaMax()[m] ));
      else
         h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muon %d: pt > %5.1f GeV and |eta| < %3.1f",r,config_->muonsPtMin()[m], config_->muonsEtaMax()[m] ));
   }

   // kinematic selection
   if ( selectedMuons_[m] -> pt() < config_->muonsPtMin()[m]           && !(config_->muonsPtMin()[m] < 0) )   return false;
   if ( fabs(selectedMuons_[m] -> eta()) > config_->muonsEtaMax()[m]   && !(config_->muonsEtaMax()[m] < 0) )  return false;

   h1_["cutflow"] -> Fill(cutflow_,weight_);

   return isgood;
}

bool MuonAnalyser::selectionMuonDr ( const int &  r1, const int &  r2  )

virtual

Given the rankings r1 and r2 of two jets, it returns whether the jets passes the delta_R selection; the threshold delta is passed by the configuration file.

Definition at line 285 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_.

{
   bool ok = true;
   if (config_->muonsDrMax() < 0 )
   {
      ok = ok && true;
   }
   else
   {
      ok = ok && selectionMuonDr(r1,r2,config_->muonsDrMax());
   }

   if (config_->muonsDrMin() < 0 )
   {
      ok = ok && true;
   }
   else
   {
      ok = ok && selectionMuonDr(r1,r2,-1*config_->muonsDrMin());
   }
   return ok;
}

bool MuonAnalyser::selectionMuonDr ( const int &  r1, const int &  r2, const float &  delta  )

virtual

Given the rankings r1 and r2 of two jets, it returns whether the jets passes the delta_R selection; the threshold delta is passed as an argument (if delta <= 0, |delta| = delta_min; else |delta| = delta_max )

Definition at line 261 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow(), and selectedMuons_.

{
   if ( r1 > config_->nMuonsMin() ||  r2 > config_->nMuonsMin() ) return true;

   bool isgood = true;

   std::string label = Form("DR(muon %d, muon %d) < %4.2f",r1,r2,fabs(delta));
   if ( delta < 0 )
      label = Form("DR(muon %d, muon %d) > %4.2f",r1,r2,fabs(delta));

   int m1 = r1-1;
   int m2 = r2-1;

   if ( delta > 0 )
      isgood = ( selectedMuons_[m1]->deltaR(*selectedMuons_[m2]) < fabs(delta) );
   else
      isgood = ( selectedMuons_[m1]->deltaR(*selectedMuons_[m2]) > fabs(delta) );

   cutflow(label,isgood);

   return isgood;

}

bool MuonAnalyser::selectionMuonId ( )

virtual

Definition at line 217 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, muonsanalysis_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

Referenced by main(), and analysis::tools::Analyser::preselection().

{
   if ( ! muonsanalysis_ ) return true;  // will skip this selection

   ++cutflow_;

   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
      h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("MuonId: %s",config_->muonsId().c_str()));

//   if ( ! muonsanalysis_ ) return false;

   auto muon = std::begin(selectedMuons_);
   while ( muon != std::end(selectedMuons_) )
   {
      if ( ! (*muon)->id(config_->muonsId() ) )
         muon = selectedMuons_.erase(muon);
      else
         ++muon;
   }
   if ( selectedMuons_.size() == 0 ) return false;


   h1_["cutflow"] -> Fill(cutflow_,weight_);

   return true;
}

bool MuonAnalyser::selectionMuons ( )

virtual

Definition at line 171 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, muonsanalysis_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

Referenced by main(), and analysis::mssmhbb::MssmHbbAnalyser::muonSelection().

{
   // selectedMuons will be composed of muons with the lowest pt threshold

   if ( ! muonsanalysis_ ) return true;  // will skip this selection


   bool isgood = true;
   ++cutflow_;
//
   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
   {
      if ( config_->muonsPtMax().size() > 0 && config_->muonsPtMax().back() > config_->muonsPtMin().back() )
         h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muons selected: pt > %5.1f GeV and pt < %5.1f GeV and |eta| < %3.1f", config_->muonsPtMin().back(), config_->muonsPtMax().back(), config_->muonsEtaMax().back() ));
      else
         h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("Muons selected: pt > %5.1f GeV and |eta| < %3.1f", config_->muonsPtMin().back(), config_->muonsEtaMax().back() ));
   }

   // kinematic selection
   auto muon = std::begin(selectedMuons_);
   while ( muon != std::end(selectedMuons_) )
   {
      if ( config_->muonsPtMax().size() > 0 && config_->muonsPtMax().back() > config_->muonsPtMin().back() )
      {
         if ( (*muon)->pt() < config_->muonsPtMin().back() || (*muon)->pt() > config_->muonsPtMax().back() || fabs((*muon)->eta()) > config_->muonsEtaMax().back() )
            muon = selectedMuons_.erase(muon);
         else
            ++muon;
      }
      else
      {
         if ( (*muon)->pt() < config_->muonsPtMin().back() || fabs((*muon)->eta()) > config_->muonsEtaMax().back() )
            muon = selectedMuons_.erase(muon);
         else
            ++muon;
      }
   }
   if ( (int)selectedMuons_.size() < config_->nMuonsMin() ) return false;

   h1_["cutflow"] -> Fill(cutflow_,weight_);
//
   return isgood;
}

bool MuonAnalyser::selectionNMuons ( )

virtual

Definition at line 244 of file MuonAnalyser.cc.

References analysis::tools::BaseAnalyser::config_, analysis::tools::BaseAnalyser::cutflow_, analysis::tools::BaseAnalyser::h1_, muonsanalysis_, selectedMuons_, and analysis::tools::BaseAnalyser::weight_.

Referenced by main(), and analysis::mssmhbb::MssmHbbAnalyser::muonSelection().

{
   if ( ! muonsanalysis_ ) return true;  // will skip this selection


   ++cutflow_;

   if  ((int)selectedMuons_.size() < config_->nMuonsMin()) return false;

   if ( std::string(h1_["cutflow"] -> GetXaxis()-> GetBinLabel(cutflow_+1)) == "" )
      h1_["cutflow"] -> GetXaxis()-> SetBinLabel(cutflow_+1,Form("NMuons >= %d",config_->nMuonsMin()));

   h1_["cutflow"] -> Fill(cutflow_,weight_);

   return true;

}

Member Data Documentation

std::map<std::string, std::shared_ptr<BTagCalibrationReader> > analysis::tools::MuonAnalyser::bsf_reader_

protected

Definition at line 52 of file MuonAnalyser.h.

std::vector< std::shared_ptr<Muon> > analysis::tools::MuonAnalyser::muons_

protected

Definition at line 46 of file MuonAnalyser.h.

Referenced by analysisWithMuons(), and muons().

bool analysis::tools::MuonAnalyser::muonsanalysis_

protected

Definition at line 50 of file MuonAnalyser.h.

Referenced by analysisWithMuons(), MuonAnalyser(), analysis::mssmhbb::MssmHbbAnalyser::muonJet(), analysis::tools::Analyser::muonJet(), onlineMuonMatching(), selectionMuonId(), selectionMuons(), and selectionNMuons().

std::vector< std::shared_ptr<Muon> > analysis::tools::MuonAnalyser::onlineMatchedMuons_

protected

Definition at line 48 of file MuonAnalyser.h.

Referenced by analysisWithMuons(), and onlineMatchedMuons().

std::vector< std::shared_ptr<Muon> > analysis::tools::MuonAnalyser::selectedMuons_

protected

Definition at line 47 of file MuonAnalyser.h.

Referenced by analysisWithMuons(), fillMuonHistograms(), analysis::mssmhbb::MssmHbbAnalyser::muonJet(), analysis::tools::Analyser::muonJet(), onlineL1MuonMatching(), onlineL3MuonMatching(), onlineMuonMatching(), selectedMuons(), selectionMuon(), selectionMuonDr(), selectionMuonId(), selectionMuons(), and selectionNMuons().

---

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

• MuonAnalyser.h
• MuonAnalyser.cc