[u/mrichter/AliRoot.git] / ANALYSIS / AliAODPairBaseCut.cxx

#include "AliAODPairBaseCut.h"

#include "AliTrackPoints.h"
#include "AliClusterMap.h"


ClassImp(AliAODPairBaseCut)
ClassImp(AliAODQInvCut)
ClassImp(AliAODKtCut)
ClassImp(AliAODQSideLCMSCut)
ClassImp(AliAODQOutLCMSCut)
ClassImp(AliAODQLongLCMSCut)

/******************************************************************/
ClassImp(AliAODAvSeparationCut)
    
Double_t AliAODAvSeparationCut::GetValue(AliAODPair* pair) const 
{
  //chacks if avarage distance of two tracks is in given range
  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
  if ( tpts1 == 0x0)
   {//it could be simulated pair
//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
     return -1.0;
   }

  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
  if ( tpts2 == 0x0)
   {
//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
     return -1.0;
   }
   
  return tpts1->AvarageDistance(*tpts2);
}
/******************************************************************/
ClassImp(AliAODSeparationCut)
    
Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const 
{
  //chacks if avarage distance of two tracks is in given range
  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
  if ( tpts1 == 0x0)
   {//it could be simulated pair
//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
     return -1.0;
   }

  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
  if ( tpts2 == 0x0)
   {
//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
     return -1.0;
   }
  Float_t x1=0,y1=0,z1=0; 
  Float_t x2=0,y2=0,z2=0;
  
  tpts1->PositionAt(fPoint,x1,y1,z1);
  tpts2->PositionAt(fPoint,x2,y2,z2);
  Double_t dx1 = x1 - x2;
  Double_t dy1 = y1 - y2;
  Double_t dz1 = z1 - z2;
  Double_t d = TMath::Sqrt(dx1*dx1 + dy1*dy1 + dz1*dz1);
  return d;
}
/******************************************************************/

ClassImp(AliAODITSSeparationCut)

Bool_t AliAODITSSeparationCut::Rejected(AliAODPair* pair) const
{
 //Checks if two tracks do not cross first pixels too close to each other
 //If two tracks use the same cluster in pixels they are given
 //the same position what skews theta angles (both are the same)
 //These guys create artificial correlation in non-id analyses
 //which is positive for identical polar angles (Qlong=0) 
 //and negative for a little bit different theta angle (Qlong=epsilon)
 //Such tracks "attracks" each other.
 
  AliTrackPoints* tpts1 = pair->Particle1()->GetITSTrackPoints();
  if ( tpts1 == 0x0)
   {//it could be simulated pair
     Warning("Pass","Track 1 does not have ITS Track Points. Pair NOT Passed.");
     return kTRUE;//reject 
   }

  AliTrackPoints* tpts2 = pair->Particle2()->GetITSTrackPoints();
  if ( tpts2 == 0x0)
   {
     Warning("Pass","Track 2 does not have ITS Track Points. Pair NOT Passed.");
     return kTRUE;//reject 
   }
  Float_t  x1=0.0,y1=0.0,z1=0.0,x2=0.0,y2=0.0,z2=0.0;
  tpts1->PositionAt(fLayer,x1,y1,z1);
  tpts2->PositionAt(fLayer,x2,y2,z2);
  
//  Info("Pass","rphi %f z %f",fMin,fMax);
//  Info("Pass","P1: %f %f %f", x1,y1,z1);
//  Info("Pass","P2: %f %f %f", x2,y2,z2);
  
  Double_t dz = TMath::Abs(z1-z2);
  
  //fMax encodes treshold valaue of distance in Z
  if (dz > fMax) return kFALSE;//pair accepted
  
  Double_t drphi = TMath::Hypot(x1-x2,y1-y2);
  
  //fMin encodes treshold valaue of distance in r-phi
  if (drphi > fMin) return kFALSE;
  
  return kTRUE;//they are too close, rejected
}
/******************************************************************/

ClassImp(AliAODCluterOverlapCut)

Double_t  AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
{
  //Returns Cluter Overlap Factor
  //It ranges between -0.5 (in all padrows both tracks have cluters) 
  // and 1 (in all padrows one track has cluter and second has not)
  // When Overlap Factor is 1 this pair of tracks in highly probable to be
  // splitted track: one particle that is recontructed twise

  AliClusterMap* cm1 = pair->Particle1()->GetClusterMap();
  if ( cm1 == 0x0)
   {
     Warning("GetValue","Track 1 does not have Cluster Map. Returning -0.5.");
     return -.5;
   }

  AliClusterMap* cm2 = pair->Particle2()->GetClusterMap();
  if ( cm2 == 0x0)
   {
     Warning("GetValue","Track 2 does not have Cluster Map. Returning -0.5.");
     return -.5;
   }
  return cm1->GetOverlapFactor(*cm2);
}
/******************************************************************/
ClassImp(AliAODOutSideSameSignCut)

Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
{
  //returns kTRUE if pair DO NOT meet cut criteria
  
  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
   {
     return kFALSE;//accpeted
   }

  return kTRUE ;//rejected
}
/******************************************************************/
ClassImp(AliAODOutSideDiffSignCut)

Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
{
  //returns kTRUE if pair DO NOT meet cut criteria
  
  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
   {
     return kTRUE;//rejected
   }
  
  return kFALSE;//accepted
}
/******************************************************************/
ClassImp( AliAODLogicalOperPairCut )

AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
 AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
 fFirst(new AliAODDummyBasePairCut),
 fSecond(new AliAODDummyBasePairCut)
{
 //ctor
}
/******************************************************************/

AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):
 AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
 fFirst((first)?(AliAODPairBaseCut*)first->Clone():0x0),
 fSecond((second)?(AliAODPairBaseCut*)second->Clone():0x0)
{
  //ctor
  //note that base cuts are copied, not just pointers assigned
  if ( (fFirst && fSecond) == kFALSE) 
   {
     Fatal("AliAODLogicalOperPairCut","One of parameters is NULL!");
   }
}
/******************************************************************/

AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
{
  //destructor
  delete fFirst;
  delete fSecond;
}
/******************************************************************/

Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Rejected(AliAODPair* /*pair*/)  const
{
  //checks if particles passes properties defined by this cut
  Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
  return kFALSE;//accept
}
/******************************************************************/

void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
{
  // Stream all objects in the array to or from the I/O buffer.
  UInt_t R__s, R__c;
  if (b.IsReading()) 
   {
     delete fFirst;
     delete fSecond;
     fFirst  = 0x0;
     fSecond = 0x0;

     b.ReadVersion(&R__s, &R__c);
     TObject::Streamer(b);
     b >> fFirst;
     b >> fSecond;
     b.CheckByteCount(R__s, R__c,AliAODLogicalOperPairCut::IsA());
   } 
  else 
   {
     R__c = b.WriteVersion(AliAODLogicalOperPairCut::IsA(), kTRUE);
     TObject::Streamer(b);
     b << fFirst;
     b << fSecond;
     b.SetByteCount(R__c, kTRUE);
  }
}

/******************************************************************/
ClassImp(AliAODOrPairCut)

Bool_t AliAODOrPairCut::Rejected(AliAODPair * p) const
{
  //returns true when rejected 
  //AND operation is a little bit misleading but is correct
  //User wants to build logical cuts with natural (positive) logic
  //while ALIAN use inernally reverse (returns true when rejected)
  if (fFirst->Rejected(p) && fSecond->Rejected(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
  return kFALSE;//accepted, at least one accepted (returned kFALSE)
}
/******************************************************************/

ClassImp(AliAODAndPairCut)

Bool_t AliAODAndPairCut::Rejected(AliAODPair * p)  const
{
  //returns true when rejected 
  //OR operation is a little bit misleading but is correct
  //User wants to build logical cuts with natural (positive) logic
  //while ALIAN use inernally reverse (returns true when rejected)
  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
  return kFALSE;//accepted (both accepted (returned kFALSE))
}
/******************************************************************/
Commit	Line	Data
073745bc	1	#include "AliAODPairBaseCut.h"
	2
	3	#include "AliTrackPoints.h"
	4	#include "AliClusterMap.h"
	5
	6
	7	ClassImp(AliAODPairBaseCut)
	8	ClassImp(AliAODQInvCut)
	9	ClassImp(AliAODKtCut)
	10	ClassImp(AliAODQSideLCMSCut)
	11	ClassImp(AliAODQOutLCMSCut)
	12	ClassImp(AliAODQLongLCMSCut)
	13
	14	/******************************************************************/
	15	ClassImp(AliAODAvSeparationCut)
	16
	17	Double_t AliAODAvSeparationCut::GetValue(AliAODPair* pair) const
	18	{
	19	//chacks if avarage distance of two tracks is in given range
	20	AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
	21	if ( tpts1 == 0x0)
	22	{//it could be simulated pair
	23	// Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
	24	return -1.0;
	25	}
	26
	27	AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
	28	if ( tpts2 == 0x0)
	29	{
	30	// Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
	31	return -1.0;
	32	}
	33
	34	return tpts1->AvarageDistance(*tpts2);
	35	}
	36	/******************************************************************/
	37	ClassImp(AliAODSeparationCut)
	38
	39	Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const
	40	{
	41	//chacks if avarage distance of two tracks is in given range
	42	AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
	43	if ( tpts1 == 0x0)
	44	{//it could be simulated pair
	45	// Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
	46	return -1.0;
	47	}
	48
	49	AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
	50	if ( tpts2 == 0x0)
	51	{
	52	// Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
	53	return -1.0;
	54	}
	55	Float_t x1=0,y1=0,z1=0;
	56	Float_t x2=0,y2=0,z2=0;
	57
	58	tpts1->PositionAt(fPoint,x1,y1,z1);
	59	tpts2->PositionAt(fPoint,x2,y2,z2);
	60	Double_t dx1 = x1 - x2;
	61	Double_t dy1 = y1 - y2;
	62	Double_t dz1 = z1 - z2;
	63	Double_t d = TMath::Sqrt(dx1dx1 + dy1dy1 + dz1*dz1);
	64	return d;
65	}
66	/******************************************************************/
67
68	ClassImp(AliAODITSSeparationCut)
69
70	Bool_t AliAODITSSeparationCut::Rejected(AliAODPair* pair) const
71	{
72	//Checks if two tracks do not cross first pixels too close to each other
73	//If two tracks use the same cluster in pixels they are given
74	//the same position what skews theta angles (both are the same)
75	//These guys create artificial correlation in non-id analyses
76	//which is positive for identical polar angles (Qlong=0)
77	//and negative for a little bit different theta angle (Qlong=epsilon)
78	//Such tracks "attracks" each other.
79
80	AliTrackPoints* tpts1 = pair->Particle1()->GetITSTrackPoints();
81	if ( tpts1 == 0x0)
82	{//it could be simulated pair
83	Warning("Pass","Track 1 does not have ITS Track Points. Pair NOT Passed.");
84	return kTRUE;//reject
85	}
86
87	AliTrackPoints* tpts2 = pair->Particle2()->GetITSTrackPoints();
88	if ( tpts2 == 0x0)
89	{
90	Warning("Pass","Track 2 does not have ITS Track Points. Pair NOT Passed.");
91	return kTRUE;//reject
92	}
93	Float_t x1=0.0,y1=0.0,z1=0.0,x2=0.0,y2=0.0,z2=0.0;
94	tpts1->PositionAt(fLayer,x1,y1,z1);
95	tpts2->PositionAt(fLayer,x2,y2,z2);
96
97	// Info("Pass","rphi %f z %f",fMin,fMax);
98	// Info("Pass","P1: %f %f %f", x1,y1,z1);
99	// Info("Pass","P2: %f %f %f", x2,y2,z2);
100
101	Double_t dz = TMath::Abs(z1-z2);
102
103	//fMax encodes treshold valaue of distance in Z
104	if (dz > fMax) return kFALSE;//pair accepted
105
106	Double_t drphi = TMath::Hypot(x1-x2,y1-y2);
107
108	//fMin encodes treshold valaue of distance in r-phi
109	if (drphi > fMin) return kFALSE;
110
111	return kTRUE;//they are too close, rejected
112	}
113	/******************************************************************/
114
115	ClassImp(AliAODCluterOverlapCut)
116
117	Double_t AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
118	{
119	//Returns Cluter Overlap Factor
120	//It ranges between -0.5 (in all padrows both tracks have cluters)
121	// and 1 (in all padrows one track has cluter and second has not)
122	// When Overlap Factor is 1 this pair of tracks in highly probable to be
123	// splitted track: one particle that is recontructed twise
124
125	AliClusterMap* cm1 = pair->Particle1()->GetClusterMap();
126	if ( cm1 == 0x0)
127	{
128	Warning("GetValue","Track 1 does not have Cluster Map. Returning -0.5.");
129	return -.5;
130	}
131
132	AliClusterMap* cm2 = pair->Particle2()->GetClusterMap();
133	if ( cm2 == 0x0)
134	{
135	Warning("GetValue","Track 2 does not have Cluster Map. Returning -0.5.");
136	return -.5;
137	}
138	return cm1->GetOverlapFactor(*cm2);
139	}
140	/******************************************************************/
141	ClassImp(AliAODOutSideSameSignCut)
142
143	Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
144	{
145	//returns kTRUE if pair DO NOT meet cut criteria
146
147	if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 )
148	{
149	return kFALSE;//accpeted
150	}
151
152	return kTRUE ;//rejected
153	}
154	/******************************************************************/
155	ClassImp(AliAODOutSideDiffSignCut)
156
157	Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
158	{
159	//returns kTRUE if pair DO NOT meet cut criteria
160
161	if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 )
162	{
163	return kTRUE;//rejected
164	}
165
166	return kFALSE;//accepted
167	}
168	/******************************************************************/
169	ClassImp( AliAODLogicalOperPairCut )
170
171	AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
172	AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
173	fFirst(new AliAODDummyBasePairCut),
174	fSecond(new AliAODDummyBasePairCut)
175	{
176	//ctor
177	}
178	/******************************************************************/
179
180	AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):
181	AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
182	fFirst((first)?(AliAODPairBaseCut*)first->Clone():0x0),
183	fSecond((second)?(AliAODPairBaseCut*)second->Clone():0x0)
184	{
185	//ctor
186	//note that base cuts are copied, not just pointers assigned
187	if ( (fFirst && fSecond) == kFALSE)
188	{
189	Fatal("AliAODLogicalOperPairCut","One of parameters is NULL!");
190	}
191	}
192	/******************************************************************/
193
194	AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
195	{
196	//destructor
197	delete fFirst;
198	delete fSecond;
199	}
200	/******************************************************************/
201
202	Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Rejected(AliAODPair* /pair/) const
203	{
204	//checks if particles passes properties defined by this cut
205	Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
206	return kFALSE;//accept
207	}
208	/******************************************************************/
209
210	void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
211	{
212	// Stream all objects in the array to or from the I/O buffer.
213	UInt_t R__s, R__c;
214	if (b.IsReading())
215	{
216	delete fFirst;
217	delete fSecond;
218	fFirst = 0x0;
219	fSecond = 0x0;
220
221	b.ReadVersion(&R__s, &R__c);
222	TObject::Streamer(b);
223	b >> fFirst;
224	b >> fSecond;
225	b.CheckByteCount(R__s, R__c,AliAODLogicalOperPairCut::IsA());
226	}
227	else
228	{
229	R__c = b.WriteVersion(AliAODLogicalOperPairCut::IsA(), kTRUE);
230	TObject::Streamer(b);
231	b << fFirst;
232	b << fSecond;
233	b.SetByteCount(R__c, kTRUE);
234	}
235	}
236
237	/******************************************************************/
238	ClassImp(AliAODOrPairCut)
239
240	Bool_t AliAODOrPairCut::Rejected(AliAODPair * p) const
241	{
242	//returns true when rejected
243	//AND operation is a little bit misleading but is correct
244	//User wants to build logical cuts with natural (positive) logic
245	//while ALIAN use inernally reverse (returns true when rejected)
246	if (fFirst->Rejected(p) && fSecond->Rejected(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
247	return kFALSE;//accepted, at least one accepted (returned kFALSE)
248	}
249	/******************************************************************/
250
251	ClassImp(AliAODAndPairCut)
252
253	Bool_t AliAODAndPairCut::Rejected(AliAODPair * p) const
254	{
255	//returns true when rejected
256	//OR operation is a little bit misleading but is correct
257	//User wants to build logical cuts with natural (positive) logic
258	//while ALIAN use inernally reverse (returns true when rejected)
259	if (fFirst->Rejected(p) \|\| fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
260	return kFALSE;//accepted (both accepted (returned kFALSE))
261	}
262	/******************************************************************/