[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"
#include "AliInputEventHandler.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 ( const AliInputEventHandler* eventHandler )
{
  /// Get parameters from OADB for runNumber
  return fMuonTrackCuts.SetRun(eventHandler);
}


//________________________________________________________________________
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 );
}

//________________________________________________________________________
Bool_t AliMuonPairCuts::IsSelected( TObject* track1, TObject* track2 )
{
  /// Pair is selected
  UInt_t filterMask = GetFilterMask();
  UInt_t selectionMask = GetSelectionMask(track1, track2);
  
  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.GetMuonTrackCutsParam().GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
    matchTrackerPt2 = ( track2->Pt() >= fMuonTrackCuts.GetMuonTrackCutsParam().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"
68e9b988	25	#include "AliInputEventHandler.h"
64647ced	26
64647ced	27	/// \cond CLASSIMP
	28	ClassImp(AliMuonPairCuts) // Class implementation in ROOT context
	29	/// \endcond
	30
	31	//________________________________________________________________________
	32	AliMuonPairCuts::AliMuonPairCuts() :
	33	AliAnalysisCuts(),
	34	fMuonTrackCuts()
	35	{
	36	/// Default ctor.
	37	}
	38
	39	//________________________________________________________________________
a12dc5da	40	AliMuonPairCuts::AliMuonPairCuts(const char* name, const char* title) :
	41	AliAnalysisCuts(name, title),
	42	fMuonTrackCuts("muonTrackCutInPair","muonTrackCutInPair")
64647ced	43	{
	44	/// Constructor
	45	SetDefaultFilterMask();
	46	}
	47
	48
	49	//________________________________________________________________________
	50	AliMuonPairCuts::AliMuonPairCuts(const char* name, const char* title, const AliMuonTrackCuts& trackCuts) :
	51	AliAnalysisCuts(name, title),
	52	fMuonTrackCuts(trackCuts)
	53	{
	54	/// Test Constructor
	55	SetDefaultFilterMask();
	56	}
	57
	58
64647ced	59	//________________________________________________________________________
	60	AliMuonPairCuts::AliMuonPairCuts(const AliMuonPairCuts& obj) :
	61	AliAnalysisCuts(obj),
	62	fMuonTrackCuts(obj.fMuonTrackCuts)
	63	{
	64	/// Copy constructor
	65	}
	66
	67
d555a462	68	//________________________________________________________________________
	69	AliMuonPairCuts& AliMuonPairCuts::operator=(const AliMuonPairCuts& obj)
	70	{
	71	/// Assignment operator
	72	if ( this != &obj ) {
	73	AliAnalysisCuts::operator=(obj);
	74	fMuonTrackCuts = obj.fMuonTrackCuts;
	75	}
	76	return *this;
	77	}
	78
	79
64647ced	80	//________________________________________________________________________
	81	AliMuonPairCuts::~AliMuonPairCuts()
	82	{
	83	/// Destructor
	84	}
	85
	86	//________________________________________________________________________
68e9b988	87	Bool_t AliMuonPairCuts::SetRun ( const AliInputEventHandler* eventHandler )
64647ced	88	{
64647ced	89	/// Get parameters from OADB for runNumber
68e9b988	90	return fMuonTrackCuts.SetRun(eventHandler);
64647ced	91	}
	92
	93
	94	//________________________________________________________________________
	95	Bool_t AliMuonPairCuts::IsSelected( TObject* /obj/ )
	96	{
	97	/// Not implemented
	98	AliError("Requires a list of two AliVParticle");
	99	return kFALSE;
	100	}
	101
	102	//________________________________________________________________________
	103	Bool_t AliMuonPairCuts::IsSelected( TList* list )
	104	{
	105	/// Pair is selected
	106	UInt_t filterMask = GetFilterMask();
	107	UInt_t selectionMask = GetSelectionMask(list);
	108
	109	return ( ( selectionMask & filterMask ) == filterMask );
	110	}
	111
260e4dda	112	//________________________________________________________________________
	113	Bool_t AliMuonPairCuts::IsSelected( TObject* track1, TObject* track2 )
	114	{
	115	/// Pair is selected
	116	UInt_t filterMask = GetFilterMask();
	117	UInt_t selectionMask = GetSelectionMask(track1, track2);
	118
	119	return ( ( selectionMask & filterMask ) == filterMask );
	120	}
	121
64647ced	122
	123	//________________________________________________________________________
	124	UInt_t AliMuonPairCuts::GetSelectionMask( const TObject* obj )
	125	{
	126	/// Get selection mask (overloaded function)
	127	const TList* list = static_cast<const TList*> ( obj );
	128	if ( list->GetEntries() < 2 ) {
	129	AliError("Requires a list of two AliVParticle");
	130	return 0;
	131	}
	132
	133	return GetSelectionMask(list->At(0), list->At(1));
	134
	135	}
	136
	137
	138	//________________________________________________________________________
	139	UInt_t AliMuonPairCuts::GetSelectionMask( const TObject* track1, const TObject* track2 )
	140	{
	141	/// Get selection mask from AliVParticles
	142
	143	UInt_t selectionMask = 0;
	144
	145	UInt_t maskTrack1 = fMuonTrackCuts.GetSelectionMask(track1);
	146	UInt_t maskTrack2 = fMuonTrackCuts.GetSelectionMask(track2);
	147
	148	UInt_t maskAND = maskTrack1 & maskTrack2;
	149	UInt_t maskOR = maskTrack1 \| maskTrack2;
	150	if ( maskAND & AliMuonTrackCuts::kMuEta ) selectionMask \|= kBothMuEta;
	151	if ( maskAND & AliMuonTrackCuts::kMuThetaAbs ) selectionMask \|= kBothMuThetaAbs;
	152	if ( maskAND & AliMuonTrackCuts::kMuPdca ) selectionMask \|= kBothMuPdca;
	153	if ( maskAND & AliMuonTrackCuts::kMuTrackChiSquare ) selectionMask \|= kBothMuTrackChiSquare;
	154	if ( maskAND & AliMuonTrackCuts::kMuMatchApt ) selectionMask \|= kBothMuMatchApt;
	155	if ( maskAND & AliMuonTrackCuts::kMuMatchLpt ) selectionMask \|= kBothMuMatchLpt;
	156	if ( maskAND & AliMuonTrackCuts::kMuMatchHpt ) selectionMask \|= kBothMuMatchHpt;
	157	if ( maskOR & AliMuonTrackCuts::kMuMatchApt ) selectionMask \|= kOneMuMatchApt;
	158	if ( maskOR & AliMuonTrackCuts::kMuMatchLpt ) selectionMask \|= kOneMuMatchLpt;
	159	if ( maskOR & AliMuonTrackCuts::kMuMatchHpt ) selectionMask \|= kOneMuMatchHpt;
	160
	161	TLorentzVector vec[2];
	162	Double_t chargeProduct = 1.;
	163	for ( Int_t itrack=0; itrack<2; ++itrack ) {
	164	const AliVParticle* track = static_cast<const AliVParticle*> ( ( itrack == 0 ) ? track1 : track2 );
	165	chargeProduct *= track->Charge();
	166	Double_t trackP = track->P();
	167	Double_t energy = TMath::Sqrt(trackP*trackP + MuonMass2());
	168	vec[itrack].SetPxPyPzE(track->Px(), track->Py(), track->Pz(), energy);
	169	}
	170
	171	if ( chargeProduct < 0. ) selectionMask \|= kDimuUnlikeSign;
	172
	173	TLorentzVector vecPair = vec[0] + vec[1];
	174	Double_t rapidity = vecPair.Rapidity();
	175	if ( rapidity > -4. && rapidity < -2.5 ) selectionMask \|= kDimuRapidity;
	176
	177	return selectionMask;
	178	}
	179
	180
	181	//_____________________________________________________________________________
	182	Double_t AliMuonPairCuts::MuonMass2() const
	183	{
	184	/// A usefull constant
76f86d1c	185	static Double_t m2 = 1.11636129640000012e-02;
64647ced	186	return m2;
	187	}
	188
	189
	190	//________________________________________________________________________
	191	void AliMuonPairCuts::SetDefaultFilterMask ()
	192	{
	193	/// Standard cuts for muon pair
	194	SetFilterMask ( kBothMuEta \| kBothMuThetaAbs \| kBothMuMatchLpt \| kDimuUnlikeSign \| kDimuRapidity );
	195	}
	196
	197	//________________________________________________________________________
	198	void AliMuonPairCuts::SetIsMC ( Bool_t isMC )
	199	{
	200	/// Set Is MC
	201	fMuonTrackCuts.SetIsMC(isMC);
	202	}
	203
ebba9ef0	204	//________________________________________________________________________
	205	Bool_t AliMuonPairCuts::TrackPtCutMatchTrigClass ( const AliVParticle* track1, const AliVParticle* track2, const TArrayI ptCutFromClass ) const
	206	{
	207	/// Check if track pair passes the trigger pt cut level used in the trigger class
	208	Bool_t matchTrig1 = fMuonTrackCuts.TrackPtCutMatchTrigClass(track1, ptCutFromClass);
	209	Bool_t matchTrig2 = fMuonTrackCuts.TrackPtCutMatchTrigClass(track2, ptCutFromClass);
	210
	211	Bool_t matchTrackerPt1 = kTRUE, matchTrackerPt2 = kTRUE;
	212	if ( IsApplySharpPtCutInMatching() ) {
68e9b988	213	matchTrackerPt1 = ( track1->Pt() >= fMuonTrackCuts.GetMuonTrackCutsParam().GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
68e9b988	214	matchTrackerPt2 = ( track2->Pt() >= fMuonTrackCuts.GetMuonTrackCutsParam().GetSharpPtCut(ptCutFromClass[0]-1,kFALSE) );
ebba9ef0	215	}
	216
	217	matchTrig1 = ( matchTrig1 && matchTrackerPt1 );
	218	matchTrig2 = ( matchTrig2 && matchTrackerPt2 );
	219
	220	Bool_t passCut = ( ptCutFromClass[1]>0 ) ? ( matchTrig1 && matchTrig2 ) : ( matchTrig1 \|\| matchTrig2 );
	221
	222	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));
	223	return passCut;
	224	}
	225
64647ced	226	//________________________________________________________________________
	227	void AliMuonPairCuts::Print(Option_t* option) const
	228	{
	229	//
	230	/// Print info
	231	//
	232
	233	TString sopt(option);
	234	sopt.ToLower();
76f86d1c	235	if ( sopt.IsNull() \|\| sopt.Contains("*") \|\| sopt.Contains("all") ) sopt += " pair trackparam trackmask";
64647ced	236	if ( sopt.Contains("pair") ) {
	237	UInt_t filterMask = GetFilterMask();
	238	printf(" * Muon pair filter mask: * \n");
	239	printf(" 0x%x\n", filterMask);
	240	if ( filterMask & kBothMuEta ) printf(" mu1 && mu2 pass eta cut\n");
	241	if ( filterMask & kBothMuThetaAbs ) printf(" mu1 && mu2 pass theta_abs cut\n");
	242	if ( filterMask & kBothMuPdca ) printf(" mu1 && mu2 pass pxDCA cut\n");
	243	if ( filterMask & kBothMuTrackChiSquare ) printf(" Chi2 cut on track\n");
	244	if ( filterMask & kBothMuMatchApt ) printf(" mu1 && mu2 match Apt\n");
	245	if ( filterMask & kBothMuMatchLpt ) printf(" mu1 && mu2 match Lpt\n");
	246	if ( filterMask & kBothMuMatchHpt ) printf(" mu1 && mu2 match Hpt\n");
89f8af70	247	if ( filterMask & kOneMuMatchApt ) printf(" mu1 \|\| mu2 match Apt\n");
	248	if ( filterMask & kOneMuMatchLpt ) printf(" mu1 \|\| mu2 match Lpt\n");
	249	if ( filterMask & kOneMuMatchHpt ) printf(" mu1 \|\| mu2 match Hpt\n");
64647ced	250	if ( filterMask & kDimuUnlikeSign ) printf(" Unlike sign\n");
	251	if ( filterMask & kDimuRapidity ) printf(" -4 < y_{mumu} < -2.5\n");
	252	printf(" ******************** \n");
	253	}
	254
	255	if ( sopt.Contains("track") )
	256	fMuonTrackCuts.Print(sopt.Data());
	257	}