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