MuonSelector Class Reference

#include <MuonSelector.h>

Inheritance diagram for MuonSelector:

Collaboration diagram for MuonSelector:

Public Member Functions
	MuonSelector ()
	~MuonSelector ()
	MuonSelector (const MuonSelector &)=delete
MuonSelector &	operator= (const MuonSelector &)=delete
bool	passSelection (const xAOD::Muon *pxMuon)
void	setDebug (bool debug)
virtual void	Init ()
void	doIsoSelection (bool doIso)
void	doIPSelection (bool doIPsel)
void	doMCPSelection (bool domcp)
virtual void	finalize ()
void	SetPtCut (double newvalue)
double	GetPtCut ()
virtual bool	Reco ()
void	SetMuonQualityRequirement (std::string newname)
void	SetCustomMuonSelectionTool (ToolHandle< CP::IMuonSelectionTool > mst)

Static Public Member Functions
template<class T>
static CLHEP::Hep3Vector	calculateMomentum (const T *pP)
template<class T>
static float	EvalInvMass (const T *pxP1, const T *pxP2, float fMass1, float fMass2=invalidAnswer)
template<class T>
static float	EvalInvMass (const T *pxP1, const T *pxP2, const T *pxp3, const T *pxP4, float fMass1, float fMass2=-999.9, float fMass3=-999.9, float fMass4=invalidAnswer)
template<class T>
static float	EvalDiMuInvMass (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalFourMuInvMass (const T *pxP1, const T *pxP2, const T *pxP3, const T *pxP4)
template<class T>
static float	EvaluateAngle (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalPtDiff (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalPhiDiff (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalEtaDiff (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalPt (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalPhi (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalEta (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalCharge (const T *pxP1, const T *pxP2)
template<class T>
static float	EvalTransverseMass (const T *pxP1, float fMETx, float fMETy, float fMass1, float fMass2=invalidAnswer)
template<class T>
static float	EvalTransverseMass (const T *pxP1, float fMETx, float fMETy)
template<class T>
static float	EvalTransverseMass (const T *pxP1, const T *pxP2, float fMETx, float fMETy, float fMass1, float fMass2=invalidAnswer)
template<class T>
static float	EvalTransverseMass (const T *pxP1, const T *pxP2, float fMETx, float fMETy)

Public Attributes
ToolHandle< CP::IMuonSelectionTool >	m_muonSelectionTool

Static Public Attributes
static constexpr float	invalidAnswer {-999.9f}

Protected Member Functions
virtual void	BookHistograms ()

Protected Attributes
unsigned int	m_uPassedEvents
std::map< unsigned int, TH1F * >	m_x1DHistograms
std::map< unsigned int, TH2F * >	m_x2DHistograms
std::map< unsigned int, TProfile * >	m_x1DProfHistograms
std::map< unsigned int, TProfile2D * >	m_x2DProfHistograms
std::string	m_xSampleName

Private Types
enum	HISTOS_1D { NMDT , NCSC , ECONE , NUM_1HISTOS }
typedef EventAnalysis	PARENT

Private Member Functions
bool	passQualCuts ()
bool	passPtCuts ()
bool	passIsolCuts ()
bool	passIPCuts ()
void	Register ()

Private Attributes
unsigned int	m_uNumInstances = 0U
MsgStream *	m_msgStream
const xAOD::Muon *	m_pxMuon
int	m_requestedMuonQuality {}
double	m_coneSize {}
unsigned char	m_ucJMuon_Cut
double	m_IsoCut
bool	m_bCutOnCombKine
float	m_fEtaCut
double	m_combPtCut
float	m_ptMSCut
float	m_diffZCut
float	m_diffPtCut
float	m_pVZCut
float	m_fIDPtCut
float	m_fIDChiPerDofCut
int	m_IDSiHitsCut
unsigned char	m_ucID_PIXCut
unsigned char	m_ucID_SCTCut
unsigned char	m_ucID_TRTCut
bool	m_doDebug
bool	m_doQualSelection
bool	m_doIsoSelection
bool	m_doPtSelection
bool	m_doIPSelection
bool	m_doMCPSelection
bool	m_bLock
unsigned int	m_testedmuons {}
unsigned int	m_passqual {}
unsigned int	m_passiso {}
unsigned int	m_passpt {}
unsigned int	m_passip {}
unsigned int	m_passmcp {}
unsigned int	m_passall {}

Detailed Description

Definition at line 33 of file MuonSelector.h.

Member Typedef Documentation

PARENT

typedef EventAnalysis MuonSelector::PARENT

private

Definition at line 64 of file MuonSelector.h.

Member Enumeration Documentation

HISTOS_1D

enum MuonSelector::HISTOS_1D

private

Enumerator
NMDT
NCSC
ECONE
NUM_1HISTOS

Definition at line 128 of file MuonSelector.h.

  {
    NMDT, NCSC, ECONE,
    NUM_1HISTOS
  };

Constructor & Destructor Documentation

MuonSelector() [1/2]

MuonSelector::MuonSelector

(

)

Definition at line 43 of file MuonSelector.cxx.

                          :
  m_muonSelectionTool("CP::MuonSelectionTool/MuonSelectionTool"),
  m_doDebug ( false ),
  m_doQualSelection ( false ),
  m_doIsoSelection  ( false ),
  m_doPtSelection   ( true  ),
  m_doIPSelection   ( true  ),
  m_doMCPSelection    ( true  )
{
  // SOC commented by Salva -- R22 test --
  //++s_uNumInstances;
  //std::stringstream xTmp;  xTmp << s_uNumInstances;
  //m_xSampleName     = "MuID_" + xTmp.str(); 
  // EOC commented by Salva -- R22 test --
  unsigned int inst = ++m_uNumInstances;
  m_xSampleName     = "MuID_" + std::to_string(inst);
  m_pxMuon = nullptr;
  m_bLock  = false;
 
  
  // requested muon tag (tight, medium, loose..)
  m_requestedMuonQuality = xAOD::Muon::Medium; 
 
 
  m_coneSize        = 0.4;
  m_ucJMuon_Cut     = 0; //not used
  m_IsoCut          = 0.2;
 
  m_bCutOnCombKine  = false; //not used
  m_fEtaCut         = 2.5;
  //m_fEtaCut         = 1.9;
  m_combPtCut       = 15.0*CLHEP::GeV; // GeV/c
  //    m_combPtCut       = .01*CLHEP::GeV; // GeV/c
 
  //m_ptMSCut         = 10.0*CLHEP::GeV;
  m_ptMSCut         = 0.0*CLHEP::GeV;
  m_diffZCut        = 1.5*CLHEP::mm;  // mm --> used to be 10.0*CLHEP::mm // Changed by Salva 26/january/2016
  m_diffPtCut       = 15.0*CLHEP::GeV;  // not used
  m_pVZCut          = 150.0*CLHEP::mm; // mm
 
  m_fIDPtCut        = 0.0;     // GeV/c
  m_fIDChiPerDofCut = 4.0;
  m_IDSiHitsCut     = 8;
  m_ucID_PIXCut     = 1;        // Hits
  m_ucID_SCTCut     = 4;        // Hits
  m_ucID_TRTCut     = 0;        // Hits
 
  m_msgStream =  new MsgStream(Athena::getMessageSvc(), "InDetPerformanceMonitoring");
 
  // stats
  m_testedmuons = 0;
  m_passqual = 0;
  m_passiso = 0;
  m_passpt = 0;
  m_passip = 0;
  m_passmcp = 0;
  m_passall = 0;
 
  // done
}

~MuonSelector()

MuonSelector::~MuonSelector

(

)

Definition at line 105 of file MuonSelector.cxx.

{
  --m_uNumInstances;
  delete m_msgStream;
}

MuonSelector() [2/2]

MuonSelector::MuonSelector ( const MuonSelector & )

delete

Member Function Documentation

BookHistograms()

void MuonSelector::BookHistograms ( )

protectedvirtual

Reimplemented from EventAnalysis.

Definition at line 212 of file MuonSelector.cxx.

{
}

calculateMomentum()

template<class T>

CLHEP::Hep3Vector EventAnalysis::calculateMomentum ( const T * pP )

staticinherited

Definition at line 92 of file EventAnalysis.h.

                                            {
  const auto & p4(pP->p4());
  return CLHEP::Hep3Vector(p4.Px() * EAna::CGeV , p4.Py() * EAna::CGeV, p4.Pz() * EAna::CGeV);
}

doIPSelection()

void MuonSelector::doIPSelection ( bool doIPsel )

inline

Definition at line 51 of file MuonSelector.h.

{m_doIPSelection = doIPsel;}

doIsoSelection()

void MuonSelector::doIsoSelection ( bool doIso )

inline

Definition at line 50 of file MuonSelector.h.

{m_doIsoSelection = doIso;}

doMCPSelection()

void MuonSelector::doMCPSelection ( bool domcp )

inline

Definition at line 52 of file MuonSelector.h.

{m_doMCPSelection = domcp;}

EvalCharge()

template<class T>

float EventAnalysis::EvalCharge ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 239 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  return static_cast<float>(  pxP1->charge() + pxP2->charge() );
}

EvalDiMuInvMass()

template<class T>

float EventAnalysis::EvalDiMuInvMass ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 98 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
 
  // Evaluate Di-mu invariant mass.
  return EvalInvMass( pxP1, pxP2, EAna::g_fMuonMass );
}

EvalEta()

template<class T>

float EventAnalysis::EvalEta ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 230 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
  return static_cast<float>( (xTmp1 + xTmp2).pseudoRapidity() );
}

EvalEtaDiff()

template<class T>

float EventAnalysis::EvalEtaDiff ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 202 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Evaluate the angle.
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
  return static_cast<float>( xTmp1.polarAngle(xTmp2) );
}

EvalFourMuInvMass()

template<class T>

float EventAnalysis::EvalFourMuInvMass ( const T * pxP1, const T * pxP2, const T * pxP3, const T * pxP4 )

staticinherited

Definition at line 124 of file EventAnalysis.h.

{
  // Check integrity of inputs.                                                                                                                                                     
  if ( !pxP1 || !pxP2 || !pxP3 || !pxP4) return invalidAnswer;
 
  // Evaluate invariant mass.                                                                                                                                                
  return EvalInvMass( pxP1, pxP2, pxP3, pxP4, EAna::g_fMuonMass );
}

EvalInvMass() [1/2]

template<class T>

float EventAnalysis::EvalInvMass ( const T * pxP1, const T * pxP2, const T * pxp3, const T * pxP4, float fMass1, float fMass2 = -999.9, float fMass3 = -999.9, float fMass4 = invalidAnswer )

staticinherited

Definition at line 133 of file EventAnalysis.h.

{
  // Check integrity of inputs.No tachyons.                                                                                                                                         
  if ( fMass1 < 0.0f )  return invalidAnswer;
  if ( !pxP1 || !pxP2 || !pxP3 || !pxP4) return invalidAnswer;
 
  // Set masses equal if required by user                                                                                                                                           
  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
  fMass3 = ( fMass3 < 0.0f ) ? fMass1 : fMass3;
  fMass4 = ( fMass4 < 0.0f ) ? fMass1 : fMass4;
 
  // Evaluate invariant mass.                                                                                                                                                       
  CLHEP::Hep3Vector xTmp1 = CLHEP::Hep3Vector( pxP1->p4().Px() * EAna::CGeV, pxP1->p4().Py() * EAna::CGeV, pxP1->p4().Pz() * EAna::CGeV  );
  CLHEP::Hep3Vector xTmp2 = CLHEP::Hep3Vector( pxP2->p4().Px() * EAna::CGeV, pxP2->p4().Py() * EAna::CGeV, pxP2->p4().Pz() * EAna::CGeV  );
  CLHEP::Hep3Vector xTmp3 = CLHEP::Hep3Vector( pxP3->p4().Px() * EAna::CGeV, pxP3->p4().Py() * EAna::CGeV, pxP3->p4().Pz() * EAna::CGeV  );
  CLHEP::Hep3Vector xTmp4 = CLHEP::Hep3Vector( pxP4->p4().Px() * EAna::CGeV, pxP4->p4().Py() * EAna::CGeV, pxP4->p4().Pz() * EAna::CGeV  );
 
  CLHEP::HepLorentzVector xLVec;  xLVec.setVectM ( xTmp1, fMass1 );
  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp2, fMass2 );
  CLHEP::HepLorentzVector xLVec3; xLVec3.setVectM( xTmp3, fMass3 );
  CLHEP::HepLorentzVector xLVec4; xLVec4.setVectM( xTmp4, fMass4 );
 
  xLVec += xLVec2;
  xLVec += xLVec3;
  xLVec += xLVec4;
 
  return static_cast<float>( xLVec.m() );
}

EvalInvMass() [2/2]

template<class T>

float EventAnalysis::EvalInvMass ( const T * pxP1, const T * pxP2, float fMass1, float fMass2 = invalidAnswer )

staticinherited

Definition at line 107 of file EventAnalysis.h.

{
  // Check integrity of inputs.No tachyons.
  if ( fMass1 < 0.0f )  return invalidAnswer;
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Set masses equal if required by user
  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
  // Evaluate invariant mass.
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2); 
  CLHEP::HepLorentzVector xLVec1; xLVec1.setVectM( xTmp1, fMass1 );
  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp2, fMass2 );
  return static_cast<float>( xLVec1.invariantMass( xLVec2 ) );
}

EvalPhi()

template<class T>

float EventAnalysis::EvalPhi ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 221 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
  return static_cast<float>( (xTmp1 + xTmp2).phi() );
}

EvalPhiDiff()

template<class T>

float EventAnalysis::EvalPhiDiff ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 191 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Evaluate the angle.
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
  return static_cast<float>( xTmp1.deltaPhi(xTmp2) );
}

EvalPt()

template<class T>

float EventAnalysis::EvalPt ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 212 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
  return static_cast<float>( (xTmp1 + xTmp2).perp() );
}

EvalPtDiff()

template<class T>

float EventAnalysis::EvalPtDiff ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 174 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Evaluate the difference between the momenta. Signed using positive - negative if appropriate.
  if ( pxP1->charge() > 0.5f )
  {
    return static_cast<float>( pxP1->pt() * EAna::CGeV - pxP2->pt() * EAna::CGeV );
  }
  else
  {
    return static_cast<float>( pxP2->pt() * EAna::CGeV - pxP1->pt() * EAna::CGeV );
  }
}

EvalTransverseMass() [1/4]

template<class T>

float EventAnalysis::EvalTransverseMass ( const T * pxP1, const T * pxP2, float fMETx, float fMETy )

staticinherited

Definition at line 272 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Evaluate Di-mu invariant mass.
  return EvalTransverseMass( pxP1, pxP2, fMETx, fMETy, EAna::g_fMuonMass );
}

EvalTransverseMass() [2/4]

template<class T>

float EventAnalysis::EvalTransverseMass ( const T * pxP1, const T * pxP2, float fMETx, float fMETy, float fMass1, float fMass2 = invalidAnswer )

staticinherited

Definition at line 280 of file EventAnalysis.h.

{
  // Check integrity of inputs.No tachyons.
  if ( fMass1 < 0.0f )  return invalidAnswer;
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Set masses equal if required by user.
  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
  // Evaluate invariant mass.
  CLHEP::Hep3Vector xTmp1  = CLHEP::Hep3Vector( pxP1->p4().Px() * EAna::CGeV, pxP1->p4().Py() * EAna::CGeV, 0.0f  );
  CLHEP::Hep3Vector xTmp2  = CLHEP::Hep3Vector( pxP2->p4().Px() * EAna::CGeV, pxP2->p4().Py() * EAna::CGeV, 0.0f  );
  CLHEP::Hep3Vector xTmp12 = xTmp1 + xTmp2;
  CLHEP::Hep3Vector xTmp3  = CLHEP::Hep3Vector( fMETx, fMETy, 0.0f  );
  CLHEP::HepLorentzVector xLVec1; xLVec1.setVectM( xTmp12, fMass1 );
  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM(  xTmp3,   0.0f );
  return static_cast<float>( xLVec1.invariantMass( xLVec2 ) );
}

EvalTransverseMass() [3/4]

template<class T>

float EventAnalysis::EvalTransverseMass ( const T * pxP1, float fMETx, float fMETy )

staticinherited

Definition at line 247 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 ) return invalidAnswer;
  // Evaluate Di-mu invariant mass.
  return EvalInvMass( pxP1, fMETx, fMETy, EAna::g_fMuonMass );
}

EvalTransverseMass() [4/4]

template<class T>

float EventAnalysis::EvalTransverseMass ( const T * pxP1, float fMETx, float fMETy, float fMass1, float fMass2 = invalidAnswer )

staticinherited

Definition at line 255 of file EventAnalysis.h.

{
  // Check integrity of inputs.No tachyons.
  if ( fMass1 < 0.0f )  return invalidAnswer;
  if ( !pxP1 ) return invalidAnswer;
  // Set masses equal if required by user.
  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
  // Evaluate invariant mass.
  CLHEP::Hep3Vector xTmp1 = CLHEP::Hep3Vector( pxP1->p4().Px() * EAna::CGeV, pxP1->p4().Py() * EAna::CGeV, 0.0f  );
  CLHEP::Hep3Vector xTmp2 = CLHEP::Hep3Vector( fMETx, fMETy, 0.0f  );
  CLHEP::HepLorentzVector xLVec1; xLVec1.setVectM( xTmp1, fMass1 );
  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp2,   0.0f );
  return static_cast<float>( xLVec1.invariantMass( xLVec2 ) );
}

EvaluateAngle()

template<class T>

float EventAnalysis::EvaluateAngle ( const T * pxP1, const T * pxP2 )

staticinherited

Definition at line 164 of file EventAnalysis.h.

{
  // Check integrity of inputs.
  if ( !pxP1 || !pxP2 ) return invalidAnswer;
  // Evaluate the angle.
  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
  return static_cast<float>( xTmp1.angle(xTmp2) );
}

finalize()

void MuonSelector::finalize ( )

virtual

Definition at line 452 of file MuonSelector.cxx.

{
  // statistics report 
  std::cout << "    * MuonSelector*  -- STATS -- " << std::endl
        << "    tested  : " << m_testedmuons << std::endl;
  if (m_doQualSelection) std::cout << "    passQual: " << m_passqual << std::endl;
  if (m_doIsoSelection)  std::cout << "    passIso : " << m_passiso << std::endl;
  if (m_doPtSelection)   std::cout << "    passpt  : " << m_passpt << std::endl;
  if (m_doIPSelection)   std::cout << "    passip  : " << m_passip << std::endl;
  if (m_doMCPSelection)  std::cout << "    passmcp : " << m_passmcp << std::endl;
  std::cout << "    passall : " << m_passall << std::endl
        << std::endl;
  
  return;
}

GetPtCut()

double MuonSelector::GetPtCut ( )

inline

Definition at line 55 of file MuonSelector.h.

{return m_combPtCut;}

Init()

void MuonSelector::Init ( )

virtual

Reimplemented from EventAnalysis.

Definition at line 112 of file MuonSelector.cxx.

{
  
  // check muon selection tool is available
  if (m_muonSelectionTool.retrieve().isSuccess()) {
    ( *m_msgStream) << MSG::INFO << "  * MuonSelector::Init * m_muonSelectionTool.initialize() success :)" << endmsg;
    if(m_doDebug){ std::cout << "  * MuonSelector::Init * m_muonSelectionTool.initialize() success :)" << std::endl;}
  }
  else {
    (*m_msgStream) << MSG::ERROR << "  * MuonSelector::Init * FAILURE * Muon selction tool retrieving failed :( " << endmsg;    
  }
 
  PARENT::Init();
}

operator=()

MuonSelector & MuonSelector::operator= ( const MuonSelector & )

delete

passIPCuts()

bool MuonSelector::passIPCuts ( )

private

Definition at line 350 of file MuonSelector.cxx.

{
  float extd0 = 0.0 ;
  float extz0 = 0.0 ;  
 
  //I'm not really sure of this logic. 
  if (m_pxMuon->inDetTrackParticleLink().isValid()) {
    const xAOD::TrackParticle* IDTrk = m_pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);  
    if (!IDTrk) {
      if (m_doDebug) std::cout << "    * MuonSelector::passIPCuts * no IDTrk --> IP failure" << std::endl;
    return false;
    }
    extd0 = IDTrk->d0();
    extz0 = IDTrk->z0()+IDTrk->vz();
    if(m_doDebug){
      std::cout << "    * MuonSelector::passIPCuts *"
        << " the IDTrack muon d0:  " << extd0
        << " the IDTrack muon z0:  " << extz0 << " = " << IDTrk->z0() << " + " << IDTrk->vz() << std::endl;
    }
  }
  else {
    if(m_doDebug) std::cout << "   * MuonSelector * passIPCuts() * no valid inDetTrackParticleLink(). Will use the combined muon IPs" << std::endl;
    
    const xAOD::TrackParticle* CBTrk = m_pxMuon->trackParticle(xAOD::Muon::CombinedTrackParticle);
    if (!CBTrk) {
      if(m_doDebug) std::cout << "   * MuonSelector * passIPCuts() * no valid CombinedTrackParticle. Giving up." << std::endl;
      return false;
    }
    else { 
      extd0 = CBTrk->d0();
      extz0 = CBTrk->z0()+CBTrk->vz();
      if(m_doDebug){
    std::cout << " * MuonSelector * passIPCuts() *"
          << " the CBTrack muon d0:  " << extd0
          << " the CBTrack muon z0:  " << extz0 << " = " << CBTrk->z0() << " + " << CBTrk->vz()<< std::endl;
      }
    }
  }
 
  // retrieve the vertices  
  const xAOD::VertexContainer *  vxContainer(nullptr);
  vxContainer = PerfMonServices::getContainer <xAOD::VertexContainer> ( PerfMonServices::VTX_COLLECTION );
  if (!vxContainer){
    if(m_doDebug) std::cout << "   * MuonSelector::passIPCuts ** fails because NO vertex collection "<< std::endl;
    return false;
  }
 
  if ( vxContainer->size()>1 ) {
    if(m_doDebug) {
      std::cout << "   * MuonSelector::passIPCuts ** vertex container is filled with " << vxContainer->size() << " vertices" <<  std::endl;
 
      // loop on vertices to check their coordinates:
      for (int ivtx=0; ivtx < (int) vxContainer->size(); ivtx++) {
    const xAOD::Vertex* thisVtx  = (*vxContainer)[ivtx];
    std::cout << "                                   vertex " << ivtx+1 << " (x,y,z) = (" << thisVtx->position().x()
          << ", " << thisVtx->position().y()
          << ", " << thisVtx->position().z()
          << ")  type= " << thisVtx->vertexType()
          << "  Npart= " << thisVtx->nTrackParticles()
          <<  std::endl;
      }
    }
        
    // new method
    if (true) {
      bool goodmuonIP = false; // by default think the IP is not good
      float minDeltaZ = 99999.; // large number
      // loop on vertices and check the muon may come from one of them
      for (int ivtx=0; ivtx < (int) vxContainer->size(); ivtx++) {
    const xAOD::Vertex* thisVtx  = (*vxContainer)[ivtx];
    // if ( (thisVtx->vertexType() == 1) && thisVtx->nTrackParticles()>2 ) {
    if ( thisVtx->nTrackParticles()>2 ) {
      if (std::abs(extz0 - thisVtx->position().z()) < minDeltaZ) minDeltaZ = std::abs(extz0 - thisVtx->position().z());
 
      // check the vertex is in the accepted Z range and that the muon is not far from the vertex
      if (m_doDebug) {
        std::cout << "           testing vtx: " << ivtx << "  vtx.z= " << thisVtx->position().z() << " trk.z= " << extz0 << "   deltaZ= " << std::abs(extz0 - thisVtx->position().z()) << "  minDeltaZ= " << minDeltaZ << std::endl;
      }
      if (std::abs(thisVtx->position().z()) < m_pVZCut && std::abs(extz0 - thisVtx->position().z()) < m_diffZCut){
        goodmuonIP = true;
        if(m_doDebug) std::cout << "    * MuonSelector::passIPCuts * this muon has passed the IPCuts for vertex " << ivtx+1
                    << "  pVZcut= " << std::abs(extz0 - thisVtx->position().z()) << " < " << m_diffZCut << std::endl
                    << "                                 vtx (x,y,z): " 
                    << " (" << thisVtx->position().x()
                    << ", " << thisVtx->position().y()
                    << ", " << thisVtx->position().z()
                    << ")   type: " << thisVtx->vertexType() 
                    << "  Npart: " << thisVtx->nTrackParticles() << std::endl;
      }
    }
      }
      if (goodmuonIP) {
    if(m_doDebug) std::cout <<"    * MuonSelector::passIPCuts * this muon has passed the IPCuts. Zcut: "<<  m_pVZCut << "  m_diffZCut " << m_diffZCut << std::endl;
    return true;
      }
    } // end new method
  }
  if(m_doDebug) std::cout <<"   * MuonSelector * passIPCuts() * this muon has not passed the IPCuts: " << std::endl;
  return false;
}

passIsolCuts()

bool MuonSelector::passIsolCuts ( )

private

Definition at line 321 of file MuonSelector.cxx.

{
  float iso_pt40(0);
  if( !m_pxMuon->isolation(iso_pt40, xAOD::Iso::ptcone40) ) {
    if(m_doDebug) { 
      std::cout << "    * MuonSelector::passIsolCuts * WARNING * No isolation variable stored on the muon" << std::endl;
      std::cout << "    * MuonSelector::passIsolCuts * this muon did not pass the IsoCuts " << std::endl;
    }
    return false;
  }
  
  else {
    double pt = m_pxMuon->pt();
    double ptSum = xAOD::Iso::ptcone40;
    if(m_doDebug) std::cout <<"    * MuonSelector::passIsolCuts *  muon pt: " << pt <<"   ptSum(ptcone40): "<< ptSum << std::endl;
    if (ptSum/pt < m_IsoCut ){
      if(m_doDebug) std::cout << "    * MuonSelector::passIsolCuts *  this muon passed the IsoCuts ptcone40 / pt= " 
                  << ptSum << " / " << pt << " = " << ptSum / pt 
                  << " < IsoCut(" << m_IsoCut << ") " << std::endl;
      return true;
    }
  }
  
  if(m_doDebug) std::cout << "    * MuonSelector::passIsolCuts * this muon did not pass the IsoCuts:" << std::endl;
  return false;
}

passPtCuts()

bool MuonSelector::passPtCuts ( )

private

Definition at line 275 of file MuonSelector.cxx.

{
 
  if(m_doDebug) std::cout << "    * MuonSelector::passPtCuts * START *" << std::endl; 
 
  const xAOD::TrackParticle* pxMuonID = m_pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
  const xAOD::TrackParticle* pxMuonMS = m_pxMuon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
  const xAOD::TrackParticle* pxMuonCB = m_pxMuon->trackParticle(xAOD::Muon::CombinedTrackParticle);
 
  double pt = 0, ptID, ptMS,ptCB;
 
  if ( !(pxMuonID || pxMuonMS || pxMuonCB)){
         if(m_doDebug) std::cout << "    * MuonSelector::passPtCuts * NO inDetTrackParticle && muonSpectrometerTrackParticle && CombinedTrackParticle: " << std::endl;
  }
 
  else {
 
    pt    = m_pxMuon->pt();
    ptID  = pxMuonID ? pxMuonID->pt() : 0.0 ;
    ptMS  = pxMuonMS ? pxMuonMS->pt() : 0.0 ;
    ptCB  = pxMuonCB ? pxMuonCB->pt() : 0.0 ;
    double fMEta = std::abs( m_pxMuon->eta() );
 
    if(m_doDebug) std::cout << "    * MuonSelector::passPtCuts * pt of each segments of this muon pxMuon: " << pt << std::endl
                << "                                                                    ptID: " << ptID << std::endl 
                << "                                                                    ptMS: " << ptMS << std::endl
                << "                                                                    ptCB: " << ptCB << std::endl
                << "                                                     fMEta pxMuon->eta(): " << fMEta << std::endl;
 
    
    if ( (fMEta < m_fEtaCut)    
     && (pt    > m_combPtCut)  
     && (ptMS  > m_ptMSCut || !pxMuonMS)
     && (ptID  > m_ptMSCut || !pxMuonID)
     ){
      // warning one can check also the difference of pt: std::abs(ptMS - ptID) < m_diffPtCut
      if(m_doDebug) std::cout << "    * MuonSelector::passPtCuts * this muon is in eta range |eta|= " << fMEta << " < EtaCut(" << m_fEtaCut << ") " << std::endl 
                  << "                                 and passed the PtCuts (" << m_combPtCut <<") "<< std::endl;
      return true;
    }
  }
  if(m_doDebug) std::cout << "    * MuonSelector::passPtCuts * this muon did not pass the PtCuts (reco pt=" << pt << ") or Eta cut " << m_fEtaCut << std::endl;
  return false;
}

passQualCuts()

bool MuonSelector::passQualCuts ( )

private

Definition at line 220 of file MuonSelector.cxx.

{
  bool goodTrack = false;
 
  // First get the muon track, then the summary  
  const xAOD::TrackParticle* IDTrk = m_pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle); // use the Inner Detector segment
  
  if (IDTrk) {
    uint8_t dummy(-1);
    bool eBLhits = IDTrk->summaryValue( dummy, xAOD::expectBLayerHit ) ? true : false;
    int  nBLhits = IDTrk->summaryValue( dummy, xAOD::numberOfBLayerHits ) ? dummy :-1;
 
    int nhitsPIX = IDTrk->summaryValue( dummy, xAOD::numberOfPixelHits ) ? dummy :-1;
    int nhitsSCT = IDTrk->summaryValue( dummy, xAOD::numberOfSCTHits ) ? dummy :-1;
    int nhitsTRT = IDTrk->summaryValue( dummy, xAOD::numberOfTRTHits ) ? dummy :-1;
 
    int nPIXDS = IDTrk->summaryValue( dummy, xAOD::numberOfPixelDeadSensors ) ? dummy :-1;
    int nSCTDS = IDTrk->summaryValue( dummy, xAOD::numberOfSCTDeadSensors ) ? dummy :-1;
 
    int nPIXH = IDTrk->summaryValue( dummy, xAOD::numberOfPixelHoles )? dummy :-1;
    int nSCTH = IDTrk->summaryValue( dummy, xAOD::numberOfSCTHoles )? dummy :-1;
    int nTRTH = IDTrk->summaryValue( dummy, xAOD::numberOfTRTHoles )? dummy :-1;
 
    int nContribPixLayers = IDTrk->summaryValue( dummy, xAOD::numberOfContribPixelLayers )? dummy :-1; 
 
    if(m_doDebug) std::cout << "  * MuonSelector * passQualCuts() * eBLhits: " << eBLhits
                << "  nBLhits:  " << nBLhits
                << "  nhitsPIX: " << nhitsPIX
                << "  nPIXLayers: " << nContribPixLayers 
                << "  nhitsSCT: " << nhitsSCT
                << "  Silicon holes: " << nPIXH + nSCTH
                << "    nhitsTRT: " << nhitsTRT
                << "  nTRTholes: " << nTRTH
                << std::endl;
 
    if (((!eBLhits) || (nBLhits > 0))
    &&   (nhitsPIX + nPIXDS > 1 )
    &&   (nhitsSCT + nSCTDS >=6 )
    &&   (nPIXH    + nSCTH  < 2 ) ) {
      goodTrack = true;
    }
  }
 
  if (m_doDebug) {
    if (goodTrack) {
      std::cout << "   * MuonSelector * passQualCuts() * this muon satisfies the hits number QualCuts  "  << std::endl;
    }
    else {
      std::cout << "   * MuonSelector * passQualCuts() * this muon did not pass the hits number QualCuts  "  << std::endl;
    }
  }
  return goodTrack;
}

passSelection()

bool MuonSelector::passSelection

(

const xAOD::Muon *

pxMuon

)

Definition at line 136 of file MuonSelector.cxx.

{
  if(m_doDebug){ std::cout << "  * MuonSelector::passSelection * START * new muon " << pxMuon << " with pt: " << pxMuon->pt() << std::endl; }
 
  std::vector<bool> passes;
  passes.reserve(8);
  bool pass = true;
  if ( pxMuon ) {
    // Save local copy of muon address if it's ok.
    m_pxMuon = pxMuon;
    m_testedmuons++;
    
    // Test muon pass conditions in turn
    if(m_doQualSelection){
      pass = passQualCuts();
      passes.push_back(pass);
      if (m_doDebug && !pass) std::cout <<"  * MuonSelector::passSelection * Muon Fails QualSelection"<<std::endl;
      if (pass) m_passqual++;
    }
 
    if (m_doIsoSelection){
      pass = passIsolCuts();
      passes.push_back(pass);
      if (m_doDebug && !pass) std::cout<<"  * MuonSelector::passSelection * Muon Fails Iso Selection"<<std::endl;
      if (pass) m_passiso++;
    }
 
 
    if (m_doPtSelection){
      pass = passPtCuts();
      passes.push_back(pass);
      if (m_doDebug && !pass) std::cout<<"  * MuonSelector::passSelection * Muon Fails pT Selection"<<std::endl;
      if (pass) m_passpt++;
    } 
 
    if (m_doIPSelection){
      pass = passIPCuts();
      passes.push_back(pass);
      if (m_doDebug && !pass) std::cout<<"  * MuonSelector::passSelection * Muon Fails IP Selection"<<std::endl;
      if (pass) m_passip++;
    }
 
    if (m_doMCPSelection) {
      xAOD::Muon::Quality my_quality=m_muonSelectionTool->getQuality(*pxMuon);
      if (m_doDebug) std::cout << "  * MuonSelector::passSelection * muon quality from muonsSelectionTool: " << my_quality << std::endl;
 
      pass = true; 
      if (m_requestedMuonQuality == xAOD::Muon::Tight     && my_quality > xAOD::Muon::Tight)     pass = false;
      if (m_requestedMuonQuality == xAOD::Muon::Medium    && my_quality > xAOD::Muon::Medium)    pass = false;
      if (m_requestedMuonQuality == xAOD::Muon::Loose     && my_quality > xAOD::Muon::Loose)     pass = false;
      if (m_requestedMuonQuality == xAOD::Muon::VeryLoose && my_quality > xAOD::Muon::VeryLoose) pass = false;
 
      passes.push_back(pass);
      if (m_doDebug &&  pass) std::cout<<"  * MuonSelector::passSelection * Muon Passes official m_muonSelectionTool (medium) Selection :)" << std::endl;
      if (m_doDebug && !pass) std::cout<<"  * MuonSelector::passSelection * Muon Fails official m_muonSelectionTool (medium) Selection" << std::endl;
      if (pass) m_passmcp++;
    }
 
    // check if the muon failed some of the cuts
    for (int i=0; i < int(passes.size()); i++)
      if (!passes[i]){
    if(m_doDebug) std::cout << "  * MuonSelector::passSelection * BAD MUON * muon haven't passed the " << i+1 << "th selection " << std::endl;
    return false;
      }
  } // if pxMuon exists
 
  // reached this point, the muon passed all selection criteria. This muon is good
  m_passall++;
  if(m_doDebug){ std::cout << "  * MuonSelector::passSelection  * completed. GOOD MUON " << std::endl; }
  return true;
}

Reco()

bool MuonSelector::Reco ( )

virtual

Definition at line 129 of file MuonSelector.cxx.

{
  return true;
}

Register()

void EventAnalysis::Register ( )

privateinherited

Definition at line 63 of file EventAnalysis.cxx.

{
  ServiceHandle<ITHistSvc> histSvc ("THistSvc", "EventAnalysis");
  
  // Register histograms in monitoring tool
  registerHistogramType(*histSvc, m_x1DHistograms, m_xSampleName, "/1dhisto_");
  registerHistogramType(*histSvc, m_x2DHistograms, m_xSampleName, "/2dhisto_");
 
  registerHistogramType(*histSvc, m_x1DProfHistograms, m_xSampleName, "/1dprof_");
  registerHistogramType(*histSvc, m_x2DProfHistograms, m_xSampleName, "/2dprof_");
}

SetCustomMuonSelectionTool()

void MuonSelector::SetCustomMuonSelectionTool ( ToolHandle< CP::IMuonSelectionTool > mst )

inline

Definition at line 58 of file MuonSelector.h.

{ m_muonSelectionTool = mst; };

setDebug()

void MuonSelector::setDebug ( bool debug )

inline

Definition at line 44 of file MuonSelector.h.

{m_doDebug = debug;}

SetMuonQualityRequirement()

void MuonSelector::SetMuonQualityRequirement

(

std::string

newname

)

Definition at line 469 of file MuonSelector.cxx.

{
  int qualityvalue = xAOD::Muon::Tight;
 
  for_each (newname.begin(), newname.end(), [](char & c) {c = std::toupper(c);} );
  
  if (newname.find("TIGHT")    != std::string::npos) qualityvalue = xAOD::Muon::Tight;
  if (newname.find("MEDIUM")   != std::string::npos) qualityvalue = xAOD::Muon::Medium;
  if (newname.find("LOOSE")    != std::string::npos) qualityvalue = xAOD::Muon::Loose;
  if (newname.find("VERYLOOSE")!= std::string::npos) qualityvalue = xAOD::Muon::VeryLoose;
 
  m_requestedMuonQuality = qualityvalue;
 
  std::cout << " ** MuonSelector::SetMuonQualityRequirement(" << newname <<") = " << m_requestedMuonQuality << std::endl;
 
  return;
}

SetPtCut()

void MuonSelector::SetPtCut ( double newvalue )

inline

Definition at line 54 of file MuonSelector.h.

{m_combPtCut = newvalue;}

Member Data Documentation

invalidAnswer

float EventAnalysis::invalidAnswer {-999.9f}

staticconstexprinherited

Definition at line 40 of file EventAnalysis.h.

{-999.9f};

m_bCutOnCombKine

bool MuonSelector::m_bCutOnCombKine

private

Definition at line 91 of file MuonSelector.h.

m_bLock

bool MuonSelector::m_bLock

private

Definition at line 116 of file MuonSelector.h.

m_combPtCut

double MuonSelector::m_combPtCut

private

Definition at line 94 of file MuonSelector.h.

m_coneSize

double MuonSelector::m_coneSize {}

private

Definition at line 84 of file MuonSelector.h.

{};

m_diffPtCut

float MuonSelector::m_diffPtCut

private

Definition at line 97 of file MuonSelector.h.

m_diffZCut

float MuonSelector::m_diffZCut

private

Definition at line 96 of file MuonSelector.h.

m_doDebug

bool MuonSelector::m_doDebug

private

Definition at line 108 of file MuonSelector.h.

m_doIPSelection

bool MuonSelector::m_doIPSelection

private

Definition at line 112 of file MuonSelector.h.

m_doIsoSelection

bool MuonSelector::m_doIsoSelection

private

Definition at line 110 of file MuonSelector.h.

m_doMCPSelection

bool MuonSelector::m_doMCPSelection

private

Definition at line 113 of file MuonSelector.h.

m_doPtSelection

bool MuonSelector::m_doPtSelection

private

Definition at line 111 of file MuonSelector.h.

m_doQualSelection

bool MuonSelector::m_doQualSelection

private

Definition at line 109 of file MuonSelector.h.

m_fEtaCut

float MuonSelector::m_fEtaCut

private

Definition at line 92 of file MuonSelector.h.

m_fIDChiPerDofCut

float MuonSelector::m_fIDChiPerDofCut

private

Definition at line 102 of file MuonSelector.h.

m_fIDPtCut

float MuonSelector::m_fIDPtCut

private

Definition at line 101 of file MuonSelector.h.

m_IDSiHitsCut

int MuonSelector::m_IDSiHitsCut

private

Definition at line 103 of file MuonSelector.h.

m_IsoCut

double MuonSelector::m_IsoCut

private

Definition at line 89 of file MuonSelector.h.

m_msgStream

MsgStream* MuonSelector::m_msgStream

private

Definition at line 75 of file MuonSelector.h.

m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> MuonSelector::m_muonSelectionTool

Definition at line 45 of file MuonSelector.h.

m_passall

unsigned int MuonSelector::m_passall {}

private

Definition at line 125 of file MuonSelector.h.

{};

m_passip

unsigned int MuonSelector::m_passip {}

private

Definition at line 123 of file MuonSelector.h.

{};

m_passiso

unsigned int MuonSelector::m_passiso {}

private

Definition at line 121 of file MuonSelector.h.

{};

m_passmcp

unsigned int MuonSelector::m_passmcp {}

private

Definition at line 124 of file MuonSelector.h.

{};

m_passpt

unsigned int MuonSelector::m_passpt {}

private

Definition at line 122 of file MuonSelector.h.

{};

m_passqual

unsigned int MuonSelector::m_passqual {}

private

Definition at line 120 of file MuonSelector.h.

{};

m_ptMSCut

float MuonSelector::m_ptMSCut

private

Definition at line 95 of file MuonSelector.h.

m_pVZCut

float MuonSelector::m_pVZCut

private

Definition at line 98 of file MuonSelector.h.

m_pxMuon

const xAOD::Muon* MuonSelector::m_pxMuon

private

Definition at line 78 of file MuonSelector.h.

m_requestedMuonQuality

int MuonSelector::m_requestedMuonQuality {}

private

Definition at line 81 of file MuonSelector.h.

{};

m_testedmuons

unsigned int MuonSelector::m_testedmuons {}

private

Definition at line 119 of file MuonSelector.h.

{};

m_ucID_PIXCut

unsigned char MuonSelector::m_ucID_PIXCut

private

Definition at line 104 of file MuonSelector.h.

m_ucID_SCTCut

unsigned char MuonSelector::m_ucID_SCTCut

private

Definition at line 105 of file MuonSelector.h.

m_ucID_TRTCut

unsigned char MuonSelector::m_ucID_TRTCut

private

Definition at line 106 of file MuonSelector.h.

m_ucJMuon_Cut

unsigned char MuonSelector::m_ucJMuon_Cut

private

Definition at line 88 of file MuonSelector.h.

m_uNumInstances

unsigned int MuonSelector::m_uNumInstances = 0U

private

Definition at line 67 of file MuonSelector.h.

m_uPassedEvents

unsigned int EventAnalysis::m_uPassedEvents

protectedinherited

Definition at line 75 of file EventAnalysis.h.

m_x1DHistograms

std::map<unsigned int, TH1F*> EventAnalysis::m_x1DHistograms

protectedinherited

Definition at line 76 of file EventAnalysis.h.

m_x1DProfHistograms

std::map<unsigned int, TProfile*> EventAnalysis::m_x1DProfHistograms

protectedinherited

Definition at line 78 of file EventAnalysis.h.

m_x2DHistograms

std::map<unsigned int, TH2F*> EventAnalysis::m_x2DHistograms

protectedinherited

Definition at line 77 of file EventAnalysis.h.

m_x2DProfHistograms

std::map<unsigned int, TProfile2D*> EventAnalysis::m_x2DProfHistograms

protectedinherited

Definition at line 79 of file EventAnalysis.h.

m_xSampleName

std::string EventAnalysis::m_xSampleName

protectedinherited

Definition at line 81 of file EventAnalysis.h.

---

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

• MuonSelector.h
• MuonSelector.cxx