FourMuonEvent Class Reference

#include <FourMuonEvent.h>

Inheritance diagram for FourMuonEvent:

Collaboration diagram for FourMuonEvent:

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

Public Member Functions
	FourMuonEvent ()
virtual	~FourMuonEvent ()
	FourMuonEvent (const FourMuonEvent &)=delete
FourMuonEvent &	operator= (const FourMuonEvent &)=delete
void	Init ()
bool	Reco ()
void	doIsoSelection (bool doIso)
void	doIPSelection (bool doIPsel)
void	doMCPSelection (bool doMCP)
bool	EventPassed ()
const float &	get4MuInvMass (ZTYPE eType)
int	getAcceptedEvents ()
const xAOD::Muon *	getCombMuon (unsigned int uPart)
const xAOD::TrackParticle *	getELTrack (unsigned int uPart)
const xAOD::TrackParticle *	getIDTrack (unsigned int uPart)
double	GetInvMass ()
const xAOD::TrackParticle *	getMSTrack (unsigned int uPart)
const xAOD::TrackParticle *	getLooseIDTk (unsigned int uPart)
const float &	getLeptonOpeningAngle (ZTYPE eType)
unsigned int	getNegMuon (int eType)
unsigned int	getNumberOfTaggedMuons ()
int	GetNVertex ()
float	getPtImbalance (ZTYPE eType)
const std::string	getRegion () const
unsigned int	getPosMuon (int eType)
int	GetVertexElec (unsigned int uPart)
int	GetVertexElNeg1 ()
int	GetVertexElNeg2 ()
int	GetVertexElPos1 ()
int	GetVertexElPos2 ()
int	GetVertexMuNeg1 ()
int	GetVertexMuNeg2 ()
int	GetVertexMuPos1 ()
int	GetVertexMuPos2 ()
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	setContainer (PerfMonServices::CONTAINERS container)
void	setDebugMode (bool debug)
void	SetLeadingMuonPtCut (double newvalue)
void	SetMassWindowLow (double newvalue)
void	SetMassWindowHigh (double newvalue)
void	SetMuonPtCut (double newvalue)
void	SetMuonSelectionTool (const ToolHandle< CP::IMuonSelectionTool > &mst)
void	SetSecondMuonPtCut (double newvalue)
void	SetOpeningAngleCut (double newvalue)
void	SetZ0GapCut (double newvalue)

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
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
using	Arrayf = std::array<float, NUM_TYPES>

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

Private Attributes
MsgStream *	m_msgStream {}
MuonSelector	m_xMuonID
ElectronSelector	m_xElecID
PerfMonServices::CONTAINERS	m_container
unsigned int	m_uMuonTags {}
double	m_FourMuonInvMass {}
double	m_LeadingMuonPtCut {}
double	m_SecondMuonPtCut {}
double	m_MassWindowLow {}
double	m_MassWindowHigh {}
double	m_OpeningAngleCut {}
double	m_deltaXYcut {}
double	m_Z0GapCut {}
bool	m_doDebug {}
bool	m_workAsFourMuons {}
bool	m_workAsFourElectrons {}
bool	m_workAsFourLeptons {}
unsigned int	m_numberOfFullPassMuons {}
unsigned int	m_numberOfFullPassElectrons {}
bool	m_passedSelectionCuts = false
bool	m_passedFourMuonSelection = false
bool	m_passedFourElectronSelection = false
bool	m_passedFourLeptonSelection = false
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] {}
const xAOD::TrackParticle *	m_pxELTrack [NUM_MUONS] {}
const xAOD::TrackParticle *	m_pxMUTrack [NUM_MUONS] {}
Arrayf	m_fZPt {}
Arrayf	m_fZEtaDir {}
Arrayf	m_fZPhiDir {}
Arrayf	m_fInvariantMass {}
Arrayf	m_fMuonDispersion {}
bool	m_SelectMuonByIso {}
bool	m_SelectMuonByIP {}
int	m_eventCount {}
int	m_acceptedEventCount {}
int	m_acceptedMuonCount {}
int	m_acceptedElecCount {}
int	m_muon1 = 0
int	m_muon2 = 0
int	m_muonpos1 = 0
int	m_muonpos2 = 0
int	m_muonneg1 = 0
int	m_muonneg2 = 0
int	m_nVertex = 0
int	m_muonneg1_vtx = 0
int	m_muonneg2_vtx = 0
int	m_muonpos1_vtx = 0
int	m_muonpos2_vtx = 0
int	m_muon_vtx [NUM_MUONS] {}
int	m_elec_vtx [NUM_MUONS] {}

Detailed Description

Definition at line 35 of file FourMuonEvent.h.

Member Typedef Documentation

Arrayf

using FourMuonEvent::Arrayf = std::array<float, NUM_TYPES>

private

Definition at line 178 of file FourMuonEvent.h.

PARENT

typedef EventAnalysis FourMuonEvent::PARENT

private

Definition at line 124 of file FourMuonEvent.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
CENTRAL
FORWARD
BACKWARD
UNDEF

Definition at line 53 of file FourMuonEvent.h.

  {
    CENTRAL,
    FORWARD,
    BACKWARD,
    UNDEF
  };

anonymous enum

anonymous enum

Enumerator
MUON1
MUON2
MUON3
MUON4
NUM_MUONS

Definition at line 44 of file FourMuonEvent.h.

  {
    MUON1,
    MUON2,
    MUON3,
    MUON4,
    NUM_MUONS
  };

HISTOS_1D

enum FourMuonEvent::HISTOS_1D

private

Enumerator
ZMASS_MUON
ZMASS_MUONADJ
ZMASS_TRACK
ZMASS_COMB
NUM_1HISTOS

Definition at line 186 of file FourMuonEvent.h.

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

ZTYPE

enum FourMuonEvent::ZTYPE

Enumerator
MS
ME
ID
CB
NUM_TYPES

Definition at line 61 of file FourMuonEvent.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

FourMuonEvent() [1/2]

FourMuonEvent::FourMuonEvent

(

)

Definition at line 25 of file FourMuonEvent.cxx.

{
  m_xSampleName = "FourMuon";
 
  m_container = PerfMonServices::MUON_COLLECTION; //PerfMonServices::ELECTRON_COLLECTION
 
  m_doDebug = false;
  m_workAsFourMuons = false;
  m_workAsFourElectrons = false;
  m_workAsFourLeptons = true;
 
  // Setup the muon tags
  m_uMuonTags   = 4;
  m_LeadingMuonPtCut = 20.;   
  m_SecondMuonPtCut = 15.;
  m_MassWindowLow = 10.0;
  m_MassWindowHigh = 125.0;
  m_deltaXYcut = 0.1; // in mm
  m_Z0GapCut = 5.0; // in mm
  m_SelectMuonByIso = true;
  m_SelectMuonByIP = true;
  m_eventCount = 0;
  m_acceptedEventCount = 0;
  m_acceptedMuonCount = 0;
  m_acceptedElecCount = 0;
 
  m_msgStream =  new MsgStream(Athena::getMessageSvc(), "InDetPerformanceMonitoring" );
}

~FourMuonEvent()

FourMuonEvent::~FourMuonEvent ( )

virtual

Definition at line 55 of file FourMuonEvent.cxx.

{
  delete m_msgStream;
}

FourMuonEvent() [2/2]

FourMuonEvent::FourMuonEvent ( const FourMuonEvent & )

delete

Member Function Documentation

BookHistograms()

void FourMuonEvent::BookHistograms ( )

protectedvirtual

Reimplemented from EventAnalysis.

Definition at line 251 of file FourMuonEvent.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);
}

CheckMuonVertices()

bool FourMuonEvent::CheckMuonVertices ( )

private

Definition at line 1187 of file FourMuonEvent.cxx.

{
  (*m_msgStream) << MSG::DEBUG << " * FourMuonsEvents::CheckMuonVertices * -- START --" << endmsg; 
 
  bool goodvertices = false; 
  goodvertices = true; // R22 set true by default. Needs to be revisited
  int nverticesfound = 0; 
  
  // loop on mu-, and for each mu-, loop on mu+ and check at least one mu+ and mu- come from the same vertex
  // mu- indices are 0 or 1
  for (unsigned int imuneg = 0; imuneg <= 1; imuneg++) {
    if (m_pxMUTrack[imuneg] != nullptr) {
      /* R21 SALVA --> vertex is not available in R22 --> A FIX IS NEEDED */
      /*
      if (m_pxMUTrack[imuneg]->vertex()) {
    
    if (m_doDebug) std::cout << "     mu-(" << imuneg <<")->vertex()->v= (" << m_pxMUTrack[imuneg]->vertex()->x()
                 << ", " << m_pxMUTrack[imuneg]->vertex()->y()
                 << ", " << m_pxMUTrack[imuneg]->vertex()->z()
                 << ") " << std::endl;
    
    for (unsigned int imupos = 2; imupos <= 3; imupos++) { // mu+ indices are 2 and 3
      if (m_pxMUTrack[imupos] != nullptr) {
        if (m_pxMUTrack[imupos]->vertex()) {
          if (m_doDebug) std::cout << "     mu+(" << imupos <<")->vertex()->v= (" << m_pxMUTrack[imupos]->vertex()->x()
                       << ", " << m_pxMUTrack[imupos]->vertex()->y()
                       << ", " << m_pxMUTrack[imupos]->vertex()->z()
                       << ") " << std::endl;
          
          float delta_x = fabs( m_pxMUTrack[imuneg]->vertex()->x() - m_pxMUTrack[imupos]->vertex()->x());
          float delta_y = fabs( m_pxMUTrack[imuneg]->vertex()->y() - m_pxMUTrack[imupos]->vertex()->y());
          float delta_z = fabs( m_pxMUTrack[imuneg]->vertex()->z() - m_pxMUTrack[imupos]->vertex()->z());
 
          if (delta_x < m_deltaXYcut && delta_y < m_deltaXYcut && delta_z < m_Z0GapCut) {
        nverticesfound++;
        if (m_doDebug) std::cout << "     MUON-BINGO !!! mu+mu- pair in same vertex !!! mu-[" << imuneg 
                     << "]  mu+[" << imupos<< "]   count: " << nverticesfound << std::endl;
          } // vertex is the same
        } // mu+ has vertex
      } // mu+ exists
    } // loop on mu+
      } // mu- has vertex
      */
    } // mu- exists
  } // loop on mu- 
 
  if (nverticesfound >= 1) goodvertices = true;
  
  if (nverticesfound == 0) if (m_doDebug) std::cout << " -- FourMuonEvent::CheckMuonVertices -- WARNING -- MUONS DO NOT COME FROM SAME VERTEX " << std::endl; 
 
  (*m_msgStream) << MSG::DEBUG << " * FourMuonsEvents::CheckMuonVertices * -- COMPLETED -- status: " << goodvertices << endmsg; 
  return goodvertices;
}

Clear()

void FourMuonEvent::Clear ( )

private

Definition at line 593 of file FourMuonEvent.cxx.

{
  m_numberOfFullPassMuons = 0;
  m_numberOfFullPassElectrons = 0;
  m_passedSelectionCuts   = false;
  m_passedFourMuonSelection = false;
  m_passedFourElectronSelection = false;
  m_passedFourLeptonSelection = false;
 
 
  m_FourMuonInvMass = -1.; // flag as no reconstructed inv mass yet
  m_muon1 = MUON1; // point to the first two
  m_muon2 = MUON2;
  m_muonneg1 = -1;
  m_muonneg2 = -1;
  m_muonpos1 = -1;
  m_muonpos2 = -1;
 
 
  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;
      m_pxMUTrack[u] = nullptr;
      m_pxELTrack[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;
  }
 
  // tell us to which vertex the muons are associated 
  m_nVertex = 0; // reset vertex count
  m_muonneg1_vtx = 0;
  m_muonneg2_vtx = 0;
  m_muonpos1_vtx = 0;
  m_muonpos2_vtx = 0;
 
  for (size_t i=0; i < NUM_MUONS; i++) m_muon_vtx[i] = 0; // reset the vertex ID to which the electrons are associated
  for (size_t i=0; i < NUM_MUONS; i++) m_elec_vtx[i] = 0; // reset the vertex ID to which the electrons are associated
  return;
}

doIPSelection()

void FourMuonEvent::doIPSelection ( bool doIPsel )

inline

Definition at line 75 of file FourMuonEvent.h.

{ m_xMuonID.doIPSelection(doIPsel); }

doIsoSelection()

void FourMuonEvent::doIsoSelection ( bool doIso )

inline

Definition at line 74 of file FourMuonEvent.h.

{ m_xMuonID.doIsoSelection(doIso); }

doMCPSelection()

void FourMuonEvent::doMCPSelection ( bool doMCP )

inline

Definition at line 76 of file FourMuonEvent.h.

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

EventPassed()

bool FourMuonEvent::EventPassed ( )

inline

Definition at line 77 of file FourMuonEvent.h.

{ return m_passedSelectionCuts; }

EventSelection()

bool FourMuonEvent::EventSelection ( ZTYPE eType )

private

Definition at line 458 of file FourMuonEvent.cxx.

{
  if(m_doDebug){  std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") ** started ** " << std::endl 
                << "                                            event count: " << m_eventCount  << std::endl
                << "                                m_NumberOfFullPassMuons: " << m_numberOfFullPassMuons << std::endl
                << "                            m_NumberOfFullPassElectrons: " << m_numberOfFullPassElectrons 
                << std::endl;
  }
 
  // First require two muon-id's with cuts pre-applied.
  if ( (m_numberOfFullPassMuons + m_numberOfFullPassElectrons) < 4 ) {
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing number of good muons and electrons == 4 :( " 
                 << m_numberOfFullPassMuons + m_numberOfFullPassElectrons 
                 << " = " << m_numberOfFullPassMuons << " + " << m_numberOfFullPassElectrons << std::endl;}
    return false;
  }
  
  if ( m_numberOfFullPassMuons > 4 ) {
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Too many muons !! Failing number of good muons == 4 :( " 
                 <<  m_numberOfFullPassMuons << std::endl;}
    return false;
  }
 
  if ( m_numberOfFullPassElectrons > 4 ) {
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Too many electrons !! Failing number of good electrons == 4 :( " 
                 <<  m_numberOfFullPassElectrons << std::endl;}
    return false;
  }
  
  // momentum of the muons
  double leadingMuonPt = -1., secondMuonPt=-1., thirdMuonPt=-1, fourthMuonPt=-1.; // negative pt, means not computed yet
  switch ( eType ) {
  case MS :
    {
      if (m_muonpos1 >= 0) leadingMuonPt = m_pxMSTrack[m_muonpos1]->pt();
      if (m_muonpos2 >= 0) secondMuonPt =  m_pxMSTrack[m_muonpos2]->pt();
      if (m_muonneg1 >= 0) thirdMuonPt =   m_pxMSTrack[m_muonneg1]->pt();
      if (m_muonneg2 >= 0) fourthMuonPt =  m_pxMSTrack[m_muonneg2]->pt();
      break;
    }
  case ME:
    {
      if (m_muonpos1 >= 0) leadingMuonPt = m_pxMETrack[m_muonpos1]->pt();
      if (m_muonpos2 >= 0) secondMuonPt =  m_pxMETrack[m_muonpos2]->pt();
      if (m_muonneg1 >= 0) thirdMuonPt =   m_pxMETrack[m_muonneg1]->pt();
      if (m_muonneg2 >= 0) fourthMuonPt =  m_pxMETrack[m_muonneg2]->pt();
      break;
    }
  case CB:
    {
      if (m_muonpos1 >= 0) leadingMuonPt = m_pxRecMuon[m_muonpos1]->pt();
      if (m_muonpos2 >= 0) secondMuonPt =  m_pxRecMuon[m_muonpos2]->pt();
      if (m_muonneg1 >= 0) thirdMuonPt =   m_pxRecMuon[m_muonneg1]->pt();
      if (m_muonneg2 >= 0) fourthMuonPt =  m_pxRecMuon[m_muonneg2]->pt();
      break;
    }
  case ID:
    {
      if (m_muonpos1 >= 0) leadingMuonPt = m_pxIDTrack[m_muonpos1]->pt();
      if (m_muonpos2 >= 0) secondMuonPt =  m_pxIDTrack[m_muonpos2]->pt();
      if (m_muonneg1 >= 0) thirdMuonPt =   m_pxIDTrack[m_muonneg1]->pt();
      if (m_muonneg2 >= 0) fourthMuonPt =  m_pxIDTrack[m_muonneg2]->pt();
      break;
    }
    
  default:
    if (m_muonpos1 >= 0) leadingMuonPt = m_pxIDTrack[m_muonpos1]->pt();
    if (m_muonpos2 >= 0) secondMuonPt =  m_pxIDTrack[m_muonpos2]->pt();
    if (m_muonneg1 >= 0) thirdMuonPt =   m_pxIDTrack[m_muonneg1]->pt();
    if (m_muonneg2 >= 0) fourthMuonPt =  m_pxIDTrack[m_muonneg2]->pt();
  } // end switch
 
  // up to here the leading and second pt are not really in the right order.
  // order the muon pt:
  double theLeadingPt = leadingMuonPt;
  if (secondMuonPt > theLeadingPt) { theLeadingPt = secondMuonPt;}
  if (thirdMuonPt  > theLeadingPt) { theLeadingPt = thirdMuonPt;}
  if (fourthMuonPt > theLeadingPt) { theLeadingPt = fourthMuonPt;}
 
  double theTrailingPt = leadingMuonPt;
  if (secondMuonPt < theTrailingPt && secondMuonPt > 0) { theTrailingPt = secondMuonPt;}
  if (thirdMuonPt  < theTrailingPt && thirdMuonPt > 0)  { theTrailingPt = thirdMuonPt;}
  if (fourthMuonPt < theTrailingPt && fourthMuonPt > 0) { theTrailingPt = fourthMuonPt;}
  
  if (m_doDebug || true) {
    std::cout << " * FourMuonEvent::EventSelection * muon pt selection -- cuts: Leading: " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl
          << "                                                                  2nd: " << m_SecondMuonPtCut*CLHEP::GeV << std::endl;
    std::cout << "                                          Pt of muons in this event 1: " << leadingMuonPt << std::endl
          << "                                                                    2: " << secondMuonPt << std::endl
          << "                                                                    3: " << thirdMuonPt << std::endl
          << "                                                                    4: " << fourthMuonPt << std::endl
          << "                                                           leading Pt: " << theLeadingPt << std::endl
          << "                                                          trailing Pt: " << theTrailingPt << std::endl;
  }
  
  // muon pt cut
  if ( !(theLeadingPt > m_LeadingMuonPtCut*CLHEP::GeV && theTrailingPt >  m_SecondMuonPtCut*CLHEP::GeV ) ) {
    if(m_doDebug){  
      std::cout <<" * FourMuonEvent::EventSelection * Failing pt cut * Reco Pt:  leading " << theLeadingPt << "  --> trailing  " << theTrailingPt << std::endl;
    }
    return false;
  }
  if(m_doDebug){
    std::cout << " * FourMuonEvent::EventSelection * Event passed the pt cuts: leading muon pt: " << leadingMuonPt << std::endl;
    std::cout << "                                                            trailing muon pt: " << theTrailingPt << std::endl; 
  }
  
 
  // Invariant mass window
  if ( m_fInvariantMass[eType]  < m_MassWindowLow  ) {
    if(m_doDebug) {
      std::cout <<" * FourMuonEvent::EventSelection * 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 <<" * FourMuonEvent * Failing mass window high cut:  reco m= " << m_fInvariantMass[eType] << " > " <<  m_MassWindowHigh << std::endl;
    }
    return false;
  }
  if(m_doDebug){
    std::cout <<" * FourMuonEvent::EventSelection * Event passed the mass window: " << m_fInvariantMass[eType] << std::endl;
  }
  
  if(m_doDebug) {
    std::cout << " * FourMuonEvent::EventSelection( type= " << eType << ")*  Good 4-muon set: pt range from  " <<  leadingMuonPt/1000 
          << " to " << secondMuonPt/1000 
          << " GeV   4-muon invariant mass = " << m_fInvariantMass.at(eType) << " GeV \n";
    std::cout << " * FourMuonEvent::EventSelection( type= " << eType << ")*  completed * \n";
  }
  return true;
}

EventSelectionNew()

bool FourMuonEvent::EventSelectionNew ( ZTYPE eType )

private

Definition at line 258 of file FourMuonEvent.cxx.

{
  bool inputdebug = m_doDebug;
  //m_doDebug = true;
 
  bool eventisgood = true;
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::EventSelection( type= " << eType << ") ** started ** " << std::endl 
         << "                                          event count: " << m_eventCount  << std::endl
         << "                              m_NumberOfFullPassMuons: " << m_numberOfFullPassMuons << std::endl
         << "                          m_NumberOfFullPassElectrons: " << m_numberOfFullPassElectrons 
         << endmsg;
  
  
  // Depending on mode: require a minimum of electrons or muons
  if ( eventisgood && m_workAsFourMuons) {
    if (m_numberOfFullPassMuons < 4) {
      eventisgood = false;
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing number of good muons == 4 :( " 
                   <<"  m_numberOfFullPassMuons= " <<  m_numberOfFullPassMuons << std::endl;
      }
    } 
  }
  
  if ( eventisgood && m_workAsFourElectrons) {
    if (m_numberOfFullPassElectrons < 4) {
      eventisgood = false;
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing number of good electrons == 4 :( " 
                   <<"  m_numberOfFullPassElectrons= " <<  m_numberOfFullPassElectrons << std::endl;
      }
    } 
  }
  
  if ( eventisgood && m_workAsFourLeptons) {
    bool thisselection = false;
    if (m_numberOfFullPassMuons     == 4) thisselection = true;
    if (m_numberOfFullPassElectrons == 4) thisselection = true;
    if (m_numberOfFullPassMuons >= 2 && m_numberOfFullPassElectrons >= 2) thisselection = true;
    if (!thisselection) {
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing number of good muons >= 2 && electrons >= 2 :( " 
                   <<"  m_numberOfFullPassMuons= " <<  m_numberOfFullPassMuons
                   <<"  m_numberOfFullPassElectrons= " <<  m_numberOfFullPassElectrons << std::endl;
      }
    }
    eventisgood = thisselection;
  } 
 
  //
  // momentum of the leptons 
  // loop over the muons and electrons and count how many pass the leadingPt and secondPt cut
  unsigned int npassleadingpt = 0;
  unsigned int npasssecondpt = 0; 
  if ( eventisgood && (m_workAsFourMuons || m_workAsFourLeptons) ) {
    if (m_numberOfFullPassMuons >= 2) { // electrons pt cuts if there are some electrons
      //for (unsigned int i=0; i < m_numberOfFullPassMuons; i++) {
      for (unsigned int i=0; i < NUM_MUONS; i++) {
    if (m_pxIDTrack[i] == nullptr) continue;
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * using muon " << i << " with pt: " << m_pxIDTrack[i]->pt() <<  std::endl;}
    if (m_pxIDTrack[i]->pt() > m_LeadingMuonPtCut*CLHEP::GeV) npassleadingpt++;
    if (m_pxIDTrack[i]->pt() > m_SecondMuonPtCut*CLHEP::GeV) npasssecondpt++;
      }
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * #muons with pt > leading pt: " << m_LeadingMuonPtCut*CLHEP::GeV << " = " << npassleadingpt << std::endl;}
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * #muons with pt > second  pt: " << m_SecondMuonPtCut*CLHEP::GeV << " = " << npasssecondpt << std::endl;}
      if (npassleadingpt == 0) { // at least 1 muon must pass the leading pt cut
    eventisgood = false;
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing leading muon pt cut " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl;}
      }
      if (npasssecondpt < m_numberOfFullPassMuons) { // all muons must pass the second pt cut
    eventisgood = false;
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing second muon pt cut " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl;}
      }
    }
  } 
 
  // four electrons case
  if ( eventisgood && (m_workAsFourElectrons || m_workAsFourLeptons) ) {
    npassleadingpt = 0;
    npasssecondpt = 0;
    if (m_numberOfFullPassElectrons >= 2) { // electrons pt cuts if there are some electrons
      for (unsigned int i=0; i < NUM_MUONS; i++) {
    if (m_pxELTrack[i] == nullptr) continue;
    if (m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * using electron " << i << " with pt: " << m_pxELTrack[i]->pt() << std::endl;}
    if (m_pxELTrack[i]->pt() > m_LeadingMuonPtCut*CLHEP::GeV) npassleadingpt++;
    if (m_pxELTrack[i]->pt() > m_SecondMuonPtCut*CLHEP::GeV) npasssecondpt++;
      }
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * #elecs with pt > leading pt: " << m_LeadingMuonPtCut*CLHEP::GeV << " = " << npassleadingpt << std::endl;}
      if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * #elecs with pt > second  pt: " << m_SecondMuonPtCut*CLHEP::GeV << " = " << npasssecondpt << std::endl;}
      if (npassleadingpt == 0) { // at least 1 electron must pass the leading pt cut
    eventisgood = false;
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing leading electron pt cut " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl;}
      }
      if (npasssecondpt < m_numberOfFullPassElectrons) { // all electrons must pass the second pt cut
    eventisgood = false;
    if(m_doDebug) {std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") * Failing second electrons pt cut " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl;}
      }
    } // electron pt cuts apply if there are some electrons
  }
 
  // Invariant mass window
  if (eventisgood) {
    if ( m_fInvariantMass[eType]  < m_MassWindowLow  ) {
      if(m_doDebug) {
    std::cout <<" * FourMuonEvent::EventSelection * Failing mass window low cut:  reco m= " << m_fInvariantMass[eType] << " > " <<  m_MassWindowLow << std::endl;
      }
      eventisgood = false;
    }
    if ( m_fInvariantMass[eType]  > m_MassWindowHigh ) {
      if(m_doDebug) {
    std::cout <<" * FourMuonEvent::EventSelection * Failing mass window high cut:  reco m= " << m_fInvariantMass[eType] << " > " <<  m_MassWindowHigh << std::endl;
      }
      eventisgood = false;
    }
  }
 
  // check on vertices 
  if (eventisgood) {
    bool vertexstatus = false;
 
    std::vector <float> vtxListX; // coordinates of the vertex
    std::vector <float> vtxListY;
    std::vector <float> vtxListZ;
    std::vector <int>   vtxNpart; // count how many particles are in vertex
 
    int noVertexCountMuon = 0;
    int noVertexCountElec = 0;
    //
    if ( m_workAsFourMuons ) { // till here we have the muon vertices list
      m_nVertex = vtxListX.size(); 
      if (vtxListX.size()>0) vertexstatus = true;
      // check that the muons are not split into too many vertices
      if (vtxListX.size() >= m_numberOfFullPassMuons - 1) vertexstatus = false;
      // allow no muon without vertex
      if (noVertexCountMuon > 0) vertexstatus = false;
      if (m_doDebug || true) {
    std::cout << " * FourMuonEvent::EventSelection(" << eType <<") * vertices ID of the muons = " << std::endl
          << "                   mu- 1 " << m_muon_vtx[0] << "  pt: " << m_pxMUTrack[0]->pt() << std::endl
          << "                   mu- 2 " << m_muon_vtx[1] << "  pt: " << m_pxMUTrack[1]->pt() << std::endl
          << "                   mu+ 1 " << m_muon_vtx[2] << "  pt: " << m_pxMUTrack[2]->pt() << std::endl
          << "                   mu+ 2 " << m_muon_vtx[3] << "  pt: " << m_pxMUTrack[3]->pt()
          << std::endl;
      } // end debug      
    } // end m_workAsFourMuons
 
    if ( m_workAsFourElectrons ) { // till here we have the electrons vertices list
      m_nVertex = vtxListX.size(); 
      if (vtxListX.size()>0) vertexstatus = true;
      // check that the electrons are not split into too many vertices
      if (vtxListX.size() >= m_numberOfFullPassElectrons - 1) vertexstatus = false;
      
    std::cout << " * FourMuonEvent::EventSelection(" << eType <<") * vertices ID of the electrons = " 
          << "\n                   el- 1 " << m_elec_vtx[0] << "  pt: " << m_pxELTrack[0]->pt() << std::endl
          << "\n                   el- 2 " << m_elec_vtx[1] << "  pt: " << m_pxELTrack[1]->pt() << std::endl
          << "\n                   el+ 1 " << m_elec_vtx[2] << "  pt: " << m_pxELTrack[2]->pt() << std::endl
          << "\n                   el+ 2 " << m_elec_vtx[3] << "  pt: " << m_pxELTrack[3]->pt() <<"\n";
    }
    
    if ( m_workAsFourLeptons ) { // till here we have the muons and electrons vertices list
      m_nVertex = vtxListX.size(); 
      if (vtxListX.size()>0) vertexstatus = true;
      // check that the electrons are not split into too many vertices
      // if (vtxListX.size() >= m_numberOfFullPassElectrons - 1) vertexstatus = false;
      // and allow no electron without vertex
      if (m_doDebug) {
    std::cout << " * FourMuonEvent::EventSelection(" << eType <<") * vertices in event = " << vtxListX.size() << std::endl;
    for (size_t imu=0; imu < NUM_MUONS; imu++) {
      if (m_pxMUTrack[imu]) std::cout << "                   mu    " << m_muon_vtx[imu] << "  pt: " << m_pxMUTrack[imu]->pt() << std::endl;
    }
    for (size_t iel=0; iel < NUM_MUONS; iel++) {
      if (m_pxELTrack[iel]) std::cout << "                   el    " << m_elec_vtx[iel] << "  pt: " << m_pxELTrack[iel]->pt() << std::endl;
    }
      }
    }
      
    vertexstatus = true; // Temporary fix to work on R22
 
    if(m_doDebug) {
      std::cout <<" * FourMuonEvent::EventSelection(" << eType <<")  * Number of vertex found = " << vtxListX.size() 
        << "  and mu without vertex: " << noVertexCountMuon 
        << "  and elec without vertex: " << noVertexCountElec << std::endl;
      for (unsigned int ivtx=0; ivtx < vtxListX.size(); ivtx++) {
    std::cout << "       vtx[" << ivtx << "]= "
          << "( " << vtxListX.at(ivtx)
          << ", " << vtxListY.at(ivtx)
          << ", " << vtxListZ.at(ivtx)
          << ")  nparticles: " << vtxNpart.at(ivtx)
          << std::endl;
      }
    }
    
 
    eventisgood = vertexstatus;
  }
 
  //
  if(m_doDebug){  std::cout <<" * FourMuonEvent::EventSelection(" << eType << ") ** completed ** result= " << eventisgood << std::endl;}
 
  m_doDebug = inputdebug;
 
  return eventisgood;
}

get4MuInvMass()

const float & FourMuonEvent::get4MuInvMass ( ZTYPE eType )

inline

Definition at line 78 of file FourMuonEvent.h.

{ return m_fInvariantMass[eType];  } 

getAcceptedEvents()

int FourMuonEvent::getAcceptedEvents ( )

inline

Definition at line 79 of file FourMuonEvent.h.

{ return m_acceptedEventCount; }      

getCombMuon()

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

inline

Definition at line 80 of file FourMuonEvent.h.

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

getELTrack()

const xAOD::TrackParticle * FourMuonEvent::getELTrack ( unsigned int uPart )

inline

Definition at line 81 of file FourMuonEvent.h.

{ return (uPart < NUM_MUONS) ? m_pxELTrack[uPart] : nullptr;  }

getIDTrack()

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

inline

Definition at line 82 of file FourMuonEvent.h.

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

GetInvMass()

double FourMuonEvent::GetInvMass ( )

inline

Definition at line 83 of file FourMuonEvent.h.

{ return m_FourMuonInvMass; }

getLeptonOpeningAngle()

const float & FourMuonEvent::getLeptonOpeningAngle ( ZTYPE eType )

inline

Definition at line 86 of file FourMuonEvent.h.

{ return m_fMuonDispersion[eType]; }

getLooseIDTk()

const xAOD::TrackParticle * FourMuonEvent::getLooseIDTk ( unsigned int uPart )

inline

Definition at line 1003 of file FourMuonEvent.cxx.

{
  const xAOD::TrackParticleContainer*  pxTrackContainer =
    PerfMonServices::getContainer<xAOD::TrackParticleContainer>( PerfMonServices::TRK_COLLECTION );
 
  if ( pxTrackContainer )
    {
      xAOD::TrackParticleContainer::const_iterator xTrkItr  = pxTrackContainer->begin();
      xAOD::TrackParticleContainer::const_iterator xTrkItrE  = pxTrackContainer->end();
      while ( xTrkItr != xTrkItrE )
    {
      const xAOD::TrackParticle* pxTrack = *xTrkItr;
      if ( !pxTrack ) continue;
      const Trk::Track* pxTrkTrack = pxTrack->track();
      if(!pxTrkTrack) continue;
      const Trk::Perigee* pxPerigee = pxTrkTrack->perigeeParameters() ;
      if ( !pxPerigee ) continue;
      const float fTrkPhi   = pxPerigee->parameters()[Trk::phi];
      const float fTrkEta   = pxPerigee->eta();
 
      float fDPhi = fabs( fTrkPhi -  m_pxMETrack[m_muon1]->phi() );
      float fDEta = fabs( fTrkEta -  m_pxMETrack[m_muon2]->eta() );
      float fDR = sqrt( fDPhi*fDPhi + fDEta*fDEta );
 
      if ( fDR < 0.3f )
        {
          return pxTrack;
        }
 
      ++xTrkItr;
    }
    }
  // if ()
  return nullptr;
}

getMSTrack()

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

inline

Definition at line 84 of file FourMuonEvent.h.

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

getNegMuon()

unsigned int FourMuonEvent::getNegMuon

(

int

eType

)

Definition at line 995 of file FourMuonEvent.cxx.

{
  unsigned int muid = m_muonneg1;
  if (eType==2) muid = m_muonneg2;
  return muid;
}

getNumberOfTaggedMuons()

unsigned int FourMuonEvent::getNumberOfTaggedMuons ( )

inline

Definition at line 88 of file FourMuonEvent.h.

{ return m_numberOfFullPassMuons; }

GetNVertex()

int FourMuonEvent::GetNVertex ( )

inline

Definition at line 89 of file FourMuonEvent.h.

{ return m_nVertex; }

getPosMuon()

unsigned int FourMuonEvent::getPosMuon

(

int

eType

)

Definition at line 984 of file FourMuonEvent.cxx.

{
  //if ( getNumberOfTaggedMuons() != 2 ) return 999;
  //if ( getZCharge(eType) != 0        ) return 999;
 
  unsigned int muid = m_muonpos1;
  if (eType==2) muid = m_muonpos2;
  return muid;
}

getPtImbalance()

float FourMuonEvent::getPtImbalance

(

ZTYPE

eType

)

Definition at line 924 of file FourMuonEvent.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 FourMuonEvent::getRegion

(

)

const

GetVertexElec()

int FourMuonEvent::GetVertexElec ( unsigned int uPart )

inline

Definition at line 93 of file FourMuonEvent.h.

{ return (uPart < NUM_MUONS) ? m_elec_vtx[uPart] : 0;}

GetVertexElNeg1()

int FourMuonEvent::GetVertexElNeg1 ( )

inline

Definition at line 94 of file FourMuonEvent.h.

{ return m_elec_vtx[0];}

GetVertexElNeg2()

int FourMuonEvent::GetVertexElNeg2 ( )

inline

Definition at line 95 of file FourMuonEvent.h.

{ return m_elec_vtx[1];}

GetVertexElPos1()

int FourMuonEvent::GetVertexElPos1 ( )

inline

Definition at line 96 of file FourMuonEvent.h.

{ return m_elec_vtx[2];}

GetVertexElPos2()

int FourMuonEvent::GetVertexElPos2 ( )

inline

Definition at line 97 of file FourMuonEvent.h.

{ return m_elec_vtx[3];}

GetVertexMuNeg1()

int FourMuonEvent::GetVertexMuNeg1 ( )

inline

Definition at line 98 of file FourMuonEvent.h.

{ return m_muon_vtx[0];} 

GetVertexMuNeg2()

int FourMuonEvent::GetVertexMuNeg2 ( )

inline

Definition at line 99 of file FourMuonEvent.h.

{ return m_muon_vtx[1];} 

GetVertexMuPos1()

int FourMuonEvent::GetVertexMuPos1 ( )

inline

Definition at line 100 of file FourMuonEvent.h.

{ return m_muon_vtx[2];} 

GetVertexMuPos2()

int FourMuonEvent::GetVertexMuPos2 ( )

inline

Definition at line 101 of file FourMuonEvent.h.

{ return m_muon_vtx[3];} 

getZCharge()

int FourMuonEvent::getZCharge

(

ZTYPE

eType

)

Definition at line 958 of file FourMuonEvent.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 & FourMuonEvent::getZEta ( ZTYPE eType )

inline

Definition at line 103 of file FourMuonEvent.h.

{ return m_fZEtaDir[eType];      }

getZMass()

const float & FourMuonEvent::getZMass ( ZTYPE eType )

inline

Definition at line 104 of file FourMuonEvent.h.

{ return m_fInvariantMass[eType];}

getZPhi()

const float & FourMuonEvent::getZPhi ( ZTYPE eType )

inline

Definition at line 105 of file FourMuonEvent.h.

{ return m_fZPhiDir[eType];      }

getZPt()

const float & FourMuonEvent::getZPt ( ZTYPE eType )

inline

Definition at line 106 of file FourMuonEvent.h.

{ return m_fZPt[eType];          }

Init()

void FourMuonEvent::Init ( )

virtual

Reimplemented from EventAnalysis.

Definition at line 61 of file FourMuonEvent.cxx.

{
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Init * START *" << endmsg;
  
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Init * initializing muon selector *" << endmsg; 
  m_xMuonID.Init();
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Init * initializing electron selector *" << endmsg; 
  m_xElecID.Init();
 
  if (m_workAsFourMuons)     {(*m_msgStream) << MSG::INFO << " * FourMuonEvent::Init * working mode: 4 muons"     << endmsg; }
  if (m_workAsFourElectrons) {(*m_msgStream) << MSG::INFO << " * FourMuonEvent::Init * working mode: 4 electrons" << endmsg; }
  if (m_workAsFourLeptons)   {(*m_msgStream) << MSG::INFO << " * FourMuonEvent::Init * working mode: 4 leptons"   << endmsg; }
 
  PARENT::Init();
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Init * Completed * " << endmsg; 
 
  return;
}

operator=()

FourMuonEvent & FourMuonEvent::operator= ( const FourMuonEvent & )

delete

OrderMuonList()

void FourMuonEvent::OrderMuonList

(

)

Definition at line 1083 of file FourMuonEvent.cxx.

{
  // Salva: 20/January/2020 RecMuon -> IDTrack
  constexpr bool thisdebug = false;
 
  if (m_doDebug || thisdebug) {std::cout << " * FourMuonEvent::OrderMuonList * -- start -- " << std::endl 
                     << "                                  #muons: " << m_numberOfFullPassMuons<< std::endl;}
 
  int muPlus1Id = -9;
  int muPlus2Id = -9;
  int muMinus1Id = -9;
  int muMinus2Id = -9;
  double muPlus1Pt = 0.;
  double muPlus2Pt = 0.;
  double muMinus1Pt = 0.;
  double muMinus2Pt = 0.;
 
  int muposcount = 0;
  int munegcount = 0;
 
  int nMuonsAtEntry = m_numberOfFullPassMuons;
  m_numberOfFullPassMuons = 0; // reset the number of full pass muons
 
  if (nMuonsAtEntry >= 2) { // we need at least 2 muons
    for (int imuon=0; imuon < (int) nMuonsAtEntry; imuon++) {
      if(m_doDebug && false ){ std::cout << " * FourMuonEvent::OrderMuonList * testing imuon= " << imuon 
                     << "   with charge= " << m_pxRecMuon[imuon]->charge()
                     << "   and pt= " << m_pxRecMuon[imuon]->pt()
                     << std::endl;
      }
      if (m_pxIDTrack[imuon] != nullptr) {
    
    if (m_pxIDTrack[imuon]->charge()==1) { // positive muon
      muposcount++;
      if (m_pxIDTrack[imuon]->pt()> muPlus1Pt) {
        // store 1st in 2nd
        muPlus2Pt = muPlus1Pt;
        muPlus2Id = muPlus1Id;
        // now store the new one in 1st place
        muPlus1Pt = m_pxIDTrack[imuon]->pt();
        muPlus1Id = imuon;  
      } 
      else if (m_pxIDTrack[imuon]->pt()> muPlus2Pt) {
        // store the new one in 2nd place
        muPlus2Pt = m_pxIDTrack[imuon]->pt();
        muPlus2Id = imuon;
      }
    }
    // Negative muons
    if (m_pxIDTrack[imuon]->charge()==-1) {
      munegcount++;
      if(m_pxIDTrack[imuon]->pt()> muMinus1Pt) {
        // store 1st in 2nd
        muMinus2Pt = muMinus1Pt;
        muMinus2Id = muMinus1Id;
        muMinus1Pt = m_pxIDTrack[imuon]->pt();
        muMinus1Id = imuon;
      } 
      else if(m_pxRecMuon[imuon]->pt()> muMinus2Pt) {
        muMinus2Pt = m_pxIDTrack[imuon]->pt();
        muMinus2Id = imuon;
      }
    }
      } // muon exist
    } // for (int imuon)
  } // if (nMuonsAtEntry >= 2)
 
  // require at least one opposite charge muon pair
  if (nMuonsAtEntry >= 2 && (muposcount == 0 || munegcount == 0)) {
    if (m_doDebug) std::cout << " -- FourMuonEvent::OrderMuonList -- No opposite charge muons in the " << nMuonsAtEntry << " input muons"
                 << " #mu+ " << muposcount
                 << " #mu- " << munegcount
                 << " --> DISCARD ALL MUONS -- \n";
    muPlus1Id = -9;
    muPlus2Id = -9;
    muMinus1Id = -9;
    muMinus2Id = -9;
  }
 
 
  if (muPlus1Id>=0) {m_muonpos1 = muPlus1Id; m_numberOfFullPassMuons++;}
  if (muPlus2Id>=0) {m_muonpos2 = muPlus2Id; m_numberOfFullPassMuons++;}
  if (muMinus1Id>=0) {m_muonneg1 = muMinus1Id; m_numberOfFullPassMuons++;}
  if (muMinus2Id>=0) {m_muonneg2 = muMinus2Id; m_numberOfFullPassMuons++;}
 
  m_muon1 = m_muonpos1; // to be deleted when no more m_muon is left
  m_muon2 = m_muonneg1; // to be deleted when no more m_muon is left
 
  if ((m_doDebug || thisdebug) && m_numberOfFullPassMuons >= 2){ 
    std::cout << " * FourMuonEvent::OrderMuonList * taking " << m_numberOfFullPassMuons << "  muons from the input list of " << nMuonsAtEntry << " muons: " << std::endl;
    if (muMinus1Id >= 0) std::cout << "                                  leading mu-: " << muMinus1Id << "   Pt = " << muMinus1Pt << std::endl;
    if (muMinus2Id >= 0) std::cout << "                                  second  mu-: " << muMinus2Id << "   Pt = " << muMinus2Pt << std::endl;
    if (muPlus1Id >= 0)  std::cout << "                                  leading mu+: " << muPlus1Id  << "   Pt = " << muPlus1Pt << std::endl;
    if (muPlus2Id >= 0)  std::cout << "                                  second  mu+: " << muPlus2Id  << "   Pt = " << muPlus2Pt << std::endl;
  }
  else {
    if (m_doDebug) std::cout << " * FourMuonEvent::OrderMuonList * This event has less than 2 muons :("  << std::endl;
  }
  
  if (m_doDebug || thisdebug) std::cout << " * FourMuonEvent::OrderMuonList * completed * m_numberOfFullPassMuons= " << m_numberOfFullPassMuons << std::endl;
  return;
}

Reco()

bool FourMuonEvent::Reco

(

)

Definition at line 81 of file FourMuonEvent.cxx.

{
  m_eventCount++;
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * STARTING ** New event ** eventCount " << m_eventCount << endmsg;
  
  // Clear out the previous events record.
  this->Clear();
  
  // if muons are requested 
  if (m_workAsFourMuons || m_workAsFourLeptons) {
    (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * retrieving xAOD::MuonContainer " << m_container << " of eventCount " << m_eventCount << std::endl; 
    
    const xAOD::MuonContainer* pxMuonContainer = PerfMonServices::getContainer<xAOD::MuonContainer>( m_container );
    
    // check if muon container does exist
    if (pxMuonContainer != nullptr) { 
      (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * eventCount " << m_eventCount 
             << " track list has "<< pxMuonContainer->size() 
             << " combined muons in container " << m_container 
             << " container name: " << PerfMonServices::getContainerName ( m_container ) 
             << endmsg; 
 
      xAOD::MuonContainer::const_iterator xMuonItr  = pxMuonContainer->begin();
      xAOD::MuonContainer::const_iterator xMuonItrE  = pxMuonContainer->end();
      int theCount = 0;
      while ( xMuonItr != xMuonItrE ){ // start loop on muons
    const xAOD::Muon* pxCMuon = *xMuonItr;
    theCount++;
    // Apply muon cuts
    if ( m_xMuonID.passSelection( pxCMuon)) {
      RecordMuon( pxCMuon );
      (*m_msgStream) << MSG::DEBUG <<  " * FourMuonEvent::Reco ** muon " << theCount << " is accepted " << endmsg;
    }
    ++xMuonItr;
      } // end loop on muons
      
      // ordering of muons
      this->OrderMuonList();      
    } // end muon container exists
    if (!pxMuonContainer) {
      std::cout << " * FourMuonEvent::Reco * Can't retrieve combined muon collection (container: " << m_container <<") " << std::endl;
      return false;
    } // end muon container does not exist
  } // end requesting muons
  
  //  
  // Electron selection (in case electrons are requested)
  if (m_workAsFourElectrons || m_workAsFourLeptons) {
    // Get the electron AOD container
    const xAOD::ElectronContainer* pxElecContainer = nullptr;
    if (m_doDebug){ std::cout << " * FourMuonEvent::Reco * retrieving xAOD::ElectronContainer " << PerfMonServices::ELECTRON_COLLECTION << std::endl; }
    pxElecContainer = PerfMonServices::getContainer<xAOD::ElectronContainer>( PerfMonServices::ELECTRON_COLLECTION );
    
    //pxElecContainer = evtStore()->retrieve( pxElecContainer, "Electrons" );
    
    if (pxElecContainer != nullptr) {
      (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * retrieving xAOD::ElectronContainer SUCCESS. " 
             << " Container name: " << PerfMonServices::getContainerName (PerfMonServices::ELECTRON_COLLECTION) 
             << " size: " << pxElecContainer->size()
             << endmsg;
      if (pxElecContainer->size() > 0 ){
    m_xElecID.PrepareElectronList (pxElecContainer);
    m_numberOfFullPassElectrons = m_xElecID.GetElectronCollectionSize();
    m_acceptedElecCount += m_numberOfFullPassElectrons;
      }    
    }
    else { // no pxElecContainer
      (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * retrieving xAOD::ElectronContainer -- FAILED -- eventcount: " << m_eventCount << endmsg;
    }
  } 
  
  // reached this point one has the list of muons and electrons in this event
  
  // now check if the particles in the event make them to satisfy the event selection
  if (m_workAsFourMuons) {
    m_passedFourMuonSelection = false; // unless the event has 4 muons, assume it is not good
    
    if (m_numberOfFullPassMuons == 4) {
      m_passedFourMuonSelection = this->ReconstructKinematicsNew();
      if (m_passedFourMuonSelection) m_passedFourMuonSelection = this->CheckMuonVertices();
      if (m_passedFourMuonSelection) m_passedFourMuonSelection = this->EventSelectionNew(ID);
      
      if (m_passedFourMuonSelection) {
    m_FourMuonInvMass = m_fInvariantMass[ID]; // store invariant mass
    if (m_doDebug) std::cout << " * FourMuonEvent::Reco * === Event " << m_eventCount << " is a GOOD 4-muon event " << std::endl;
      }
      else {
    if (m_doDebug) std::cout << " * FourMuonEvent::Reco * === Event " << m_eventCount << " FAILS the 4-muon event selection " << std::endl;
      }
    }  
  } // end of workAsFourMuons
  
  if (m_workAsFourElectrons) {
    if (m_doDebug) std::cout << " * FourMuonEvent::Reco * applying 4 electron selection " << std::endl;
    m_passedFourElectronSelection = false; // unless the event has 4 muons, assume it is not good
    
    if (m_numberOfFullPassElectrons == 4) {
      m_passedFourElectronSelection = this->ReconstructKinematicsNew();
      if (m_passedFourElectronSelection) m_passedFourElectronSelection = this->EventSelectionNew(ID);
      
      if (m_passedFourElectronSelection) {
    m_FourMuonInvMass = m_fInvariantMass[ID]; // store invariant mass
    if (m_doDebug) std::cout << " * FourMuonEvent::Reco * === Event " << m_eventCount << " is a GOOD 4-electrom event " << std::endl;
      }
      else {
    if (m_doDebug) std::cout << " * FourMuonEvent::Reco * === Event " << m_eventCount << " FAILS the 4-electron event selection " << std::endl;
      }
    }
    else {
      if (m_doDebug) std::cout << " * FourMuonEvent::Reco * === Event " << m_eventCount << " is not a 4-electron event " << std::endl;
    }
  } // end of workAsFourElectrons
  
  
  if (m_workAsFourLeptons) {
    if (m_doDebug) std::cout << " * FourMuonEvent::Reco * applying 4 lepton selection " << std::endl;
    m_passedFourLeptonSelection = false;
    
    bool enoughleptons = false;
    if (m_numberOfFullPassMuons == 4) enoughleptons = true;
    if (m_numberOfFullPassElectrons == 4) enoughleptons = true;
    if (m_numberOfFullPassMuons >= 2 && m_numberOfFullPassElectrons >= 2) enoughleptons = true;
    
    if ( enoughleptons) {
      if (m_doDebug) {
    std::cout << " * FourMuonEvent::Reco * Global statistics: Total number of accepted muons so far: " << m_acceptedMuonCount 
          << "  &   electrons: " << m_acceptedElecCount  << " integrated over all events "
          << std::endl;
    std::cout << " * FourMuonEvent::Reco * This event has " << m_numberOfFullPassMuons
          << " muons & " << m_numberOfFullPassElectrons << " electrons --> try kinematics, vertex and event selection"
          << std::endl;
      }
      m_passedFourLeptonSelection = this->ReconstructKinematicsNew();
      if (m_passedFourLeptonSelection && m_numberOfFullPassMuons >= 2) m_passedFourLeptonSelection = this->CheckMuonVertices();
      if (m_passedFourLeptonSelection) m_passedFourLeptonSelection = this->EventSelectionNew(ID);
      
      if (m_passedFourLeptonSelection) {
    m_FourMuonInvMass = m_fInvariantMass[ID]; // store invariant mass
    (*m_msgStream) << MSG::INFO << " * FourMuonEvent::Reco * === Event " << m_eventCount << " is a GOOD 4-lepton event with inv mass: " << m_FourMuonInvMass << endmsg;
      }
      else {
    (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * === Event " << m_eventCount << " -- FAILS -- the 4-lepton event selection " << endmsg;
      }
    }
    else {
      (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * 4lepton selection FAILURE. Not enough muons or electrons. Event has " << m_numberOfFullPassMuons
             << " muons & " << m_numberOfFullPassElectrons << " electrons"
             << endmsg;
    }
  }
  
  m_passedSelectionCuts = false; // assume event is not good, but check the selection according to the use case
  if (m_workAsFourMuons)     m_passedSelectionCuts = m_passedFourMuonSelection;
  if (m_workAsFourElectrons) m_passedSelectionCuts = m_passedFourElectronSelection;
  if (m_workAsFourLeptons)   m_passedSelectionCuts = m_passedFourLeptonSelection;
  
  if ( m_passedSelectionCuts) m_acceptedEventCount++;
  
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent::Reco * COMPLETED *   Event has " << m_numberOfFullPassMuons << " muons & " 
         << m_numberOfFullPassElectrons << " electrons. "
         << "  So far: " << m_acceptedEventCount << " events were accepted out of " << m_eventCount << " tested" << endmsg;
 
  return m_passedSelectionCuts;
}

ReconstructKinematics()

bool FourMuonEvent::ReconstructKinematics ( )

private

Definition at line 693 of file FourMuonEvent.cxx.

{
  if(m_doDebug){ std::cout << " * FourMuonEvent * ReconstructKinematics * -- start -- " << std::endl; }
  bool kinematicscomputed = false;
 
  // Three ways. No checks here. Thus make sure the pointers are ok before this.
  if ( m_numberOfFullPassMuons == 4 ) {
    // crosscheck identifiers are good:
    bool goodidentifiers = true;
    if (m_muonneg1 < 0) goodidentifiers = false;
    if (m_muonneg2 < 0) goodidentifiers = false;
    if (m_muonpos1 < 0) goodidentifiers = false;
    if (m_muonpos2 < 0) goodidentifiers = false;
 
    if (goodidentifiers) {
      // before computing the kinematic parameters check track particles are ok
      bool goodtracks = true;
      if (m_pxIDTrack[m_muonneg1] == nullptr) goodtracks = false;
      if (m_pxIDTrack[m_muonneg2] == nullptr) goodtracks = false;
      if (m_pxIDTrack[m_muonpos1] == nullptr) goodtracks = false;
      if (m_pxIDTrack[m_muonpos2] == nullptr) goodtracks = false;
      
      if (m_pxIDTrack[m_muonneg1] != nullptr) m_pxMUTrack[0] = m_pxIDTrack[m_muonneg1]; 
      if (m_pxIDTrack[m_muonneg2] != nullptr) m_pxMUTrack[1] = m_pxIDTrack[m_muonneg2]; 
      if (m_pxIDTrack[m_muonpos1] != nullptr) m_pxMUTrack[2] = m_pxIDTrack[m_muonpos1]; 
      if (m_pxIDTrack[m_muonpos2] != nullptr) m_pxMUTrack[3] = m_pxIDTrack[m_muonpos2]; 
 
      if (goodtracks) { // Everything is ready
    m_fInvariantMass[ID]      = EvalFourMuInvMass( m_pxMUTrack[0], m_pxMUTrack[1], m_pxMUTrack[2], m_pxMUTrack[3] );
    m_fMuonDispersion[ID]     = EvaluateAngle(   m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
    m_fZPt[ID]                = EvalPt(          m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
    m_fZEtaDir[ID]            = EvalEta(         m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
    m_fZPhiDir[ID]            = EvalPhi(         m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
    
    kinematicscomputed = true;
    
    if(m_doDebug){ 
      std::cout << " * FourMuonEvent * ReconstructKinematics4Elec * -- Muon ID Tracks -- new -- " << std::endl
            << "                                           Pt(mu1-)= " << m_pxMUTrack[0]->pt() << std::endl
            << "                                           Pt(mu2-)= " << m_pxMUTrack[1]->pt() << std::endl
            << "                                           Pt(mu1+)= " << m_pxMUTrack[2]->pt() << std::endl
            << "                                           Pt(mu2+)= " << m_pxMUTrack[3]->pt() << std::endl
            << "                                           invariant mass (4mu) = " << m_fInvariantMass[ID] << std::endl
            << std::endl; 
    }
    
      } // good tracks  
    } // goodidentifiers
  } // goodmuons == 4
  
  if (!kinematicscomputed) {
    if(m_doDebug){  std::cout <<" * FourMuonEvent * ReconstructKinematics * -- FAILED -- " << std::endl; }
  }
 
  if(m_doDebug){  std::cout <<" * FourMuonEvent * ReconstructKinematics * -- completed -- status: " << kinematicscomputed << std::endl; }
  return kinematicscomputed;
}

ReconstructKinematics4Elec()

bool FourMuonEvent::ReconstructKinematics4Elec ( )

private

Definition at line 752 of file FourMuonEvent.cxx.

{
  if(m_doDebug){ std::cout << " * FourMuonEvent * ReconstructKinematics4Elec * -- start -- " << std::endl; }
  bool kinematicscomputed = false;
 
  // Three ways. No checks here. Thus make sure the pointers are ok before this.
  if ( m_numberOfFullPassElectrons == 4 ) {
    // before computing the kinematic parameters check track particles are ok
    bool goodtracks = true;
    m_pxELTrack[0] = m_xElecID.GetElecNegTrackParticle(0); 
    m_pxELTrack[1] = m_xElecID.GetElecNegTrackParticle(1); 
    m_pxELTrack[2] = m_xElecID.GetElecPosTrackParticle(0); 
    m_pxELTrack[3] = m_xElecID.GetElecPosTrackParticle(1); 
    if (m_pxELTrack[0] == nullptr) goodtracks = false;
    if (m_pxELTrack[1] == nullptr) goodtracks = false;
    if (m_pxELTrack[2] == nullptr) goodtracks = false;
    if (m_pxELTrack[3] == nullptr) goodtracks = false;
      
    if (goodtracks) { // Everything is ready
      // For the time being analysis is performed only with ID tracks
      m_fInvariantMass[ID]      = EvalFourMuInvMass( m_pxELTrack[0], m_pxELTrack[1], m_pxELTrack[2], m_pxELTrack[3]);
      m_fMuonDispersion[ID]     = EvaluateAngle(   m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      m_fZPt[ID]                = EvalPt(          m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      m_fZEtaDir[ID]            = EvalEta(         m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      m_fZPhiDir[ID]            = EvalPhi(         m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      kinematicscomputed = true;
      
      if(m_doDebug){ 
    std::cout << " * FourMuonEvent * ReconstructKinematics4Elec * -- Electron Tracks -- " << std::endl
          << "                                           Pt(e1-)= " << m_pxELTrack[0]->pt() << std::endl
          << "                                           Pt(e2-)= " << m_pxELTrack[1]->pt() << std::endl
          << "                                           Pt(e1+)= " << m_pxELTrack[2]->pt() << std::endl
          << "                                           Pt(e2+)= " << m_pxELTrack[3]->pt() << std::endl
          << "                                           invariant mass (4e) = " << m_fInvariantMass[ID] << std::endl
          << std::endl; 
      }
    } // good tracks  
  } // goodidentifiers
 
  if (!kinematicscomputed) {
    if(m_doDebug){  std::cout <<" * FourMuonEvent * ReconstructKinematics4Elec * -- FAILED -- " << std::endl; }
  }
  
  if(m_doDebug){  std::cout <<" * FourMuonEvent * ReconstructKinematics4Elec * -- completed -- status: " << kinematicscomputed << std::endl; }
  return kinematicscomputed;
}

ReconstructKinematicsNew()

bool FourMuonEvent::ReconstructKinematicsNew ( )

private

Definition at line 800 of file FourMuonEvent.cxx.

{
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent * ReconstructKinematicsNew * -- START -- " << endmsg; 
 
  bool kinematicscomputed = false;
 
  // first step get the list of TrackParticles for muons and electrons
  // -- muons (a bit more complex than for electrons)
  if (m_muonneg1 >= 0) m_pxMUTrack[0] = m_pxIDTrack[m_muonneg1];  
  if (m_muonneg2 >= 0) m_pxMUTrack[1] = m_pxIDTrack[m_muonneg2];  
  if (m_muonpos1 >= 0) m_pxMUTrack[2] = m_pxIDTrack[m_muonpos1];  
  if (m_muonpos2 >= 0) m_pxMUTrack[3] = m_pxIDTrack[m_muonpos2];  
  // add an extra proteccion
  if (m_numberOfFullPassMuons < 2) {
    for (int i=0; i<4; i++) m_pxMUTrack[i] = nullptr;
  } 
  
  // -- electrons
  m_pxELTrack[0] = m_xElecID.GetElecNegTrackParticle(0); 
  m_pxELTrack[1] = m_xElecID.GetElecNegTrackParticle(1); 
  m_pxELTrack[2] = m_xElecID.GetElecPosTrackParticle(0); 
  m_pxELTrack[3] = m_xElecID.GetElecPosTrackParticle(1);
  // add an extra proteccion
  if (m_numberOfFullPassElectrons < 2) {
    for (int i=0; i<4; i++) m_pxELTrack[i] = nullptr;
  } 
  
  if ( m_numberOfFullPassMuons == 4 ) {
    bool goodtracks = true;
    if (m_pxMUTrack[0] == nullptr) goodtracks = false;
    if (m_pxMUTrack[1] == nullptr) goodtracks = false;
    if (m_pxMUTrack[2] == nullptr) goodtracks = false;
    if (m_pxMUTrack[3] == nullptr) goodtracks = false;
    
    if (goodtracks) { // Everything is ready
      m_fInvariantMass[ID]      = EvalFourMuInvMass ( m_pxMUTrack[0], m_pxMUTrack[1], m_pxMUTrack[2], m_pxMUTrack[3] );
      m_fMuonDispersion[ID]     = EvaluateAngle     ( m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
      m_fZPt[ID]                = EvalPt            ( m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
      m_fZEtaDir[ID]            = EvalEta           ( m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
      m_fZPhiDir[ID]            = EvalPhi           ( m_pxMUTrack[0], m_pxMUTrack[2]); // leading mu- and leading mu+ 
      kinematicscomputed = true;
    }      
  }
    
  if(m_doDebug){ 
    std::cout << " * FourMuonEvent * ReconstructKinematicsNew * -- Muon ID Tracks -- new -- " << std::endl;
    if (m_pxMUTrack[0] != nullptr) std::cout << "                                           Pt(mu1-)= " << m_pxMUTrack[0]->pt() << std::endl;
    if (m_pxMUTrack[1] != nullptr) std::cout << "                                           Pt(mu2-)= " << m_pxMUTrack[1]->pt() << std::endl;
    if (m_pxMUTrack[2] != nullptr) std::cout << "                                           Pt(mu1+)= " << m_pxMUTrack[2]->pt() << std::endl;
    if (m_pxMUTrack[3] != nullptr) std::cout << "                                           Pt(mu2+)= " << m_pxMUTrack[3]->pt() << std::endl;
    if (kinematicscomputed)        std::cout << "                                           invariant mass (4mu) = " << m_fInvariantMass[ID] << std::endl;
  }
 
  double invmass_test = -1.; // default value
  if ( m_numberOfFullPassElectrons == 4) { 
    // before computing the kinematic parameters check track particles are ok
    bool goodtracks = true;
    if (m_pxELTrack[0] == nullptr) goodtracks = false;
    if (m_pxELTrack[1] == nullptr) goodtracks = false;
    if (m_pxELTrack[2] == nullptr) goodtracks = false;
    if (m_pxELTrack[3] == nullptr) goodtracks = false;
      
    if (goodtracks && !kinematicscomputed) { // Everything is ready
      // For the time being analysis is performed only with ID tracks
      m_fInvariantMass[ID]      = EvalFourMuInvMass( m_pxELTrack[0], m_pxELTrack[1], m_pxELTrack[2], m_pxELTrack[3]);
      invmass_test              = m_fInvariantMass[ID];
      m_fMuonDispersion[ID]     = EvaluateAngle(   m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      m_fZPt[ID]                = EvalPt(          m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      m_fZEtaDir[ID]            = EvalEta(         m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      m_fZPhiDir[ID]            = EvalPhi(         m_pxELTrack[0], m_pxELTrack[2]); // leading e- and leading e+ 
      kinematicscomputed = true;
    } // good tracks  
  }
  if(m_doDebug){ 
    std::cout << " * FourMuonEvent * ReconstructKinematicsNew * -- Electron Tracks -- " << std::endl;
    if (m_pxELTrack[0] != nullptr) std::cout << "                                           Pt(e1-)= " << m_pxELTrack[0]->pt() << std::endl;
    if (m_pxELTrack[1] != nullptr) std::cout << "                                           Pt(e2-)= " << m_pxELTrack[1]->pt() << std::endl;
    if (m_pxELTrack[2] != nullptr) std::cout << "                                           Pt(e1+)= " << m_pxELTrack[2]->pt() << std::endl;
    if (m_pxELTrack[3] != nullptr) std::cout << "                                           Pt(e2+)= " << m_pxELTrack[3]->pt() << std::endl;
    std::cout << "                                           invariant mass (4e) = " <<  invmass_test << std::endl; 
  }
 
  if ( m_numberOfFullPassMuons >= 2 && m_numberOfFullPassElectrons >= 2 && !kinematicscomputed) {
    // before computing the kinematic parameters check track particles are ok
    bool goodtracks = true;
    if (m_pxMUTrack[0] == nullptr) goodtracks = false; // leading mu-
    if (m_pxMUTrack[2] == nullptr) goodtracks = false; // leading mu+
    if (m_pxELTrack[0] == nullptr) goodtracks = false; // leading e-
    if (m_pxELTrack[2] == nullptr) goodtracks = false; // leading e+
      
    if (goodtracks && !kinematicscomputed) { // Everything is ready
      // For the time being analysis is performed only with ID tracks
      m_fInvariantMass[ID]      = EvalFourMuInvMass ( m_pxMUTrack[0], m_pxMUTrack[2], m_pxELTrack[0], m_pxELTrack[2]);
      invmass_test              = m_fInvariantMass[ID];
      m_fMuonDispersion[ID]     = EvaluateAngle     ( m_pxMUTrack[0], m_pxELTrack[0]); // leading mu- and leading e- 
      m_fZPt[ID]                = EvalPt            ( m_pxMUTrack[0], m_pxELTrack[0]); // leading mu- and leading e- 
      m_fZEtaDir[ID]            = EvalEta           ( m_pxMUTrack[0], m_pxELTrack[0]); // leading mu- and leading e- 
      m_fZPhiDir[ID]            = EvalPhi           ( m_pxMUTrack[0], m_pxELTrack[0]); // leading mu- and leading e- 
      kinematicscomputed = true;
    } // good tracks  
  }
  if(m_doDebug){ 
    std::cout << " * FourMuonEvent * ReconstructKinematicsNew * -- Muon and Electron Tracks -- " << std::endl;
    if (m_pxMUTrack[0] != nullptr) std::cout << "                                           Pt(mu1-)= " << m_pxMUTrack[0]->pt() << std::endl;
    if (m_pxMUTrack[1] != nullptr) std::cout << "                                           Pt(mu2-)= " << m_pxMUTrack[1]->pt() << std::endl;
    if (m_pxMUTrack[2] != nullptr) std::cout << "                                           Pt(mu1+)= " << m_pxMUTrack[2]->pt() << std::endl;
    if (m_pxMUTrack[3] != nullptr) std::cout << "                                           Pt(mu2+)= " << m_pxMUTrack[3]->pt() << std::endl;
    if (m_pxELTrack[0] != nullptr) std::cout << "                                           Pt(e1-)= " << m_pxELTrack[0]->pt() << std::endl;
    if (m_pxELTrack[1] != nullptr) std::cout << "                                           Pt(e2-)= " << m_pxELTrack[1]->pt() << std::endl;
    if (m_pxELTrack[2] != nullptr) std::cout << "                                           Pt(e1+)= " << m_pxELTrack[2]->pt() << std::endl;
    if (m_pxELTrack[3] != nullptr) std::cout << "                                           Pt(e2+)= " << m_pxELTrack[3]->pt() << std::endl;
    std::cout << "                                           invariant mass used = " <<  m_fInvariantMass[ID]  << std::endl; 
    std::cout << "                                           invariant mass test = " <<  invmass_test << std::endl; 
  }
  
  if (!kinematicscomputed) {
    if(m_doDebug){  std::cout <<" * FourMuonEvent * ReconstructKinematicsNew * -- FAILED -- " << std::endl; }
  }
  
  (*m_msgStream) << MSG::DEBUG << " * FourMuonEvent * ReconstructKinematicsNew * -- COMPLETED -- status " << kinematicscomputed << endmsg; 
  return kinematicscomputed;
}

RecordMuon()

void FourMuonEvent::RecordMuon ( const xAOD::Muon * pxMuon )

private

Definition at line 641 of file FourMuonEvent.cxx.

{
  constexpr bool thisdebug = false;
  // This shouldn't really ever happen but just in case.
  if ( !pxMuon ) {
    if(m_doDebug){  std::cout <<" * FourMuonEvent * RecordMuon * bad pxMuon --> EXIT "<< std::endl;}
    return;
  }
 
  if ( m_numberOfFullPassMuons < NUM_MUONS ) {
      // The main Muon
      m_pxRecMuon[m_numberOfFullPassMuons] = pxMuon;
      if (thisdebug) {
    std::cout <<" * FourMuonEvent * RecordMuon * m_pxRecMuon for this muon--> pt "<< m_pxRecMuon[m_numberOfFullPassMuons]->pt() << std::endl;
    std::cout <<"                                                             d0 "<< m_pxRecMuon[m_numberOfFullPassMuons]->trackParticle(xAOD::Muon::TrackParticleType::Primary)->d0() << std::endl;
    std::cout <<"                                                       sigma_d0 "<< m_pxRecMuon[m_numberOfFullPassMuons]->trackParticle(xAOD::Muon::TrackParticleType::Primary)->definingParametersCovMatrixVec()[0] << std::endl;
      }
 
      const xAOD::TrackParticle* pxMSTrack   = pxMuon->trackParticle(xAOD::Muon::TrackParticleType::MuonSpectrometerTrackParticle);
      if (!pxMSTrack) {
    if (m_doDebug){  std::cout <<" * FourMuonEvent * RecordMuon * bad pxMSmuon --> EXIT "<< std::endl;}
    return;
      } 
      m_pxMSTrack[m_numberOfFullPassMuons] = pxMSTrack;
      if (thisdebug) {
    std::cout <<" * FourMuonEvent * RecordMuon * m_pxMSTrack for this muon--> pt "<< m_pxMSTrack[m_numberOfFullPassMuons]->pt() << std::endl;
    std::cout <<"                                                             d0 "<< m_pxMSTrack[m_numberOfFullPassMuons]->d0() << std::endl;
    std::cout <<"                                                       sigma_d0 "<< m_pxMSTrack[m_numberOfFullPassMuons]->definingParametersCovMatrixVec()[0] << std::endl;
      }
 
      // ID muon 
      const xAOD::TrackParticle*  pxIDTrack  = pxMuon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle);
      if (!pxIDTrack) {
    if (m_doDebug){  std::cout <<" * FourMuonEvent * RecordMuon * bad pxIDTrack for this muon--> EXIT "<< std::endl;}
    return;
      }      
      m_pxIDTrack[m_numberOfFullPassMuons] = pxIDTrack;
      if (thisdebug) {
    std::cout <<" * FourMuonEvent * RecordMuon * m_pxIDTrack for this muon--> pt "<< m_pxIDTrack[m_numberOfFullPassMuons]->pt() << std::endl;
    std::cout <<"                                                             d0 "<< m_pxIDTrack[m_numberOfFullPassMuons]->d0() << std::endl;
    std::cout <<"                                                       sigma_d0 "<< m_pxIDTrack[m_numberOfFullPassMuons]->definingParametersCovMatrixVec()[0] << std::endl;
      }
      //
      ++m_numberOfFullPassMuons;
      ++m_acceptedMuonCount;
  }
  // if(m_doDebug){  std::cout <<" * FourMuonEvent * RecordMuon * completed -- return with a total of " << m_numberOfFullPassMuons << std::endl;}
  return;
}

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 FourMuonEvent::setContainer ( PerfMonServices::CONTAINERS container )

inline

Definition at line 108 of file FourMuonEvent.h.

{ m_container = container; };

setDebugMode()

void FourMuonEvent::setDebugMode ( bool debug )

inline

Definition at line 109 of file FourMuonEvent.h.

{ m_doDebug=debug; }

SetLeadingMuonPtCut()

void FourMuonEvent::SetLeadingMuonPtCut

(

double

newvalue

)

Definition at line 1040 of file FourMuonEvent.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){ 
    std::cout <<" * FourMuonEvent * SetLeadingMuonPtCut * new Pt cuts:  " << m_LeadingMuonPtCut << " & " 
          << m_SecondMuonPtCut 
          << "  MuonSelector: " << m_xMuonID.GetPtCut() << std::endl;
  }
  return;
}

SetMassWindowHigh()

void FourMuonEvent::SetMassWindowHigh ( double newvalue )

inline

Definition at line 112 of file FourMuonEvent.h.

{ m_MassWindowHigh = newvalue; }

SetMassWindowLow()

void FourMuonEvent::SetMassWindowLow ( double newvalue )

inline

Definition at line 111 of file FourMuonEvent.h.

{ m_MassWindowLow = newvalue; }

SetMuonPtCut()

void FourMuonEvent::SetMuonPtCut ( double newvalue )

inline

Definition at line 113 of file FourMuonEvent.h.

{ m_xMuonID.SetPtCut(newvalue); }

SetMuonSelectionTool()

void FourMuonEvent::SetMuonSelectionTool ( const ToolHandle< CP::IMuonSelectionTool > & mst )

inline

Definition at line 114 of file FourMuonEvent.h.

{ m_xMuonID.SetCustomMuonSelectionTool (mst); };

SetOpeningAngleCut()

void FourMuonEvent::SetOpeningAngleCut ( double newvalue )

inline

Definition at line 116 of file FourMuonEvent.h.

{ m_OpeningAngleCut = newvalue; }

SetSecondMuonPtCut()

void FourMuonEvent::SetSecondMuonPtCut

(

double

newvalue

)

Definition at line 1060 of file FourMuonEvent.cxx.

{
  m_SecondMuonPtCut = newvalue;
 
  // use same for electrons  
  m_xElecID.SetPtCut(m_SecondMuonPtCut);
 
  // 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) {
    std::cout <<" * FourMuonEvent * SetSecondMuonPtCut * new Pt cuts:  " << m_LeadingMuonPtCut 
          << " & " << m_SecondMuonPtCut 
          << "  MuonSelector: " << m_xMuonID.GetPtCut() << std::endl;
  }
 
  return;
}

SetZ0GapCut()

void FourMuonEvent::SetZ0GapCut ( double newvalue )

inline

Definition at line 117 of file FourMuonEvent.h.

{ m_Z0GapCut = newvalue; }

Member Data Documentation

invalidAnswer

float EventAnalysis::invalidAnswer {-999.9f}

staticconstexprinherited

Definition at line 40 of file EventAnalysis.h.

{-999.9f};

m_acceptedElecCount

int FourMuonEvent::m_acceptedElecCount {}

private

Definition at line 201 of file FourMuonEvent.h.

{};

m_acceptedEventCount

int FourMuonEvent::m_acceptedEventCount {}

private

Definition at line 198 of file FourMuonEvent.h.

{};

m_acceptedMuonCount

int FourMuonEvent::m_acceptedMuonCount {}

private

Definition at line 200 of file FourMuonEvent.h.

{};

m_container

PerfMonServices::CONTAINERS FourMuonEvent::m_container

private

Definition at line 142 of file FourMuonEvent.h.

m_deltaXYcut

double FourMuonEvent::m_deltaXYcut {}

private

Definition at line 153 of file FourMuonEvent.h.

{};

m_doDebug

bool FourMuonEvent::m_doDebug {}

private

Definition at line 156 of file FourMuonEvent.h.

{};

m_elec_vtx

int FourMuonEvent::m_elec_vtx[NUM_MUONS] {}

private

Definition at line 221 of file FourMuonEvent.h.

{};

m_eventCount

int FourMuonEvent::m_eventCount {}

private

Definition at line 197 of file FourMuonEvent.h.

{};

m_fInvariantMass

Arrayf FourMuonEvent::m_fInvariantMass {}

private

Definition at line 182 of file FourMuonEvent.h.

{};

m_fMuonDispersion

Arrayf FourMuonEvent::m_fMuonDispersion {}

private

Definition at line 183 of file FourMuonEvent.h.

{};

m_FourMuonInvMass

double FourMuonEvent::m_FourMuonInvMass {}

private

Definition at line 146 of file FourMuonEvent.h.

{};

m_fZEtaDir

Arrayf FourMuonEvent::m_fZEtaDir {}

private

Definition at line 180 of file FourMuonEvent.h.

{};

m_fZPhiDir

Arrayf FourMuonEvent::m_fZPhiDir {}

private

Definition at line 181 of file FourMuonEvent.h.

{};

m_fZPt

Arrayf FourMuonEvent::m_fZPt {}

private

Definition at line 179 of file FourMuonEvent.h.

{};

m_LeadingMuonPtCut

double FourMuonEvent::m_LeadingMuonPtCut {}

private

Definition at line 148 of file FourMuonEvent.h.

{};

m_MassWindowHigh

double FourMuonEvent::m_MassWindowHigh {}

private

Definition at line 151 of file FourMuonEvent.h.

{};

m_MassWindowLow

double FourMuonEvent::m_MassWindowLow {}

private

Definition at line 150 of file FourMuonEvent.h.

{};

m_msgStream

MsgStream* FourMuonEvent::m_msgStream {}

private

Definition at line 137 of file FourMuonEvent.h.

{};

m_muon1

int FourMuonEvent::m_muon1 = 0

private

Definition at line 205 of file FourMuonEvent.h.

m_muon2

int FourMuonEvent::m_muon2 = 0

private

Definition at line 206 of file FourMuonEvent.h.

m_muon_vtx

int FourMuonEvent::m_muon_vtx[NUM_MUONS] {}

private

Definition at line 220 of file FourMuonEvent.h.

{};

m_muonneg1

int FourMuonEvent::m_muonneg1 = 0

private

Definition at line 210 of file FourMuonEvent.h.

m_muonneg1_vtx

int FourMuonEvent::m_muonneg1_vtx = 0

private

Definition at line 215 of file FourMuonEvent.h.

m_muonneg2

int FourMuonEvent::m_muonneg2 = 0

private

Definition at line 211 of file FourMuonEvent.h.

m_muonneg2_vtx

int FourMuonEvent::m_muonneg2_vtx = 0

private

Definition at line 216 of file FourMuonEvent.h.

m_muonpos1

int FourMuonEvent::m_muonpos1 = 0

private

Definition at line 208 of file FourMuonEvent.h.

m_muonpos1_vtx

int FourMuonEvent::m_muonpos1_vtx = 0

private

Definition at line 217 of file FourMuonEvent.h.

m_muonpos2

int FourMuonEvent::m_muonpos2 = 0

private

Definition at line 209 of file FourMuonEvent.h.

m_muonpos2_vtx

int FourMuonEvent::m_muonpos2_vtx = 0

private

Definition at line 218 of file FourMuonEvent.h.

m_numberOfFullPassElectrons

unsigned int FourMuonEvent::m_numberOfFullPassElectrons {}

private

Definition at line 163 of file FourMuonEvent.h.

{};

m_numberOfFullPassMuons

unsigned int FourMuonEvent::m_numberOfFullPassMuons {}

private

Definition at line 162 of file FourMuonEvent.h.

{};

m_nVertex

int FourMuonEvent::m_nVertex = 0

private

Definition at line 214 of file FourMuonEvent.h.

m_OpeningAngleCut

double FourMuonEvent::m_OpeningAngleCut {}

private

Definition at line 152 of file FourMuonEvent.h.

{};

m_passedFourElectronSelection

bool FourMuonEvent::m_passedFourElectronSelection = false

private

Definition at line 166 of file FourMuonEvent.h.

m_passedFourLeptonSelection

bool FourMuonEvent::m_passedFourLeptonSelection = false

private

Definition at line 167 of file FourMuonEvent.h.

m_passedFourMuonSelection

bool FourMuonEvent::m_passedFourMuonSelection = false

private

Definition at line 165 of file FourMuonEvent.h.

m_passedSelectionCuts

bool FourMuonEvent::m_passedSelectionCuts = false

private

Definition at line 164 of file FourMuonEvent.h.

m_pxELTrack

const xAOD::TrackParticle* FourMuonEvent::m_pxELTrack[NUM_MUONS] {}

private

Definition at line 174 of file FourMuonEvent.h.

{};  // pointer to Track particle of the electrons

m_pxIDTrack

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

private

Definition at line 172 of file FourMuonEvent.h.

{};       // Pointer to ID track

m_pxMETrack

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

private

Definition at line 170 of file FourMuonEvent.h.

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

m_pxMSTrack

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

private

Definition at line 171 of file FourMuonEvent.h.

{};      // Pointer to muon spectro

m_pxMUTrack

const xAOD::TrackParticle* FourMuonEvent::m_pxMUTrack[NUM_MUONS] {}

private

Definition at line 175 of file FourMuonEvent.h.

{};  // pointer to Track particle of the muons

m_pxRecMuon

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

private

Definition at line 169 of file FourMuonEvent.h.

{};

m_SecondMuonPtCut

double FourMuonEvent::m_SecondMuonPtCut {}

private

Definition at line 149 of file FourMuonEvent.h.

{};

m_SelectMuonByIP

bool FourMuonEvent::m_SelectMuonByIP {}

private

Definition at line 194 of file FourMuonEvent.h.

{};

m_SelectMuonByIso

bool FourMuonEvent::m_SelectMuonByIso {}

private

Definition at line 193 of file FourMuonEvent.h.

{};

m_uMuonTags

unsigned int FourMuonEvent::m_uMuonTags {}

private

Definition at line 145 of file FourMuonEvent.h.

{};

m_uPassedEvents

unsigned int EventAnalysis::m_uPassedEvents

protectedinherited

Definition at line 75 of file EventAnalysis.h.

m_workAsFourElectrons

bool FourMuonEvent::m_workAsFourElectrons {}

private

Definition at line 158 of file FourMuonEvent.h.

{};

m_workAsFourLeptons

bool FourMuonEvent::m_workAsFourLeptons {}

private

Definition at line 159 of file FourMuonEvent.h.

{};

m_workAsFourMuons

bool FourMuonEvent::m_workAsFourMuons {}

private

Definition at line 157 of file FourMuonEvent.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_xElecID

ElectronSelector FourMuonEvent::m_xElecID

private

Definition at line 141 of file FourMuonEvent.h.

m_xMuonID

MuonSelector FourMuonEvent::m_xMuonID

private

Definition at line 140 of file FourMuonEvent.h.

m_xSampleName

std::string EventAnalysis::m_xSampleName

protectedinherited

Definition at line 81 of file EventAnalysis.h.

m_Z0GapCut

double FourMuonEvent::m_Z0GapCut {}

private

Definition at line 154 of file FourMuonEvent.h.

{};

---

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

• FourMuonEvent.h
• FourMuonEvent.cxx