f72c7a88d209e0da0cf76da0ad75911393e79206
[u/mrichter/AliRoot.git] / HBTAN / AliHBTPairCut.cxx
1 /* $Id$ */
2
3 //-------------------------------------------------------------------
4 // Class AliHBTPairCut:
5 // implements cut on the pair of particles
6 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
7 // Author: Piotr.Skowronski@cern.ch
8 //-------------------------------------------------------------------
9
10 #include "AliHBTPairCut.h"
11 #include "AliHBTPair.h"
12 #include "AliHBTParticleCut.h"
13
14 ClassImp(AliHBTPairCut)
15 const Int_t AliHBTPairCut::fgkMaxCuts = 50;
16 /**********************************************************/
17
18 AliHBTPairCut::AliHBTPairCut():
19   fNCuts(0)
20 {
21   //constructor
22   fFirstPartCut = new AliHBTEmptyParticleCut(); //empty cuts
23   fSecondPartCut= new AliHBTEmptyParticleCut(); //empty cuts
24     
25   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
26 }
27 /**********************************************************/
28
29 AliHBTPairCut::AliHBTPairCut(const AliHBTPairCut& in):
30  TNamed(in)
31 {
32   //copy constructor
33   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
34   fNCuts = in.fNCuts;
35
36   fFirstPartCut = (AliHBTParticleCut*)in.fFirstPartCut->Clone();
37   fSecondPartCut = (AliHBTParticleCut*)in.fSecondPartCut->Clone();
38  
39   for (Int_t i = 0;i<fNCuts;i++)
40     {
41       fCuts[i] = (AliHbtBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
42     }
43 }
44 /**********************************************************/
45
46 AliHBTPairCut&  AliHBTPairCut::operator=(const AliHBTPairCut& in)
47 {
48   //assignment operator
49   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
50   fNCuts = in.fNCuts;
51
52   fFirstPartCut = (AliHBTParticleCut*)in.fFirstPartCut->Clone();
53   fSecondPartCut = (AliHBTParticleCut*)in.fSecondPartCut->Clone();
54  
55   for (Int_t i = 0;i<fNCuts;i++)
56     {
57       fCuts[i] = (AliHbtBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
58     }
59   return * this;
60 }
61 /**********************************************************/
62
63 AliHBTPairCut::~AliHBTPairCut()
64 {
65   //destructor
66   if (fFirstPartCut != fSecondPartCut)
67     {
68       delete fSecondPartCut;
69     }
70   delete fFirstPartCut;
71   for (Int_t i = 0;i<fNCuts;i++)
72     {
73       delete fCuts[i];
74     }
75   delete []fCuts;
76
77 /**********************************************************/
78
79 /**********************************************************/
80
81 void AliHBTPairCut::AddBasePairCut(AliHbtBasePairCut* basecut)
82 {
83   //adds the base pair cut (cut on one value)
84   
85   if (!basecut) return;
86   if( fNCuts == (fgkMaxCuts-1) )
87     {
88       Warning("AddBasePairCut","Not enough place for another cut");
89       return;
90     }
91   fCuts[fNCuts++]=basecut;
92 }
93 /**********************************************************/
94
95 Bool_t AliHBTPairCut::Pass(AliHBTPair* pair) const
96 {
97   //methods which checks if given pair meets all criteria of the cut
98   //if it meets returns FALSE
99   //if NOT   returns    TRUE
100   if(!pair) 
101     {
102       Warning("Pass","No Pasaran! We never accept NULL pointers");
103       return kTRUE;
104     }
105   
106   //check particle's cuts
107   if( ( fFirstPartCut->Pass( pair->Particle1()) ) || 
108       ( fSecondPartCut->Pass(pair->Particle2()) )   )
109     {  
110       return kTRUE;
111     }
112   return PassPairProp(pair);
113 }
114 /**********************************************************/
115
116 Bool_t AliHBTPairCut::PassPairProp(AliHBTPair* pair) const
117 {
118   //methods which checks if given pair meets all criteria of the cut
119   //if it meets returns FALSE
120   //if NOT   returns    TRUE
121   //examine all base pair cuts
122   for (Int_t i = 0;i<fNCuts;i++)
123     {
124       if ( (fCuts[i]->Pass(pair)) ) return kTRUE; //if one of the cuts reject, then reject
125     }
126   return kFALSE;
127 }
128 /**********************************************************/
129
130 void AliHBTPairCut::SetFirstPartCut(AliHBTParticleCut* cut)
131 {
132   // set cut for the first particle
133   if(!cut) 
134     {
135       Error("SetFirstPartCut","argument is NULL");
136       return;
137     }
138   delete fFirstPartCut;
139   fFirstPartCut = (AliHBTParticleCut*)cut->Clone();
140   
141 }
142 /**********************************************************/
143
144 void AliHBTPairCut::SetSecondPartCut(AliHBTParticleCut* cut)
145 {
146   // set cut for the second particle
147   if(!cut) 
148     {
149       Error("SetSecondPartCut","argument is NULL");
150       return;
151     }
152   delete fSecondPartCut;
153   fSecondPartCut = (AliHBTParticleCut*)cut->Clone();
154 }
155 /**********************************************************/
156
157 void AliHBTPairCut::SetPartCut(AliHBTParticleCut* cut)
158 {
159   //sets the the same cut on both particles
160   if(!cut) 
161     {
162       Error("SetFirstPartCut","argument is NULL");
163       return;
164     }
165   if (fFirstPartCut == fSecondPartCut) fSecondPartCut = 0x0;
166   
167   delete fFirstPartCut;
168   fFirstPartCut = (AliHBTParticleCut*)cut->Clone();
169   
170   delete fSecondPartCut; //even if null should not be harmful
171   fSecondPartCut = fFirstPartCut;
172 }
173 /**********************************************************/
174
175 void AliHBTPairCut::SetQInvRange(Double_t min, Double_t max)
176 {
177   // set range of accepted invariant masses
178   AliHBTQInvCut* cut= (AliHBTQInvCut*)FindCut(kHbtPairCutPropQInv);
179   if(cut) cut->SetRange(min,max);
180   else fCuts[fNCuts++] = new AliHBTQInvCut(min,max);
181 }
182 /**********************************************************/
183 void AliHBTPairCut::SetQOutCMSLRange(Double_t min, Double_t max)
184 {
185   // set range of accepted QOut in CMS
186   AliHBTQOutCMSLCCut* cut= (AliHBTQOutCMSLCCut*)FindCut(kHbtPairCutPropQOutCMSLC);
187   if(cut) cut->SetRange(min,max);
188   else fCuts[fNCuts++] = new AliHBTQOutCMSLCCut(min,max);
189 }
190
191 /**********************************************************/
192 void AliHBTPairCut::SetQSideCMSLRange(Double_t min, Double_t max)
193 {
194   // set range of accepted QSide in CMS
195   AliHBTQSideCMSLCCut* cut= (AliHBTQSideCMSLCCut*)FindCut(kHbtPairCutPropQSideCMSLC);
196   if(cut) cut->SetRange(min,max);
197   else fCuts[fNCuts++] = new AliHBTQSideCMSLCCut(min,max);
198 }
199
200 /**********************************************************/
201 void AliHBTPairCut::SetQLongCMSLRange(Double_t min, Double_t max)
202 {
203   // set range of accepted QLong in CMS
204   AliHBTQLongCMSLCCut* cut= (AliHBTQLongCMSLCCut*)FindCut(kHbtPairCutPropQLongCMSLC);
205   if(cut) cut->SetRange(min,max);
206   else fCuts[fNCuts++] = new AliHBTQLongCMSLCCut(min,max);
207 }
208
209 /**********************************************************/
210
211 void AliHBTPairCut::SetKtRange(Double_t min, Double_t max)
212 {
213   // set range of accepted Kt (?)
214   AliHBTKtCut* cut= (AliHBTKtCut*)FindCut(kHbtPairCutPropKt);
215   if(cut) cut->SetRange(min,max);
216   else fCuts[fNCuts++] = new AliHBTKtCut(min,max);
217 }
218 /**********************************************************/
219
220 void AliHBTPairCut::SetKStarRange(Double_t min, Double_t max)
221 {
222   // set range of accepted KStar (?)
223   AliHBTKStarCut* cut= (AliHBTKStarCut*)FindCut(kHbtPairCutPropKStar);
224   if(cut) cut->SetRange(min,max);
225   else fCuts[fNCuts++] = new AliHBTKStarCut(min,max);
226 }
227 /**********************************************************/
228
229 AliHbtBasePairCut* AliHBTPairCut::FindCut(AliHBTPairCutProperty property)
230 {
231   // Find the cut corresponding to "property"
232   for (Int_t i = 0;i<fNCuts;i++)
233     {
234       if (fCuts[i]->GetProperty() == property) 
235         return fCuts[i]; //we found the cut we were searching for
236     }
237   
238   return 0x0; //we did not found this cut
239   
240 }
241 /**********************************************************/
242
243 void AliHBTPairCut::Streamer(TBuffer &b)
244 {
245   // Stream all objects in the array to or from the I/O buffer.
246   
247   UInt_t R__s, R__c;
248   if (b.IsReading()) 
249     {
250       Version_t v = b.ReadVersion(&R__s, &R__c);
251       if (v > -1)
252        {
253           delete fFirstPartCut;
254           delete fSecondPartCut;
255           fFirstPartCut = 0x0;
256           fSecondPartCut = 0x0;
257           TObject::Streamer(b);
258           b >> fFirstPartCut;
259           b >> fSecondPartCut;
260           b >> fNCuts;
261           for (Int_t i = 0;i<fNCuts;i++)
262            {
263              b >> fCuts[i];
264            }
265         }
266       b.CheckByteCount(R__s, R__c,AliHBTPairCut::IsA());
267     } 
268   else 
269     {
270       R__c = b.WriteVersion(AliHBTPairCut::IsA(), kTRUE);
271       TObject::Streamer(b);
272       
273 //      printf("Streamer Cut 1 %#x Cut 2 %#x\n",fFirstPartCut,fSecondPartCut);
274 //      this->Dump();
275 //      fFirstPartCut->Dump();
276       
277       b << fFirstPartCut;
278       b << fSecondPartCut;
279       b << fNCuts;
280       for (Int_t i = 0;i<fNCuts;i++)
281         {
282           b << fCuts[i];
283         }
284       b.SetByteCount(R__c, kTRUE);
285     }
286 }
287
288 ClassImp(AliHBTEmptyPairCut)
289   
290 void AliHBTEmptyPairCut::Streamer(TBuffer &b)
291 {
292 //streamer for empty pair cut
293   AliHBTPairCut::Streamer(b);
294 }
295
296 ClassImp(AliHbtBasePairCut)
297 ClassImp(AliHBTQInvCut)
298 ClassImp(AliHBTKtCut)
299 ClassImp(AliHBTQSideCMSLCCut)
300 ClassImp(AliHBTQOutCMSLCCut)
301 ClassImp(AliHBTQLongCMSLCCut)