#include <ZmumuEvent.h>

Inheritance diagram for ZmumuEvent:

Collaboration diagram for ZmumuEvent:

Public Types
enum	{ MUON1 , MUON2 , MUON3_OVR1 , MUON4_OVR2 , NUM_MUONS }
enum	{ CENTRAL , FORWARD , BACKWARD , UNDEF }
enum	ZTYPE { MS , ME , ID , CB , NUM_TYPES }

Public Member Functions
	ZmumuEvent ()
virtual	~ZmumuEvent ()
virtual void	Init ()
virtual bool	Reco (int theLumiBlock=0)
void	doIsoSelection (bool doIso)
void	doIPSelection (bool doIPsel)
void	doMCPSelection (bool doMCP)
bool	AcceptEvent ()
void	finalize ()
unsigned int	getAcceptedEvents ()
const xAOD::Muon *	getCombMuon (unsigned int uPart)
const xAOD::TrackParticle *	getIDTrack (unsigned int uPart)
double	GetInvMass ()
const float &	getLeptonOpeningAngle (ZTYPE eType)
const xAOD::TrackParticle *getLooseIDTk	ATLAS_NOT_REENTRANT (unsigned int uPart)
const xAOD::TrackParticle *	getMSTrack (unsigned int uPart)
unsigned int	getNegMuon (ZTYPE eType)
unsigned int	getNumberOfTaggedMuons ()
unsigned int	getPosMuon (ZTYPE eType)
float	getPtImbalance (ZTYPE eType)
const std::string	getRegion () const
unsigned int	getTestedMuonCount ()
int	getZCharge (ZTYPE eType)
const float &	getZEta (ZTYPE eType)
const float &	getZMass (ZTYPE eType)
const float &	getZPhi (ZTYPE eType)
const float &	getZPt (ZTYPE eType)
void	OrderMuonList ()
void	setDebugMode (bool debug)
void	SetMaxLumiBlock (int newlumiblock)
void	SetMinLumiBlock (int newlumiblock)
void	SetMuonPtCut (double newvalue)
void	SetMuonQuality (const std::string &newname)
void	SetMassWindowLow (double newvalue)
void	SetMassWindowHigh (double newvalue)
void	SetLeadingMuonPtCut (double newvalue)
void	SetSecondMuonPtCut (double newvalue)
void	SetOpeningAngleCut (double newvalue)
void	SetZ0GapCut (double newvalue)
void	SetSkipMSCheck (bool value)
void	setContainer (PerfMonServices::CONTAINERS container)
void	SetMuonSelectionTool (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)

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 { ZMASS_MUON , ZMASS_MUONADJ , ZMASS_TRACK , ZMASS_COMB , NUM_1HISTOS }
typedef EventAnalysis	PARENT

Private Member Functions
void	Clear ()
bool	EventSelection (ZTYPE eType)
void	ReconstructKinematics ()
bool	RecordMuon (const xAOD::Muon *pxMuon)
void	Register ()

Private Attributes
MuonSelector	m_xMuonID
PerfMonServices::CONTAINERS	m_container
ToolHandle< CP::IMuonSelectionTool >	m_muonSelectionTool
unsigned int	m_uMuonTags
unsigned int	m_uTrackMatch
bool	m_bLooseMatch
double	m_etaCut
double	m_DiMuonPairInvMass = 0.0
double	m_LeadingMuonPtCut
double	m_SecondMuonPtCut
double	m_MassWindowLow
double	m_MassWindowHigh
double	m_OpeningAngleCut
double	m_Z0GapCut
bool	m_skipMScheck
int	m_minGoodLumiBlock
int	m_maxGoodLumiBlock
bool	m_doDebug
unsigned int	m_numberOfFullPassMuons {}
bool	m_passedSelectionCuts {}
int	m_analyzedEventCount {}
unsigned int	m_eventsWithoutEnoughMuonsCount {}
unsigned int	m_eventsWithEnoughMuonsCount {}
unsigned int	m_acceptedEventCount {}
unsigned int	m_testedMuonCount {}
unsigned int	m_acceptedMuonCount {}
unsigned int	m_eventselectioncount_toofewmuons {}
unsigned int	m_eventselectioncount_notallmuonsfilled {}
unsigned int	m_eventselectioncount_morethantwomuons {}
unsigned int	m_eventselectioncount_ptofleadingmuon {}
unsigned int	m_eventselectioncount_ptofsecondmuon {}
unsigned int	m_eventselectioncount_masswindow {}
unsigned int	m_eventselectioncount_openingangle {}
unsigned int	m_eventselectioncount_dimuoncharge {}
unsigned int	m_eventselectioncount_goodlumiblock {}
const xAOD::Muon *	m_pxRecMuon [NUM_MUONS] {}
const xAOD::TrackParticle *	m_pxMETrack [NUM_MUONS] {}
const xAOD::TrackParticle *	m_pxMSTrack [NUM_MUONS] {}
const xAOD::TrackParticle *	m_pxIDTrack [NUM_MUONS] {}
float	m_fZPt [NUM_TYPES] {}
float	m_fZEtaDir [NUM_TYPES] {}
float	m_fZPhiDir [NUM_TYPES] {}
float	m_fInvariantMass [NUM_TYPES] {}
float	m_fMuonDispersion [NUM_TYPES] {}
bool	m_SelectMuonByIso
bool	m_SelectMuonByIP
int	m_muon1 = 0
int	m_muon2 = 0

Detailed Description

Definition at line 27 of file ZmumuEvent.h.

Member Typedef Documentation

◆ PARENT

typedef EventAnalysis ZmumuEvent::PARENT

private

Definition at line 109 of file ZmumuEvent.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
MUON1
MUON2
MUON3_OVR1
MUON4_OVR2
NUM_MUONS

Definition at line 33 of file ZmumuEvent.h.

  {
    MUON1,
    MUON2,
    MUON3_OVR1,
    MUON4_OVR2,
    NUM_MUONS
  };

◆ anonymous enum

anonymous enum

Enumerator
CENTRAL
FORWARD
BACKWARD
UNDEF

Definition at line 42 of file ZmumuEvent.h.

  {
    CENTRAL,
    FORWARD,
    BACKWARD,
    UNDEF
  };

◆ HISTOS_1D

enum ZmumuEvent::HISTOS_1D

private

Enumerator
ZMASS_MUON
ZMASS_MUONADJ
ZMASS_TRACK
ZMASS_COMB
NUM_1HISTOS

Definition at line 173 of file ZmumuEvent.h.

  {
    ZMASS_MUON, ZMASS_MUONADJ, ZMASS_TRACK, ZMASS_COMB,
    NUM_1HISTOS
  };

◆ ZTYPE

enum ZmumuEvent::ZTYPE

Enumerator
MS
ME
ID
CB
NUM_TYPES

Definition at line 50 of file ZmumuEvent.h.

  {
    MS,     // Just the muon system ( uncorrected )
    ME,     // The adjusted muon system properties ( corr. for cal. )
    ID,     // Using the ID system.
    CB,     // Using both the muon & ID system.
    NUM_TYPES
  };

Constructor & Destructor Documentation

◆ ZmumuEvent()

ZmumuEvent::ZmumuEvent ( )

Definition at line 36 of file ZmumuEvent.cxx.

{
  m_xSampleName = "ZMM";
 
  m_container = PerfMonServices::MUID_COLLECTION;
 
  m_doDebug = false;
 
  // Setup the muon tags
  m_uMuonTags   = 2;
  m_uTrackMatch = 0;
  m_bLooseMatch = true;  // will use combined fit otherwise.
  m_etaCut      = 1.05;
  m_LeadingMuonPtCut = 20.;   
  m_SecondMuonPtCut = 15.;
  m_MassWindowLow = 60.0;
  m_MassWindowHigh = 120.0;
  m_OpeningAngleCut = 0.2; // in radians
  m_Z0GapCut = 5.0; // in mm
  m_minGoodLumiBlock = 0;
  m_maxGoodLumiBlock = 0;
  m_SelectMuonByIso = true;
  m_SelectMuonByIP = true;
  m_analyzedEventCount = 0;
  m_eventsWithoutEnoughMuonsCount = 0;
  m_eventsWithEnoughMuonsCount = 0;
  m_acceptedEventCount = 0;
  m_testedMuonCount = 0;
  m_acceptedMuonCount = 0;
  m_eventselectioncount_toofewmuons = 0;
  m_eventselectioncount_notallmuonsfilled = 0;
  m_eventselectioncount_morethantwomuons = 0;
  m_eventselectioncount_ptofleadingmuon = 0;
  m_eventselectioncount_ptofsecondmuon = 0;
  m_eventselectioncount_masswindow = 0;
  m_eventselectioncount_openingangle = 0;
  m_eventselectioncount_dimuoncharge = 0;
  m_eventselectioncount_goodlumiblock = 0;
  m_skipMScheck = false;
 
  return;
}

◆ ~ZmumuEvent()

ZmumuEvent::~ZmumuEvent ( )

virtual

Definition at line 80 of file ZmumuEvent.cxx.

81{

82}

Member Function Documentation

◆ AcceptEvent()

bool ZmumuEvent::AcceptEvent ( )

inline

Definition at line 67 of file ZmumuEvent.h.

67{ return m_passedSelectionCuts; }

ZmumuEvent::m_passedSelectionCuts

bool m_passedSelectionCuts

Definition ZmumuEvent.h:142

◆ ATLAS_NOT_REENTRANT()

const xAOD::TrackParticle *getLooseIDTk ZmumuEvent::ATLAS_NOT_REENTRANT ( unsigned int uPart )

◆ BookHistograms()

void ZmumuEvent::BookHistograms ( )

protectedvirtual

Reimplemented from EventAnalysis.

Definition at line 212 of file ZmumuEvent.cxx.

213{

214}

◆ 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);
}

◆ Clear()

void ZmumuEvent::Clear ( )

private

Definition at line 362 of file ZmumuEvent.cxx.

{
  m_numberOfFullPassMuons = 0;
  m_passedSelectionCuts   = false;
  m_DiMuonPairInvMass = -1.; // flag as no reconstructed inv mass yet
  m_muon1 = MUON1; // point to the first two
  m_muon2 = MUON2;
 
  for ( unsigned int u = 0; u < NUM_MUONS; ++u ) {
      m_pxRecMuon[u] = nullptr;
      m_pxMSTrack[u] = nullptr;
      m_pxMETrack[u] = nullptr;
      m_pxIDTrack[u] = nullptr;
  }
  for ( unsigned int v = 0; v < NUM_TYPES; ++v ) {
    m_fZPt[v]            = -999.9f;
    m_fZEtaDir[v]        = -999.9f;
    m_fZPhiDir[v]        = -999.9f;
    m_fInvariantMass[v]  = -999.9f;
    m_fMuonDispersion[v] = -999.9f;
  }
  return;
}

◆ doIPSelection()

void ZmumuEvent::doIPSelection ( bool doIPsel )

inline

Definition at line 65 of file ZmumuEvent.h.

65{ m_xMuonID.doIPSelection(doIPsel); }

ZmumuEvent::m_xMuonID

MuonSelector m_xMuonID

Definition ZmumuEvent.h:118

◆ doIsoSelection()

void ZmumuEvent::doIsoSelection ( bool doIso )

inline

Definition at line 64 of file ZmumuEvent.h.

64{ m_xMuonID.doIsoSelection(doIso); }

◆ doMCPSelection()

void ZmumuEvent::doMCPSelection ( bool doMCP )

inline

Definition at line 66 of file ZmumuEvent.h.

66{ m_xMuonID.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) );
}

◆ EventSelection()

bool ZmumuEvent::EventSelection ( ZTYPE eType )

private

Definition at line 219 of file ZmumuEvent.cxx.

{
  if(m_doDebug) {std::cout <<" * ZmumuEvent * Event selection ** START ** for type: " << eType << " m_NumberOfFullPassMuons: " << m_numberOfFullPassMuons << std::endl;}
 
  // First require two muon-id's with cuts pre-applied.
  if ( m_numberOfFullPassMuons < 2 ) {
    if (m_doDebug) {std::cout <<" * ZmumuEvent * Failing number of good muons == 2 :( " <<  m_numberOfFullPassMuons << std::endl;}
    return false;
  }
  m_eventselectioncount_toofewmuons++;
  
  // crosscheck all muons have been properly filled
  bool allMuonsGood = true;
  for (unsigned int muonid=0; muonid < m_numberOfFullPassMuons; muonid++) {
    if (!m_pxMSTrack[muonid]) {
      allMuonsGood = false;
    } 
  }
  if (!allMuonsGood){
    return false;
  } 
  m_eventselectioncount_notallmuonsfilled++;
   
  if ( m_numberOfFullPassMuons > 2 ) {
    if (m_doDebug) {std::cout <<" * ZmumuEvent * Failing number of good muons == 2 :( " <<  m_numberOfFullPassMuons << std::endl;}
    return false;
  }
  m_eventselectioncount_morethantwomuons++;
  
  // momentum of the muons
  double leadingMuonPt, secondMuonPt;
  switch ( eType )
    {
    case MS :
      {
    leadingMuonPt = m_pxMSTrack[m_muon1]->pt();
    secondMuonPt = m_pxMSTrack[m_muon2]->pt();
    break;
      }
    case ME:
      {
    leadingMuonPt = m_pxMETrack[m_muon1]->pt();
    secondMuonPt = m_pxMETrack[m_muon2]->pt();
    break;
      }
    case CB:
      {
    leadingMuonPt = m_pxRecMuon[m_muon1]->pt();
    secondMuonPt = m_pxRecMuon[m_muon2]->pt();
    break;
      }
    case ID:
      {
    leadingMuonPt = m_pxIDTrack[m_muon1]->pt();
    secondMuonPt = m_pxIDTrack[m_muon2]->pt();
    break;
      }
          
    default:
      leadingMuonPt = m_pxRecMuon[m_muon1]->pt();
      secondMuonPt = m_pxRecMuon[m_muon2]->pt();
    }
  // up to here the leading and second pt are not really in the right order.
  // order the muon pt:
  if (secondMuonPt > leadingMuonPt) {
    double tempPt = leadingMuonPt;
    leadingMuonPt = secondMuonPt;
    secondMuonPt = tempPt;
  }
 
  // muon pt cut
  // if ( !(leadingMuonPt > m_LeadingMuonPtCut*CLHEP::GeV &&  secondMuonPt >  m_SecondMuonPtCut*CLHEP::GeV ) ) {
  if ( leadingMuonPt < m_LeadingMuonPtCut*CLHEP::GeV ) {
    if(m_doDebug){  std::cout <<" * ZmumuEvent * Failing 1st muon pt cut * Reco Pt:  " << leadingMuonPt << " < " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl;}
    return false;
  }
  m_eventselectioncount_ptofleadingmuon++;
  
  if ( secondMuonPt < m_SecondMuonPtCut*CLHEP::GeV ) {
    if(m_doDebug){  std::cout <<" * ZmumuEvent * Failing 2nd muon pt cut * Reco Pt:  " << secondMuonPt << " < " <<  m_SecondMuonPtCut*CLHEP::GeV << std::endl;}
    return false;
  }
  m_eventselectioncount_ptofsecondmuon++;
 
  // Invariant mass window
  if ( m_fInvariantMass[eType]  < m_MassWindowLow  ) {
    if(m_doDebug) {std::cout <<" * ZmumuEvent * Failing mass window low cut:  reco m= " << m_fInvariantMass[eType] << " > " <<  m_MassWindowLow << std::endl;}
    return false;
  }
  if ( m_fInvariantMass[eType]  > m_MassWindowHigh ) {
    if(m_doDebug) {std::cout <<" * ZmumuEvent * Failing mass window high cut:  reco m= " << m_fInvariantMass[eType] << " > " <<  m_MassWindowHigh << std::endl;}
    return false;
  }
  m_eventselectioncount_masswindow++;
 
  // opening angle
  if ( m_fMuonDispersion[eType] <  m_OpeningAngleCut  ) {        
    if(m_doDebug) {std::cout <<" * ZmumuEvent * Failing opening angle cut. Opening angle " << m_fMuonDispersion[eType] << " < " <<  m_OpeningAngleCut << std::endl;}
    return false;
  }
  m_eventselectioncount_openingangle++;
 
  // opposite charge
  if ( getZCharge(eType) != 0  ) {
    if(m_doDebug) {
      std::cout <<" * ZmumuEvent * Failing get ZCharge != 0 cut * Reco q1= " << m_pxRecMuon[m_muon1]->charge()*m_pxRecMuon[m_muon1]->pt() <<std::endl;
    //<< "  q2= " <<  m_pxRecMuon[m_muon2]->charge()*m_pxRecMuon[m_muon2]->pt() << std::endl; //This might not exist!
      std::cout <<"                                             * ID   q1= " << m_pxIDTrack[m_muon1]->charge()*m_pxIDTrack[m_muon1]->pt() << std::endl;
    //  << "  q2= " <<  m_pxIDTrack[m_muon2]->charge()*m_pxIDTrack[m_muon2]->pt() << std::endl; //This might not exist!
    }
    return false;
  }
  m_eventselectioncount_dimuoncharge++;
 
  //
  // both muons should come from the same vertex
  // if the vertex information is used, that is already guaranteed, but if not, one has to check the z0
  if (eType == ID) {
    double z0_muon1 = m_pxIDTrack[m_muon1]->vz() +  m_pxIDTrack[m_muon1]->z0();
    double z0_muon2 = m_pxIDTrack[m_muon2]->vz() +  m_pxIDTrack[m_muon2]->z0();
    if(m_doDebug) {
      std::cout << " * ZmumuEvent *  z0_muon1= " << z0_muon1 << "  z0_muon2= " << z0_muon2 << "  delta= " << z0_muon1-z0_muon2 << std::endl;
    }
    if ( std::abs(z0_muon1 - z0_muon2) > m_Z0GapCut) {
      if(m_doDebug) {
    std::cout << " * ZmumuEvent * Failing common vertex cut. z.vtx1= " << m_pxIDTrack[m_muon1]->vz() << "  z.vtx2= " << m_pxIDTrack[m_muon2]->vz() << std::endl;
    std::cout << " * ZmumuEvent * Failing common vertex cut. IDTrk.z0_1= " << m_pxIDTrack[m_muon1]->z0() << "  IDTrk.z0_2= " << m_pxIDTrack[m_muon2]->z0() << std::endl;
    std::cout << " * ZmumuEvent * z0_muon1= " << z0_muon1 << "  z0_muon2= " << z0_muon2 << "  delta= " << z0_muon1-z0_muon2 << " > " << m_Z0GapCut << " (cut)" << std::endl;
      } 
      return false;
    }
  }
  
 
  if(m_doDebug) {
    std::cout <<" * ZmumuEvent * Good muon pair: pt= " <<  leadingMuonPt/1000 
          << " & " << secondMuonPt/1000 
          << " GeV   dimuon invariant mass = " << m_fInvariantMass[eType] << " GeV " << std::endl;
  }
  return true;
}

◆ finalize()

void ZmumuEvent::finalize ( )

Definition at line 670 of file ZmumuEvent.cxx.

{
  m_xMuonID.finalize();
  
  std::cout << " ** ZmumuEvent ** -- STATS -- " << std::endl
        << "    Analyzed events           : " << m_analyzedEventCount << std::endl
            << "    Events passing LumiBlock  : " << m_eventselectioncount_goodlumiblock << std::endl
        << "    Tested muons              : " << m_testedMuonCount << std::endl
        << "    Accepted muons            : " << m_acceptedMuonCount << std::endl
        << "    Events without enough muon: " << m_eventsWithoutEnoughMuonsCount << std::endl
        << "    Events with enough muons  : " << m_eventsWithEnoughMuonsCount << std::endl
            << "    pass few muons            : " << m_eventselectioncount_toofewmuons << std::endl
        << "    pass not filled muons     : " << m_eventselectioncount_notallmuonsfilled << std::endl
        << "    pass more than 2 muons    : " << m_eventselectioncount_morethantwomuons << std::endl
        << "    pass pt lead              : " << m_eventselectioncount_ptofleadingmuon << std::endl
        << "    pass pt 2nd               : " << m_eventselectioncount_ptofsecondmuon << std::endl
        << "    pass mass window          : " << m_eventselectioncount_masswindow << std::endl  
        << "    pass opening angle        : " << m_eventselectioncount_openingangle << std::endl
        << "    pass dimuon charge        : " << m_eventselectioncount_dimuoncharge << std::endl
        << "    Accepted events           : " << m_acceptedEventCount << std::endl
        << std::endl;
  return;
}

◆ getAcceptedEvents()

unsigned int ZmumuEvent::getAcceptedEvents ( )

inline

Definition at line 69 of file ZmumuEvent.h.

69{ return m_acceptedEventCount; }

◆ getCombMuon()

const xAOD::Muon * ZmumuEvent::getCombMuon ( unsigned int uPart )

inline

Definition at line 70 of file ZmumuEvent.h.

70{ return (uPart < NUM_MUONS) ? m_pxRecMuon[uPart] : NULL; }

◆ getIDTrack()

const xAOD::TrackParticle * ZmumuEvent::getIDTrack ( unsigned int uPart )

inline

Definition at line 71 of file ZmumuEvent.h.

71{ return (uPart < NUM_MUONS) ? m_pxIDTrack[uPart] : NULL; }

◆ GetInvMass()

double ZmumuEvent::GetInvMass ( )

inline

Definition at line 72 of file ZmumuEvent.h.

72{return m_DiMuonPairInvMass;}

◆ getLeptonOpeningAngle()

const float & ZmumuEvent::getLeptonOpeningAngle ( ZTYPE eType )

inline

Definition at line 73 of file ZmumuEvent.h.

73{ return m_fMuonDispersion[eType]; }

◆ getMSTrack()

const xAOD::TrackParticle * ZmumuEvent::getMSTrack ( unsigned int uPart )

inline

Definition at line 75 of file ZmumuEvent.h.

75{ return (uPart < NUM_MUONS) ? m_pxMSTrack[uPart] : NULL; }

◆ getNegMuon()

unsigned int ZmumuEvent::getNegMuon ( ZTYPE eType )

Definition at line 550 of file ZmumuEvent.cxx.

{
  int uTmp = getPosMuon( eType );
  if ( uTmp == 999 )
    {
      return 999;
    }
  else
    {
      return ( ( uTmp == m_muon1 ) ? m_muon2 : m_muon1 );
    }
}

◆ getNumberOfTaggedMuons()

unsigned int ZmumuEvent::getNumberOfTaggedMuons ( )

inline

Definition at line 77 of file ZmumuEvent.h.

77{ return m_numberOfFullPassMuons; }

◆ getPosMuon()

unsigned int ZmumuEvent::getPosMuon ( ZTYPE eType )

Definition at line 517 of file ZmumuEvent.cxx.

{
  if ( getNumberOfTaggedMuons() != 2 ) return 999;
  if ( getZCharge(eType) != 0        ) return 999;
 
  switch ( eType )
    {
    case MS :
      {
    if ( !m_pxMSTrack[m_muon1] || !m_pxMSTrack[m_muon2] ) return 999;
    return ( static_cast<int>( m_pxMSTrack[m_muon1]->charge() ) == 1  ? m_muon1 : m_muon2 );
      }
    case ME:
      {
    if ( !m_pxMETrack[m_muon1] || !m_pxMETrack[m_muon2] ) return 999;
    return ( static_cast<int>( m_pxMETrack[m_muon1]->charge() ) == 1  ? m_muon1 : m_muon2 );
      }
    case CB:
      {
    if ( !m_pxRecMuon[m_muon1] || !m_pxRecMuon[m_muon2] ) return 999;
    return ( static_cast<int>( m_pxRecMuon[m_muon1]->charge() ) == 1  ? m_muon1 : m_muon2 );
      }
    case ID:
      {
    if ( !m_pxIDTrack[m_muon1] || !m_pxIDTrack[m_muon2] ) return 999;
    return ( static_cast<int>( m_pxIDTrack[m_muon1]->charge() ) == 1 ? m_muon1 : m_muon2 );
      }
    default:
      return 999;
    }
}

◆ getPtImbalance()

float ZmumuEvent::getPtImbalance ( ZTYPE eType )

Definition at line 457 of file ZmumuEvent.cxx.

{
  // First determine what's positive
  if ( m_numberOfFullPassMuons == 2 )
    {
      switch ( eType )
    {
    case MS :
      {
        return EvalPtDiff( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
      }
    case ME:
      {
        return EvalPtDiff( m_pxMETrack[m_muon1], m_pxMETrack[m_muon2] );
      }
    case CB:
      {
        return EvalPtDiff( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
      }
    case ID:
      {
        return EvalPtDiff( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
      }
    default:
      return -999.0;
    }
    }
  else
    {
      return -999.0;
    }
}

◆ getRegion()

const std::string ZmumuEvent::getRegion ( ) const

Definition at line 95 of file ZmumuEvent.cxx.

                                           {
 
  const double eta1 = std::abs(m_pxRecMuon[m_muon1]->eta());
  const double eta2 = std::abs(m_pxRecMuon[m_muon2]->eta());
 
  if ( eta1 < m_etaCut && eta2 < m_etaCut )
    return "BB";
 
  else if( (eta1 < m_etaCut && eta2 > m_etaCut) || (eta1 > m_etaCut && eta2 < m_etaCut) )
    return "BE";
 
  else return "EE";
}

◆ getTestedMuonCount()

unsigned int ZmumuEvent::getTestedMuonCount ( )

inline

Definition at line 81 of file ZmumuEvent.h.

81{ return m_testedMuonCount; }

◆ getZCharge()

int ZmumuEvent::getZCharge ( ZTYPE eType )

Definition at line 491 of file ZmumuEvent.cxx.

{
  switch ( eType )
    {
    case MS :
      {
    return ( static_cast<int>( EvalCharge( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] ) ) );
      }
    case ME:
      {
    return ( static_cast<int>( EvalCharge( m_pxMETrack[m_muon1], m_pxMETrack[m_muon2] ) ) );
      }
    case CB:
      {
    return ( static_cast<int>( EvalCharge( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] ) ) );
      }
    case ID:
      {
    return ( static_cast<int>( EvalCharge( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] ) ) );
      }
    default:
      return -999;
    }
}

◆ getZEta()

const float & ZmumuEvent::getZEta ( ZTYPE eType )

inline

Definition at line 83 of file ZmumuEvent.h.

83{ return m_fZEtaDir[eType]; }

◆ getZMass()

const float & ZmumuEvent::getZMass ( ZTYPE eType )

inline

Definition at line 84 of file ZmumuEvent.h.

84{ return m_fInvariantMass[eType]; }

◆ getZPhi()

const float & ZmumuEvent::getZPhi ( ZTYPE eType )

inline

Definition at line 85 of file ZmumuEvent.h.

85{ return m_fZPhiDir[eType]; }

◆ getZPt()

const float & ZmumuEvent::getZPt ( ZTYPE eType )

inline

Definition at line 86 of file ZmumuEvent.h.

86{ return m_fZPt[eType]; }

◆ Init()

void ZmumuEvent::Init ( )

virtual

Reimplemented from EventAnalysis.

Definition at line 85 of file ZmumuEvent.cxx.

{
  m_xMuonID.Init();
  
  PARENT::Init();
}

◆ OrderMuonList()

void ZmumuEvent::OrderMuonList ( )

Definition at line 634 of file ZmumuEvent.cxx.

{
  int muPlusId = -9;
  int muMinusId = -9;
  double muPlusPt = 0.;
  double muMinusPt = 0.;
 
  if (m_doDebug) {std::cout <<" * ZmumuEvent * OrderMuonList * START *  input number of muons: " << m_numberOfFullPassMuons << std::endl;}
 
  if (m_numberOfFullPassMuons >= 2) {
    for (int imuon=0; imuon < (int) m_numberOfFullPassMuons; imuon++) {
      if (m_pxRecMuon[imuon] != nullptr) {
    
    if (m_pxRecMuon[imuon]->charge()== 1 && m_pxRecMuon[imuon]->pt()> muPlusPt) {
      muPlusPt = m_pxRecMuon[imuon]->pt();
      muPlusId = imuon;
    } 
    if (m_pxRecMuon[imuon]->charge()==-1 && m_pxRecMuon[imuon]->pt()> muMinusPt) {
      muMinusPt = m_pxRecMuon[imuon]->pt();
      muMinusId = imuon;
    } 
      } // muon exist
    } // for (int imuon
  } // if (m_numberOfFullPassMuons >= 2)
  if (muPlusId>=0 && muMinusId>=0) {
    m_muon1 = muPlusId;
    m_muon2 = muMinusId;
    m_numberOfFullPassMuons = 2; // the two muons have been selected. Let's pretend we have only two muons then.
  }
  if (m_doDebug) {std::cout <<" * ZmumuEvent * OrderMuonList * COMPLETED ** numberOfFullPassMuons: " << m_numberOfFullPassMuons 
                << "  mu+: " << muPlusId << " mu-: " << muMinusId << std::endl;}
  return;
}

◆ Reco()

bool ZmumuEvent::Reco ( int theLumiBlock = 0 )

virtual

Definition at line 111 of file ZmumuEvent.cxx.

{
  if (m_doDebug) { std::cout << " * ZmumuEvent * ZmumuEvent::Reco() starting " << std::endl; }
  m_analyzedEventCount++;
 
  // Clear out the previous events record.
  this->Clear();
 
  // before getting into business, check lumiblock is in requested range
  if (m_maxGoodLumiBlock > m_minGoodLumiBlock) {
    // lumiblock range is requested
    if ( theLumiBlock < m_minGoodLumiBlock) return false;
    if ( theLumiBlock > m_maxGoodLumiBlock) return false;
  }
  m_eventselectioncount_goodlumiblock++;
 
  // retrieve muons
  const xAOD::MuonContainer* pxMuonContainer = PerfMonServices::getContainer<xAOD::MuonContainer>( m_container );
 
  // START patch by Anthony to avoid crash when MuonSpetrometer::Pt was not defined mainly for data16 
  // WARNING thus is necessary for data16 !!
  if (false) {
    for( auto muon :  *pxMuonContainer ){
      const xAOD::TrackParticle* idtrk(nullptr);
      const xAOD::TrackParticle* metrk(nullptr);
      using enum xAOD::Muon::TrackParticleType;
      idtrk = muon->trackParticle(InnerDetectorTrackParticle);
      metrk = muon->trackParticle(ExtrapolatedMuonSpectrometerTrackParticle);
      if (idtrk && metrk) {
    static const SG::Decorator<float> InnerDetectorPtAcc("InnerDetectorPt");
    static const SG::Decorator<float> MuonSpectrometerPtAcc("MuonSpectrometerPt");
    InnerDetectorPtAcc(*muon) = idtrk->pt();
    MuonSpectrometerPtAcc(*muon) = metrk->pt();
      }
    }
  }
  // END patch 
 
  if (pxMuonContainer != nullptr) {
    if (m_doDebug) {std::cout << " * ZmumuEvent * track list has "<< pxMuonContainer->size() << " muon in xAOD::MuonContainer " << m_container <<std::endl; }
    xAOD::MuonContainer::const_iterator xMuonItr  = pxMuonContainer->begin();
    xAOD::MuonContainer::const_iterator xMuonItrE  = pxMuonContainer->end();
 
    int attemptedMuonCount = 0;
    int acceptedMuonCount = 0;
 
    while ( xMuonItr != xMuonItrE ){ // this loops on the muons in the pxMuonContainer
      const xAOD::Muon* pxCMuon = *xMuonItr;
      attemptedMuonCount++;
      m_testedMuonCount++;
      if(m_doDebug){std::cout << " * ZmumuEvent * Reco() ** attempt on xMuonItr number "<< attemptedMuonCount << " (pointer: "<< *xMuonItr <<")" << std::endl; }
      // Apply muon cuts
      if ( m_xMuonID.passSelection( pxCMuon) ) {
    if (RecordMuon( pxCMuon )) {
      acceptedMuonCount++;
      m_acceptedMuonCount++;
      if (m_doDebug) {std::cout << "                          This muon is accepeted !! this is muon number " << acceptedMuonCount << " & full pass" << m_numberOfFullPassMuons << std::endl; }
    }
      }
      ++xMuonItr;
    } // end loop on muons
    if (m_doDebug) {std::cout << " * ZmumuEvent * accepted " << acceptedMuonCount << " muons from the input list of "<< pxMuonContainer->size() <<std::endl; }
 
    if (acceptedMuonCount < 2) m_eventsWithoutEnoughMuonsCount++;
    if (acceptedMuonCount >= 2) m_eventsWithEnoughMuonsCount++;
  } // muon container exist
  else {
    std::cout << " * ZmumuEvent * Can't retrieve combined muon collection (container: " << m_container <<") " << std::endl;
    return false;
  }
  
  // Ordering of muons
  this->OrderMuonList();
  
  // Reconstruct the invariant mass ( based on mu-sys pt ).
  ReconstructKinematics();
  
  m_passedSelectionCuts = EventSelection(ID);
  m_DiMuonPairInvMass =  m_fInvariantMass[ID];
  
  if (m_passedSelectionCuts) m_acceptedEventCount++;
  
  if(m_doDebug) {
    if ( m_passedSelectionCuts) std::cout << " * ZmumuEvent * Reco() * result of analyzed event " << m_analyzedEventCount << " --> Selected event :) " << std::endl;
    if (!m_passedSelectionCuts) std::cout << " * ZmumuEvent * Reco() * result of analyzed event " << m_analyzedEventCount << " --> Rejected event :( " << std::endl;
  }
  if (m_doDebug) {
    std::cout << " * ZmumuEvent::Reco * COMPLETED * Event has " << m_numberOfFullPassMuons 
          << " muons. " << m_acceptedEventCount 
          << " events accpeted out of " <<  m_analyzedEventCount 
          << " tested ";
    if (m_passedSelectionCuts) std::cout << " This m= " << m_DiMuonPairInvMass; 
    std::cout << " * return " << m_passedSelectionCuts << std::endl; 
  }
  return m_passedSelectionCuts;
}

◆ ReconstructKinematics()

void ZmumuEvent::ReconstructKinematics ( )

private

Definition at line 430 of file ZmumuEvent.cxx.

{
  // Three ways. No checks here. Thus make sure the pointers are ok before this.
  if ( m_numberOfFullPassMuons == 2 )
    {
      // Note that all the util. functions will check the pointers & return -999.9f on failure.
      m_fInvariantMass[MS]      = EvalDiMuInvMass( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
      m_fMuonDispersion[MS]     = EvaluateAngle(   m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
      m_fZPt[MS]                = EvalPt(          m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
      m_fZEtaDir[MS]            = EvalEta(         m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
      m_fZPhiDir[MS]            = EvalPhi(         m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
 
      m_fInvariantMass[CB]      = EvalDiMuInvMass( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
      m_fMuonDispersion[CB]     = EvaluateAngle(   m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
      m_fZPt[CB]                = EvalPt(          m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
      m_fZEtaDir[CB]            = EvalEta(         m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
      m_fZPhiDir[CB]            = EvalPhi(         m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
 
      m_fInvariantMass[ID]      = EvalDiMuInvMass( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2]);
      m_fMuonDispersion[ID]     = EvaluateAngle(   m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
      m_fZPt[ID]                = EvalPt(          m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
      m_fZEtaDir[ID]            = EvalEta(         m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
      m_fZPhiDir[ID]            = EvalPhi(         m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
    }
}

◆ RecordMuon()

bool ZmumuEvent::RecordMuon ( const xAOD::Muon * pxMuon )

private

Definition at line 387 of file ZmumuEvent.cxx.

{
  if(m_doDebug) { std::cout <<" * ZmumuEvent * RecordMuon * START ** muons recorded so far "<< m_numberOfFullPassMuons << " up to a maximum of " << NUM_MUONS << std::endl;}
 
  // This shouldn't really ever happen but just in case.
  if ( !pxMuon ) {
    if(m_doDebug) { std::cout <<" * ZmumuEvent * RecordMuon * bad pxMuon --> EXIT "<< std::endl;}
    return false;
  }
 
  if ( m_numberOfFullPassMuons < NUM_MUONS ) {
      // The main Muon
      m_pxRecMuon[m_numberOfFullPassMuons] = pxMuon;
      // Tracking Muon Spectrometer ( raw )
      const xAOD::TrackParticle* pxMSTrack   = pxMuon->trackParticle(xAOD::Muon::TrackParticleType::MuonSpectrometerTrackParticle);
      if (!pxMSTrack) {
    if(m_doDebug){  std::cout <<" * ZmumuEvent * RecordMuon * bad pxMSmuon --> EXIT "<< std::endl;}
    return false;
      } 
      m_pxMSTrack[m_numberOfFullPassMuons] = pxMSTrack;
 
      // Tracking ID ( fix later to include loose match track conditions )
      const xAOD::TrackParticle*  pxIDTrack  = pxMuon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle);
      if (!pxIDTrack) {
    return false;
      }      
      m_pxIDTrack[m_numberOfFullPassMuons] = pxIDTrack;
      //
      if(m_doDebug){  std::cout <<"                m_pxRecMuon[" << m_numberOfFullPassMuons <<"]" 
                << "  pt= " << m_pxRecMuon[m_numberOfFullPassMuons]->pt() << "  q= "<< m_pxRecMuon[m_numberOfFullPassMuons]->charge() << std::endl;}
      if(m_doDebug){  std::cout <<"                m_pxMSTrack[" << m_numberOfFullPassMuons <<"]" 
                <<"   pt= " << m_pxMSTrack[m_numberOfFullPassMuons]->pt() << "  q= " << m_pxMSTrack[m_numberOfFullPassMuons]->charge() << std::endl;}
      if(m_doDebug){  std::cout <<"                m_pxIDTrack[" << m_numberOfFullPassMuons <<"]"
                <<"   pt= " << m_pxIDTrack[m_numberOfFullPassMuons]->pt() << "  q= " << m_pxIDTrack[m_numberOfFullPassMuons]->charge() << std::endl;}
      // update count
      ++m_numberOfFullPassMuons;
  }
  if(m_doDebug){  std::cout <<" * ZmumuEvent * RecordMuon * return with a total of " << m_numberOfFullPassMuons << std::endl;}
  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_");
}

◆ setContainer()

void ZmumuEvent::setContainer ( PerfMonServices::CONTAINERS container )

inline

Definition at line 102 of file ZmumuEvent.h.

102{ m_container = container; };

SG::container

const SG::AuxVectorData * container() const

Return the container holding this element.

◆ setDebugMode()

void ZmumuEvent::setDebugMode ( bool debug )

inline

Definition at line 88 of file ZmumuEvent.h.

88{ m_doDebug=debug; }

debug

const bool debug

Definition MakeUncertaintyPlots.cxx:53

◆ SetLeadingMuonPtCut()

void ZmumuEvent::SetLeadingMuonPtCut ( double newvalue )

Definition at line 601 of file ZmumuEvent.cxx.

{
  // first set the new pt cut value
  m_LeadingMuonPtCut = newvalue;
  
 
  // the second muon pt cut can not be higher than the leading muon pt cut:
  if (m_LeadingMuonPtCut < m_SecondMuonPtCut) this->SetSecondMuonPtCut(m_LeadingMuonPtCut);
 
  // this has to be translated to the MuonSelector
  // but there one has to use the minimum momentum --> second muon
  //this->SetMuonPtCut(m_SecondMuonPtCut);
  if(m_doDebug && false){std::cout <<" * ZmumuEvent * SetLeadingMuonPtCut * new Pt cuts:  " << m_LeadingMuonPtCut << " & " << m_SecondMuonPtCut << "  MuonSelector: " << m_xMuonID.GetPtCut() << std::endl;}
  return;
}

◆ SetMassWindowHigh()

void ZmumuEvent::SetMassWindowHigh ( double newvalue )

inline

Definition at line 95 of file ZmumuEvent.h.

95{ m_MassWindowHigh = newvalue; }

◆ SetMassWindowLow()

void ZmumuEvent::SetMassWindowLow ( double newvalue )

inline

Definition at line 94 of file ZmumuEvent.h.

94{ m_MassWindowLow = newvalue; }

◆ SetMaxLumiBlock()

void ZmumuEvent::SetMaxLumiBlock ( int newlumiblock )

inline

Definition at line 89 of file ZmumuEvent.h.

89{ m_maxGoodLumiBlock = newlumiblock; }

◆ SetMinLumiBlock()

void ZmumuEvent::SetMinLumiBlock ( int newlumiblock )

inline

Definition at line 90 of file ZmumuEvent.h.

90{ m_minGoodLumiBlock = newlumiblock; }

◆ SetMuonPtCut()

void ZmumuEvent::SetMuonPtCut ( double newvalue )

inline

Definition at line 91 of file ZmumuEvent.h.

91{ m_xMuonID.SetPtCut(newvalue); }

◆ SetMuonQuality()

void ZmumuEvent::SetMuonQuality ( const std::string & newname )

inline

Definition at line 92 of file ZmumuEvent.h.

92{ m_xMuonID.SetMuonQualityRequirement(newname); }

◆ SetMuonSelectionTool()

void ZmumuEvent::SetMuonSelectionTool ( ToolHandle< CP::IMuonSelectionTool > mst )

inline

Definition at line 103 of file ZmumuEvent.h.

103{ m_muonSelectionTool = mst; m_xMuonID.SetCustomMuonSelectionTool (mst); };

ZmumuEvent::m_muonSelectionTool

ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool

Definition ZmumuEvent.h:120

◆ SetOpeningAngleCut()

void ZmumuEvent::SetOpeningAngleCut ( double newvalue )

inline

Definition at line 98 of file ZmumuEvent.h.

98{m_OpeningAngleCut = newvalue;}

◆ SetSecondMuonPtCut()

void ZmumuEvent::SetSecondMuonPtCut ( double newvalue )

Definition at line 618 of file ZmumuEvent.cxx.

{
  m_SecondMuonPtCut = newvalue;
 
  // second muon pt shouldn't be higher than the leading muon pt
  if (m_LeadingMuonPtCut < m_SecondMuonPtCut) this->SetLeadingMuonPtCut(m_LeadingMuonPtCut);
 
  // this has to be translated to the MuonSelector
  this->SetMuonPtCut(m_SecondMuonPtCut);
 
  if(m_doDebug && false){std::cout <<" * ZmumuEvent * SetSecondMuonPtCut * new Pt cuts:  " << m_LeadingMuonPtCut << " & " << m_SecondMuonPtCut << "  MuonSelector: " << m_xMuonID.GetPtCut() << std::endl;}
 
  return;
}

◆ SetSkipMSCheck()

void ZmumuEvent::SetSkipMSCheck ( bool value )

inline

Definition at line 100 of file ZmumuEvent.h.

100{m_skipMScheck = value;}

athena.value

value

Definition athena.py:126

◆ SetZ0GapCut()

void ZmumuEvent::SetZ0GapCut ( double newvalue )

inline

Definition at line 99 of file ZmumuEvent.h.

99{m_Z0GapCut = newvalue;}

Member Data Documentation

◆ invalidAnswer

float EventAnalysis::invalidAnswer {-999.9f}

staticconstexprinherited

Definition at line 40 of file EventAnalysis.h.

40{-999.9f};

◆ m_acceptedEventCount

unsigned int ZmumuEvent::m_acceptedEventCount {}

private

Definition at line 146 of file ZmumuEvent.h.

146{};

◆ m_acceptedMuonCount

unsigned int ZmumuEvent::m_acceptedMuonCount {}

private

Definition at line 148 of file ZmumuEvent.h.

148{};

◆ m_analyzedEventCount

int ZmumuEvent::m_analyzedEventCount {}

private

Definition at line 143 of file ZmumuEvent.h.

143{};

◆ m_bLooseMatch

bool ZmumuEvent::m_bLooseMatch

private

Definition at line 125 of file ZmumuEvent.h.

◆ m_container

PerfMonServices::CONTAINERS ZmumuEvent::m_container

private

Definition at line 119 of file ZmumuEvent.h.

◆ m_DiMuonPairInvMass

double ZmumuEvent::m_DiMuonPairInvMass = 0.0

private

Definition at line 127 of file ZmumuEvent.h.

◆ m_doDebug

bool ZmumuEvent::m_doDebug

private

Definition at line 139 of file ZmumuEvent.h.

◆ m_etaCut

double ZmumuEvent::m_etaCut

private

Definition at line 126 of file ZmumuEvent.h.

◆ m_eventselectioncount_dimuoncharge

unsigned int ZmumuEvent::m_eventselectioncount_dimuoncharge {}

private

Definition at line 156 of file ZmumuEvent.h.

156{};

◆ m_eventselectioncount_goodlumiblock

unsigned int ZmumuEvent::m_eventselectioncount_goodlumiblock {}

private

Definition at line 157 of file ZmumuEvent.h.

157{};

◆ m_eventselectioncount_masswindow

unsigned int ZmumuEvent::m_eventselectioncount_masswindow {}

private

Definition at line 154 of file ZmumuEvent.h.

154{};

◆ m_eventselectioncount_morethantwomuons

unsigned int ZmumuEvent::m_eventselectioncount_morethantwomuons {}

private

Definition at line 151 of file ZmumuEvent.h.

151{};

◆ m_eventselectioncount_notallmuonsfilled

unsigned int ZmumuEvent::m_eventselectioncount_notallmuonsfilled {}

private

Definition at line 150 of file ZmumuEvent.h.

150{};

◆ m_eventselectioncount_openingangle

unsigned int ZmumuEvent::m_eventselectioncount_openingangle {}

private

Definition at line 155 of file ZmumuEvent.h.

155{};

◆ m_eventselectioncount_ptofleadingmuon

unsigned int ZmumuEvent::m_eventselectioncount_ptofleadingmuon {}

private

Definition at line 152 of file ZmumuEvent.h.

152{};

◆ m_eventselectioncount_ptofsecondmuon

unsigned int ZmumuEvent::m_eventselectioncount_ptofsecondmuon {}

private

Definition at line 153 of file ZmumuEvent.h.

153{};

◆ m_eventselectioncount_toofewmuons

unsigned int ZmumuEvent::m_eventselectioncount_toofewmuons {}

private

Definition at line 149 of file ZmumuEvent.h.

149{};

◆ m_eventsWithEnoughMuonsCount

unsigned int ZmumuEvent::m_eventsWithEnoughMuonsCount {}

private

Definition at line 145 of file ZmumuEvent.h.

145{};

◆ m_eventsWithoutEnoughMuonsCount

unsigned int ZmumuEvent::m_eventsWithoutEnoughMuonsCount {}

private

Definition at line 144 of file ZmumuEvent.h.

144{};

◆ m_fInvariantMass

float ZmumuEvent::m_fInvariantMass[NUM_TYPES] {}

private

Definition at line 169 of file ZmumuEvent.h.

169{};

◆ m_fMuonDispersion

float ZmumuEvent::m_fMuonDispersion[NUM_TYPES] {}

private

Definition at line 170 of file ZmumuEvent.h.

170{};

◆ m_fZEtaDir

float ZmumuEvent::m_fZEtaDir[NUM_TYPES] {}

private

Definition at line 167 of file ZmumuEvent.h.

167{};

◆ m_fZPhiDir

float ZmumuEvent::m_fZPhiDir[NUM_TYPES] {}

private

Definition at line 168 of file ZmumuEvent.h.

168{};

◆ m_fZPt

float ZmumuEvent::m_fZPt[NUM_TYPES] {}

private

Definition at line 166 of file ZmumuEvent.h.

166{};

◆ m_LeadingMuonPtCut

double ZmumuEvent::m_LeadingMuonPtCut

private

Definition at line 129 of file ZmumuEvent.h.

◆ m_MassWindowHigh

double ZmumuEvent::m_MassWindowHigh

private

Definition at line 132 of file ZmumuEvent.h.

◆ m_MassWindowLow

double ZmumuEvent::m_MassWindowLow

private

Definition at line 131 of file ZmumuEvent.h.

◆ m_maxGoodLumiBlock

int ZmumuEvent::m_maxGoodLumiBlock

private

Definition at line 137 of file ZmumuEvent.h.

◆ m_minGoodLumiBlock

int ZmumuEvent::m_minGoodLumiBlock

private

Definition at line 136 of file ZmumuEvent.h.

◆ m_muon1

int ZmumuEvent::m_muon1 = 0

private

Definition at line 184 of file ZmumuEvent.h.

◆ m_muon2

int ZmumuEvent::m_muon2 = 0

private

Definition at line 185 of file ZmumuEvent.h.

◆ m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> ZmumuEvent::m_muonSelectionTool

private

Definition at line 120 of file ZmumuEvent.h.

◆ m_numberOfFullPassMuons

unsigned int ZmumuEvent::m_numberOfFullPassMuons {}

private

Definition at line 141 of file ZmumuEvent.h.

141{};

◆ m_OpeningAngleCut

double ZmumuEvent::m_OpeningAngleCut

private

Definition at line 133 of file ZmumuEvent.h.

◆ m_passedSelectionCuts

bool ZmumuEvent::m_passedSelectionCuts {}

private

Definition at line 142 of file ZmumuEvent.h.

142{};

◆ m_pxIDTrack

const xAOD::TrackParticle* ZmumuEvent::m_pxIDTrack[NUM_MUONS] {}

private

Definition at line 163 of file ZmumuEvent.h.

163{}; // Pointer to ID track

◆ m_pxMETrack

const xAOD::TrackParticle* ZmumuEvent::m_pxMETrack[NUM_MUONS] {}

private

Definition at line 161 of file ZmumuEvent.h.

161{}; // Pointer to muon spectro ( corr. )

◆ m_pxMSTrack

const xAOD::TrackParticle* ZmumuEvent::m_pxMSTrack[NUM_MUONS] {}

private

Definition at line 162 of file ZmumuEvent.h.

162{}; // Pointer to muon spectro

◆ m_pxRecMuon

const xAOD::Muon* ZmumuEvent::m_pxRecMuon[NUM_MUONS] {}

private

Definition at line 160 of file ZmumuEvent.h.

160{};

◆ m_SecondMuonPtCut

double ZmumuEvent::m_SecondMuonPtCut

private

Definition at line 130 of file ZmumuEvent.h.

◆ m_SelectMuonByIP

bool ZmumuEvent::m_SelectMuonByIP

private

Definition at line 181 of file ZmumuEvent.h.

◆ m_SelectMuonByIso

bool ZmumuEvent::m_SelectMuonByIso

private

Definition at line 180 of file ZmumuEvent.h.

◆ m_skipMScheck

bool ZmumuEvent::m_skipMScheck

private

Definition at line 135 of file ZmumuEvent.h.

◆ m_testedMuonCount

unsigned int ZmumuEvent::m_testedMuonCount {}

private

Definition at line 147 of file ZmumuEvent.h.

147{};

◆ m_uMuonTags

unsigned int ZmumuEvent::m_uMuonTags

private

Definition at line 123 of file ZmumuEvent.h.

◆ m_uPassedEvents

unsigned int EventAnalysis::m_uPassedEvents

protectedinherited

Definition at line 75 of file EventAnalysis.h.

◆ m_uTrackMatch

unsigned int ZmumuEvent::m_uTrackMatch

private

Definition at line 124 of file ZmumuEvent.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_xMuonID

MuonSelector ZmumuEvent::m_xMuonID

private

Definition at line 118 of file ZmumuEvent.h.

◆ m_xSampleName

std::string EventAnalysis::m_xSampleName

protectedinherited

Definition at line 81 of file EventAnalysis.h.

◆ m_Z0GapCut

double ZmumuEvent::m_Z0GapCut

private

Definition at line 134 of file ZmumuEvent.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ PARENT

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

◆ HISTOS_1D

◆ ZTYPE

Constructor & Destructor Documentation

◆ ZmumuEvent()

◆ ~ZmumuEvent()

Member Function Documentation

◆ AcceptEvent()

◆ ATLAS_NOT_REENTRANT()

◆ BookHistograms()

◆ calculateMomentum()

◆ Clear()

◆ doIPSelection()

◆ doIsoSelection()

◆ doMCPSelection()

◆ EvalCharge()

◆ EvalDiMuInvMass()

◆ EvalEta()

◆ EvalEtaDiff()

◆ EvalFourMuInvMass()

◆ EvalInvMass() [1/2]

◆ EvalInvMass() [2/2]

◆ EvalPhi()

◆ EvalPhiDiff()

◆ EvalPt()

◆ EvalPtDiff()

◆ EvalTransverseMass() [1/4]

◆ EvalTransverseMass() [2/4]

◆ EvalTransverseMass() [3/4]

◆ EvalTransverseMass() [4/4]

◆ EvaluateAngle()

◆ EventSelection()

◆ finalize()

◆ getAcceptedEvents()

◆ getCombMuon()

◆ getIDTrack()

◆ GetInvMass()

◆ getLeptonOpeningAngle()

◆ getMSTrack()

◆ getNegMuon()

◆ getNumberOfTaggedMuons()

◆ getPosMuon()

◆ getPtImbalance()

◆ getRegion()

◆ getTestedMuonCount()

◆ getZCharge()

◆ getZEta()

◆ getZMass()

◆ getZPhi()

◆ getZPt()

◆ Init()

◆ OrderMuonList()

◆ Reco()

◆ ReconstructKinematics()

◆ RecordMuon()

◆ Register()

◆ setContainer()

◆ setDebugMode()

◆ SetLeadingMuonPtCut()

◆ SetMassWindowHigh()

◆ SetMassWindowLow()

◆ SetMaxLumiBlock()

◆ SetMinLumiBlock()

◆ SetMuonPtCut()

◆ SetMuonQuality()

◆ SetMuonSelectionTool()