[u/mrichter/AliRoot.git] / PWG / muon / AliMuonPairCuts.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

#include "AliMuonPairCuts.h"

#include "TMath.h"
#include "TList.h"
#include "TLorentzVector.h"
#include "TArrayI.h"

#include "AliLog.h"
#include "AliVParticle.h"

/// \cond CLASSIMP
ClassImp(AliMuonPairCuts) // Class implementation in ROOT context
/// \endcond

//________________________________________________________________________
AliMuonPairCuts::AliMuonPairCuts() :
  AliAnalysisCuts(),
  fMuonTrackCuts()
{
  /// Default ctor.
}

//________________________________________________________________________
AliMuonPairCuts::AliMuonPairCuts(const char* name, const char* title) :
AliAnalysisCuts(name, title),
fMuonTrackCuts("muonTrackCutInPair","muonTrackCutInPair")
{
  /// Constructor
  SetDefaultFilterMask();
}


//________________________________________________________________________
AliMuonPairCuts::AliMuonPairCuts(const char* name, const char* title, const AliMuonTrackCuts& trackCuts) :
AliAnalysisCuts(name, title),
fMuonTrackCuts(trackCuts)
{
  /// Test Constructor
  SetDefaultFilterMask();
}


//________________________________________________________________________
AliMuonPairCuts::AliMuonPairCuts(const AliMuonPairCuts& obj) :
  AliAnalysisCuts(obj),
  fMuonTrackCuts(obj.fMuonTrackCuts)
{
  /// Copy constructor
}


//________________________________________________________________________
AliMuonPairCuts& AliMuonPairCuts::operator=(const AliMuonPairCuts& obj)
{
  /// Assignment operator
  if ( this != &obj ) { 
    AliAnalysisCuts::operator=(obj);
    fMuonTrackCuts = obj.fMuonTrackCuts;
  }
  return *this;
}


//________________________________________________________________________
AliMuonPairCuts::~AliMuonPairCuts()
{
  /// Destructor
}

//________________________________________________________________________
Bool_t AliMuonPairCuts::SetRun( Int_t runNumber )
{
  /// Get parameters from OADB for runNumber
  return fMuonTrackCuts.SetRun(runNumber);
}


//________________________________________________________________________
Bool_t AliMuonPairCuts::IsSelected( TObject* /*obj*/ )
{
  /// Not implemented
  AliError("Requires a list of two AliVParticle");
  return kFALSE;
}

//________________________________________________________________________
Bool_t AliMuonPairCuts::IsSelected( TList* list )
{
  /// Pair is selected
  UInt_t filterMask = GetFilterMask();
  UInt_t selectionMask = GetSelectionMask(list);
  
  return ( ( selectionMask & filterMask ) == filterMask );
}


//________________________________________________________________________
UInt_t AliMuonPairCuts::GetSelectionMask( const TObject* obj )
{
  /// Get selection mask (overloaded function)
  const TList* list = static_cast<const TList*> ( obj );
  if ( list->GetEntries() < 2 ) {
    AliError("Requires a list of two AliVParticle");
    return 0;
  }

  return GetSelectionMask(list->At(0), list->At(1));

}


//________________________________________________________________________
UInt_t AliMuonPairCuts::GetSelectionMask( const TObject* track1, const TObject* track2 )
{
  /// Get selection mask from AliVParticles
  
  UInt_t selectionMask = 0;
    
  UInt_t maskTrack1 = fMuonTrackCuts.GetSelectionMask(track1);
  UInt_t maskTrack2 = fMuonTrackCuts.GetSelectionMask(track2);
  
  UInt_t maskAND = maskTrack1 & maskTrack2;
  UInt_t maskOR = maskTrack1 | maskTrack2;
  if ( maskAND & AliMuonTrackCuts::kMuEta ) selectionMask |= kBothMuEta;
  if ( maskAND & AliMuonTrackCuts::kMuThetaAbs ) selectionMask |= kBothMuThetaAbs;
  if ( maskAND & AliMuonTrackCuts::kMuPdca ) selectionMask |= kBothMuPdca;
  if ( maskAND & AliMuonTrackCuts::kMuTrackChiSquare ) selectionMask |= kBothMuTrackChiSquare;
  if ( maskAND & AliMuonTrackCuts::kMuMatchApt ) selectionMask |= kBothMuMatchApt;
  if ( maskAND & AliMuonTrackCuts::kMuMatchLpt ) selectionMask |= kBothMuMatchLpt;
  if ( maskAND & AliMuonTrackCuts::kMuMatchHpt ) selectionMask |= kBothMuMatchHpt;
  if ( maskOR & AliMuonTrackCuts::kMuMatchApt ) selectionMask |= kOneMuMatchApt;
  if ( maskOR & AliMuonTrackCuts::kMuMatchLpt ) selectionMask |= kOneMuMatchLpt;
  if ( maskOR & AliMuonTrackCuts::kMuMatchHpt ) selectionMask |= kOneMuMatchHpt;
  
  TLorentzVector vec[2];
  Double_t chargeProduct = 1.;
  for ( Int_t itrack=0; itrack<2; ++itrack ) {
    const AliVParticle* track = static_cast<const AliVParticle*> ( ( itrack == 0 ) ? track1 : track2 );
    chargeProduct *= track->Charge();
    Double_t trackP = track->P();
    Double_t energy = TMath::Sqrt(trackP*trackP + MuonMass2());
    vec[itrack].SetPxPyPzE(track->Px(), track->Py(), track->Pz(), energy);
  }
  
  if ( chargeProduct < 0. ) selectionMask |= kDimuUnlikeSign;
  
  TLorentzVector vecPair = vec[0] + vec[1];
  Double_t rapidity = vecPair.Rapidity();
  if ( rapidity > -4. && rapidity < -2.5 ) selectionMask |= kDimuRapidity; 
  
  return selectionMask;
}


//_____________________________________________________________________________
Double_t AliMuonPairCuts::MuonMass2() const
{
  /// A usefull constant
  static Double_t m2 = 1.11636129640000012e-02;
  return m2;
}


//________________________________________________________________________
void AliMuonPairCuts::SetDefaultFilterMask ()
{
  /// Standard cuts for muon pair
  SetFilterMask ( kBothMuEta | kBothMuThetaAbs | kBothMuMatchLpt | kDimuUnlikeSign | kDimuRapidity );
}  

//________________________________________________________________________
void AliMuonPairCuts::SetIsMC ( Bool_t isMC )
{
  /// Set Is MC
  fMuonTrackCuts.SetIsMC(isMC);
}

//________________________________________________________________________
Bool_t AliMuonPairCuts::TrackPtCutMatchTrigClass ( const AliVParticle* track1, const AliVParticle* track2, const TArrayI ptCutFromClass ) const
{
  /// Check if track pair passes the trigger pt cut level used in the trigger class
  Bool_t matchTrig1 = fMuonTrackCuts.TrackPtCutMatchTrigClass(track1, ptCutFromClass);
  Bool_t matchTrig2 = fMuonTrackCuts.TrackPtCutMatchTrigClass(track2, ptCutFromClass);
  
  Bool_t matchTrackerPt1 = kTRUE, matchTrackerPt2 = kTRUE;
  if ( IsApplySharpPtCutInMatching() ) {
    matchTrackerPt1 = ( track1->Pt() >= fMuonTrackCuts.GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
    matchTrackerPt2 = ( track2->Pt() >= fMuonTrackCuts.GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
  }
  
  matchTrig1 = ( matchTrig1 && matchTrackerPt1 );
  matchTrig2 = ( matchTrig2 && matchTrackerPt2 );
  
  Bool_t passCut = ( ptCutFromClass[1]>0 ) ? ( matchTrig1 && matchTrig2 ) : ( matchTrig1 || matchTrig2 );

  AliDebug(1,Form("Class matchTrig %i %i  trackMatchTrig %i %i trackPt %g %g (required %i)  passCut %i", ptCutFromClass[0], ptCutFromClass[1], matchTrig1, matchTrig2, track1->Pt(), track2->Pt(), IsApplySharpPtCutInMatching(),passCut));
  return passCut;
}

//________________________________________________________________________
void AliMuonPairCuts::Print(Option_t* option) const
{
  //
  /// Print info
  //
  
  TString sopt(option);
  sopt.ToLower();
  if ( sopt.IsNull() || sopt.Contains("*") || sopt.Contains("all") ) sopt += " pair trackparam trackmask";
  if ( sopt.Contains("pair") ) {
    UInt_t filterMask = GetFilterMask();
    printf(" *** Muon pair filter mask: *** \n");
    printf("  0x%x\n", filterMask);
    if ( filterMask & kBothMuEta ) printf("  mu1 && mu2 pass eta cut\n");
    if ( filterMask & kBothMuThetaAbs ) printf("  mu1 && mu2 pass theta_abs cut\n");
    if ( filterMask & kBothMuPdca ) printf("  mu1 && mu2 pass pxDCA cut\n");
    if ( filterMask & kBothMuTrackChiSquare ) printf("  Chi2 cut on track\n");
    if ( filterMask & kBothMuMatchApt ) printf("  mu1 && mu2 match Apt\n");
    if ( filterMask & kBothMuMatchLpt ) printf("  mu1 && mu2 match Lpt\n");
    if ( filterMask & kBothMuMatchHpt ) printf("  mu1 && mu2 match Hpt\n");
    if ( filterMask & kOneMuMatchApt ) printf("  mu1 || mu2 match Apt\n");
    if ( filterMask & kOneMuMatchLpt ) printf("  mu1 || mu2 match Lpt\n");
    if ( filterMask & kOneMuMatchHpt ) printf("  mu1 || mu2 match Hpt\n");
    if ( filterMask & kDimuUnlikeSign ) printf("  Unlike sign\n");
    if ( filterMask & kDimuRapidity ) printf("  -4 < y_{mumu} < -2.5\n");
    printf(" ******************** \n");
  }
  
  if ( sopt.Contains("track") )
    fMuonTrackCuts.Print(sopt.Data());
}
Commit	Line	Data
64647ced	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
75ef785b	16	#include "AliMuonPairCuts.h"
75ef785b	17
64647ced	18	#include "TMath.h"
	19	#include "TList.h"
	20	#include "TLorentzVector.h"
ebba9ef0	21	#include "TArrayI.h"
64647ced	22
	23	#include "AliLog.h"
	24	#include "AliVParticle.h"
	25
64647ced	26	/// \cond CLASSIMP
	27	ClassImp(AliMuonPairCuts) // Class implementation in ROOT context
	28	/// \endcond
	29
	30	//________________________________________________________________________
	31	AliMuonPairCuts::AliMuonPairCuts() :
	32	AliAnalysisCuts(),
	33	fMuonTrackCuts()
	34	{
	35	/// Default ctor.
	36	}
	37
	38	//________________________________________________________________________
a12dc5da	39	AliMuonPairCuts::AliMuonPairCuts(const char* name, const char* title) :
	40	AliAnalysisCuts(name, title),
	41	fMuonTrackCuts("muonTrackCutInPair","muonTrackCutInPair")
64647ced	42	{
	43	/// Constructor
	44	SetDefaultFilterMask();
	45	}
	46
	47
	48	//________________________________________________________________________
	49	AliMuonPairCuts::AliMuonPairCuts(const char* name, const char* title, const AliMuonTrackCuts& trackCuts) :
	50	AliAnalysisCuts(name, title),
	51	fMuonTrackCuts(trackCuts)
	52	{
	53	/// Test Constructor
	54	SetDefaultFilterMask();
	55	}
	56
	57
64647ced	58	//________________________________________________________________________
	59	AliMuonPairCuts::AliMuonPairCuts(const AliMuonPairCuts& obj) :
	60	AliAnalysisCuts(obj),
	61	fMuonTrackCuts(obj.fMuonTrackCuts)
	62	{
	63	/// Copy constructor
	64	}
	65
	66
d555a462	67	//________________________________________________________________________
	68	AliMuonPairCuts& AliMuonPairCuts::operator=(const AliMuonPairCuts& obj)
	69	{
	70	/// Assignment operator
	71	if ( this != &obj ) {
	72	AliAnalysisCuts::operator=(obj);
	73	fMuonTrackCuts = obj.fMuonTrackCuts;
	74	}
	75	return *this;
	76	}
	77
	78
64647ced	79	//________________________________________________________________________
	80	AliMuonPairCuts::~AliMuonPairCuts()
	81	{
	82	/// Destructor
	83	}
	84
	85	//________________________________________________________________________
	86	Bool_t AliMuonPairCuts::SetRun( Int_t runNumber )
	87	{
	88	/// Get parameters from OADB for runNumber
	89	return fMuonTrackCuts.SetRun(runNumber);
	90	}
	91
	92
	93	//________________________________________________________________________
	94	Bool_t AliMuonPairCuts::IsSelected( TObject* /obj/ )
	95	{
	96	/// Not implemented
	97	AliError("Requires a list of two AliVParticle");
	98	return kFALSE;
	99	}
	100
	101	//________________________________________________________________________
	102	Bool_t AliMuonPairCuts::IsSelected( TList* list )
	103	{
	104	/// Pair is selected
	105	UInt_t filterMask = GetFilterMask();
	106	UInt_t selectionMask = GetSelectionMask(list);
	107
	108	return ( ( selectionMask & filterMask ) == filterMask );
	109	}
	110
	111
	112	//________________________________________________________________________
	113	UInt_t AliMuonPairCuts::GetSelectionMask( const TObject* obj )
	114	{
	115	/// Get selection mask (overloaded function)
	116	const TList* list = static_cast<const TList*> ( obj );
	117	if ( list->GetEntries() < 2 ) {
	118	AliError("Requires a list of two AliVParticle");
	119	return 0;
	120	}
	121
	122	return GetSelectionMask(list->At(0), list->At(1));
	123
	124	}
	125
	126
	127	//________________________________________________________________________
	128	UInt_t AliMuonPairCuts::GetSelectionMask( const TObject* track1, const TObject* track2 )
	129	{
	130	/// Get selection mask from AliVParticles
	131
	132	UInt_t selectionMask = 0;
	133
	134	UInt_t maskTrack1 = fMuonTrackCuts.GetSelectionMask(track1);
	135	UInt_t maskTrack2 = fMuonTrackCuts.GetSelectionMask(track2);
	136
	137	UInt_t maskAND = maskTrack1 & maskTrack2;
	138	UInt_t maskOR = maskTrack1 \| maskTrack2;
	139	if ( maskAND & AliMuonTrackCuts::kMuEta ) selectionMask \|= kBothMuEta;
	140	if ( maskAND & AliMuonTrackCuts::kMuThetaAbs ) selectionMask \|= kBothMuThetaAbs;
	141	if ( maskAND & AliMuonTrackCuts::kMuPdca ) selectionMask \|= kBothMuPdca;
	142	if ( maskAND & AliMuonTrackCuts::kMuTrackChiSquare ) selectionMask \|= kBothMuTrackChiSquare;
143	if ( maskAND & AliMuonTrackCuts::kMuMatchApt ) selectionMask \|= kBothMuMatchApt;
144	if ( maskAND & AliMuonTrackCuts::kMuMatchLpt ) selectionMask \|= kBothMuMatchLpt;
145	if ( maskAND & AliMuonTrackCuts::kMuMatchHpt ) selectionMask \|= kBothMuMatchHpt;
146	if ( maskOR & AliMuonTrackCuts::kMuMatchApt ) selectionMask \|= kOneMuMatchApt;
147	if ( maskOR & AliMuonTrackCuts::kMuMatchLpt ) selectionMask \|= kOneMuMatchLpt;
148	if ( maskOR & AliMuonTrackCuts::kMuMatchHpt ) selectionMask \|= kOneMuMatchHpt;
149
150	TLorentzVector vec[2];
151	Double_t chargeProduct = 1.;
152	for ( Int_t itrack=0; itrack<2; ++itrack ) {
153	const AliVParticle* track = static_cast<const AliVParticle*> ( ( itrack == 0 ) ? track1 : track2 );
154	chargeProduct *= track->Charge();
155	Double_t trackP = track->P();
156	Double_t energy = TMath::Sqrt(trackP*trackP + MuonMass2());
157	vec[itrack].SetPxPyPzE(track->Px(), track->Py(), track->Pz(), energy);
158	}
159
160	if ( chargeProduct < 0. ) selectionMask \|= kDimuUnlikeSign;
161
162	TLorentzVector vecPair = vec[0] + vec[1];
163	Double_t rapidity = vecPair.Rapidity();
164	if ( rapidity > -4. && rapidity < -2.5 ) selectionMask \|= kDimuRapidity;
165
166	return selectionMask;
167	}
168
169
170	//_____________________________________________________________________________
171	Double_t AliMuonPairCuts::MuonMass2() const
172	{
173	/// A usefull constant
76f86d1c	174	static Double_t m2 = 1.11636129640000012e-02;
64647ced	175	return m2;
	176	}
	177
	178
	179	//________________________________________________________________________
	180	void AliMuonPairCuts::SetDefaultFilterMask ()
	181	{
	182	/// Standard cuts for muon pair
	183	SetFilterMask ( kBothMuEta \| kBothMuThetaAbs \| kBothMuMatchLpt \| kDimuUnlikeSign \| kDimuRapidity );
	184	}
	185
	186	//________________________________________________________________________
	187	void AliMuonPairCuts::SetIsMC ( Bool_t isMC )
	188	{
	189	/// Set Is MC
	190	fMuonTrackCuts.SetIsMC(isMC);
	191	}
	192
ebba9ef0	193	//________________________________________________________________________
	194	Bool_t AliMuonPairCuts::TrackPtCutMatchTrigClass ( const AliVParticle* track1, const AliVParticle* track2, const TArrayI ptCutFromClass ) const
	195	{
	196	/// Check if track pair passes the trigger pt cut level used in the trigger class
	197	Bool_t matchTrig1 = fMuonTrackCuts.TrackPtCutMatchTrigClass(track1, ptCutFromClass);
	198	Bool_t matchTrig2 = fMuonTrackCuts.TrackPtCutMatchTrigClass(track2, ptCutFromClass);
	199
	200	Bool_t matchTrackerPt1 = kTRUE, matchTrackerPt2 = kTRUE;
	201	if ( IsApplySharpPtCutInMatching() ) {
	202	matchTrackerPt1 = ( track1->Pt() >= fMuonTrackCuts.GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
	203	matchTrackerPt2 = ( track2->Pt() >= fMuonTrackCuts.GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
	204	}
	205
	206	matchTrig1 = ( matchTrig1 && matchTrackerPt1 );
	207	matchTrig2 = ( matchTrig2 && matchTrackerPt2 );
	208
	209	Bool_t passCut = ( ptCutFromClass[1]>0 ) ? ( matchTrig1 && matchTrig2 ) : ( matchTrig1 \|\| matchTrig2 );
	210
	211	AliDebug(1,Form("Class matchTrig %i %i trackMatchTrig %i %i trackPt %g %g (required %i) passCut %i", ptCutFromClass[0], ptCutFromClass[1], matchTrig1, matchTrig2, track1->Pt(), track2->Pt(), IsApplySharpPtCutInMatching(),passCut));
	212	return passCut;
	213	}
	214
64647ced	215	//________________________________________________________________________
	216	void AliMuonPairCuts::Print(Option_t* option) const
	217	{
	218	//
	219	/// Print info
	220	//
	221
	222	TString sopt(option);
	223	sopt.ToLower();
76f86d1c	224	if ( sopt.IsNull() \|\| sopt.Contains("*") \|\| sopt.Contains("all") ) sopt += " pair trackparam trackmask";
64647ced	225	if ( sopt.Contains("pair") ) {
	226	UInt_t filterMask = GetFilterMask();
	227	printf(" * Muon pair filter mask: * \n");
	228	printf(" 0x%x\n", filterMask);
	229	if ( filterMask & kBothMuEta ) printf(" mu1 && mu2 pass eta cut\n");
	230	if ( filterMask & kBothMuThetaAbs ) printf(" mu1 && mu2 pass theta_abs cut\n");
	231	if ( filterMask & kBothMuPdca ) printf(" mu1 && mu2 pass pxDCA cut\n");
	232	if ( filterMask & kBothMuTrackChiSquare ) printf(" Chi2 cut on track\n");
	233	if ( filterMask & kBothMuMatchApt ) printf(" mu1 && mu2 match Apt\n");
	234	if ( filterMask & kBothMuMatchLpt ) printf(" mu1 && mu2 match Lpt\n");
	235	if ( filterMask & kBothMuMatchHpt ) printf(" mu1 && mu2 match Hpt\n");
89f8af70	236	if ( filterMask & kOneMuMatchApt ) printf(" mu1 \|\| mu2 match Apt\n");
	237	if ( filterMask & kOneMuMatchLpt ) printf(" mu1 \|\| mu2 match Lpt\n");
	238	if ( filterMask & kOneMuMatchHpt ) printf(" mu1 \|\| mu2 match Hpt\n");
64647ced	239	if ( filterMask & kDimuUnlikeSign ) printf(" Unlike sign\n");
	240	if ( filterMask & kDimuRapidity ) printf(" -4 < y_{mumu} < -2.5\n");
	241	printf(" ******************** \n");
	242	}
	243
	244	if ( sopt.Contains("track") )
	245	fMuonTrackCuts.Print(sopt.Data());
	246	}