]>
Commit | Line | Data |
---|---|---|
1b446896 | 1 | #include "AliHBTParticleCut.h" |
2 | ||
d0c23b58 | 3 | #include <Riostream.h> |
1b446896 | 4 | |
5 | ClassImp(AliHBTParticleCut) | |
6 | const Int_t AliHBTParticleCut::fkgMaxCuts = 50; | |
7 | /******************************************************************/ | |
8 | ||
9 | AliHBTParticleCut::AliHBTParticleCut() | |
10 | { | |
11 | fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property | |
12 | //property enum => defines number of properties | |
13 | fNCuts = 0; | |
14 | fPID = 0; | |
15 | } | |
16 | /******************************************************************/ | |
17 | ||
18 | AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in) | |
19 | { | |
20 | fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property | |
21 | //property enum => defines number of properties | |
22 | fNCuts = in.fNCuts; | |
23 | fPID = in.fPID; | |
24 | for (Int_t i = 0;i<fNCuts;i++) | |
25 | { | |
26 | fCuts[i] = (AliHbtBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it | |
27 | } | |
28 | } | |
29 | /******************************************************************/ | |
30 | ||
31 | AliHBTParticleCut::~AliHBTParticleCut() | |
32 | { | |
33 | for (Int_t i = 0;i<fNCuts;i++) | |
34 | { | |
35 | delete fCuts[i]; | |
36 | } | |
37 | delete []fCuts; | |
38 | } | |
39 | /******************************************************************/ | |
40 | ||
41 | Bool_t AliHBTParticleCut::Pass(AliHBTParticle* p) | |
42 | { | |
43 | //method checks all the cuts that are set (in the list) | |
44 | //If any of the baseCuts rejects particle False(rejection) is returned | |
45 | if(!p) | |
46 | { | |
47 | Warning("Pass()","No Pasaran! We never accept NULL pointers"); | |
48 | return kTRUE; | |
49 | } | |
50 | if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE; | |
51 | ||
52 | for (Int_t i = 0;i<fNCuts;i++) | |
53 | { | |
54 | if ( (fCuts[i]->Pass(p)) ) return kTRUE; //if one of the cuts rejects, then reject | |
55 | } | |
56 | return kFALSE; | |
57 | } | |
58 | /******************************************************************/ | |
59 | ||
60 | void AliHBTParticleCut::AddBasePartCut(AliHbtBaseCut* basecut) | |
61 | { | |
62 | //adds the base pair cut (cut on one value) | |
63 | ||
64 | if (!basecut) return; | |
65 | if( fNCuts == (fkgMaxCuts-1) ) | |
66 | { | |
67 | Warning("AddBasePartCut","Not enough place for another cut"); | |
68 | return; | |
69 | } | |
70 | fCuts[fNCuts++]=basecut; | |
71 | ||
72 | } | |
73 | ||
74 | /******************************************************************/ | |
75 | AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty property) | |
76 | { | |
77 | ||
78 | for (Int_t i = 0;i<fNCuts;i++) | |
79 | { | |
80 | if (fCuts[i]->GetProperty() == property) | |
81 | return fCuts[i]; //we found the cut we were searching for | |
82 | } | |
83 | ||
84 | return 0x0; //we did not found this cut | |
85 | ||
86 | } | |
87 | /******************************************************************/ | |
88 | ||
89 | void AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max) | |
90 | { | |
91 | AliHBTMomentumCut* cut= (AliHBTMomentumCut*)FindCut(kHbtP); | |
92 | if(cut) cut->SetRange(min,max); | |
93 | else fCuts[fNCuts++] = new AliHBTMomentumCut(min,max); | |
94 | } | |
95 | /******************************************************************/ | |
96 | ||
97 | ||
98 | void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max) | |
99 | { | |
100 | AliHBTPtCut* cut= (AliHBTPtCut*)FindCut(kHbtPt); | |
101 | if(cut) cut->SetRange(min,max); | |
102 | else fCuts[fNCuts++] = new AliHBTPtCut(min,max); | |
103 | ||
104 | } | |
105 | /******************************************************************/ | |
106 | ||
107 | void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max) | |
108 | { | |
109 | AliHBTEnergyCut* cut= (AliHBTEnergyCut*)FindCut(kHbtE); | |
110 | if(cut) cut->SetRange(min,max); | |
111 | else fCuts[fNCuts++] = new AliHBTEnergyCut(min,max); | |
112 | ||
113 | } | |
114 | /******************************************************************/ | |
115 | ||
116 | void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max) | |
117 | { | |
118 | AliHbtBaseCut* cut = FindCut(kHbtRapidity); | |
119 | if(cut) cut->SetRange(min,max); | |
120 | else fCuts[fNCuts++] = new AliHBTRapidityCut(min,max); | |
121 | ||
122 | } | |
123 | /******************************************************************/ | |
124 | ||
125 | void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max) | |
126 | { | |
127 | AliHbtBaseCut* cut = FindCut(kHbtPseudoRapidity); | |
128 | if(cut) cut->SetRange(min,max); | |
129 | else fCuts[fNCuts++] = new AliHBTPseudoRapidityCut(min,max); | |
130 | ||
131 | } | |
132 | /******************************************************************/ | |
133 | ||
134 | void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max) | |
135 | { | |
136 | AliHbtBaseCut* cut = FindCut(kHbtPx); | |
137 | if(cut) cut->SetRange(min,max); | |
138 | else fCuts[fNCuts++] = new AliHBTPxCut(min,max); | |
139 | } | |
140 | /******************************************************************/ | |
141 | ||
142 | void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max) | |
143 | { | |
144 | AliHbtBaseCut* cut = FindCut(kHbtPy); | |
145 | if(cut) cut->SetRange(min,max); | |
146 | else fCuts[fNCuts++] = new AliHBTPyCut(min,max); | |
147 | } | |
148 | /******************************************************************/ | |
149 | ||
150 | void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max) | |
151 | { | |
152 | AliHbtBaseCut* cut = FindCut(kHbtPz); | |
153 | if(cut) cut->SetRange(min,max); | |
154 | else fCuts[fNCuts++] = new AliHBTPzCut(min,max); | |
155 | } | |
156 | /******************************************************************/ | |
157 | ||
158 | void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max) | |
159 | { | |
160 | AliHbtBaseCut* cut = FindCut(kHbtPhi); | |
161 | if(cut) cut->SetRange(min,max); | |
162 | else fCuts[fNCuts++] = new AliHBTPhiCut(min,max); | |
163 | } | |
164 | /******************************************************************/ | |
165 | ||
166 | void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max) | |
167 | { | |
168 | AliHbtBaseCut* cut = FindCut(kHbtTheta); | |
169 | if(cut) cut->SetRange(min,max); | |
170 | else fCuts[fNCuts++] = new AliHBTThetaCut(min,max); | |
171 | } | |
172 | /******************************************************************/ | |
173 | ||
174 | void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max) | |
175 | { | |
176 | AliHbtBaseCut* cut = FindCut(kHbtVx); | |
177 | if(cut) cut->SetRange(min,max); | |
178 | else fCuts[fNCuts++] = new AliHBTVxCut(min,max); | |
179 | } | |
180 | /******************************************************************/ | |
181 | ||
182 | void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max) | |
183 | { | |
184 | AliHbtBaseCut* cut = FindCut(kHbtVy); | |
185 | if(cut) cut->SetRange(min,max); | |
186 | else fCuts[fNCuts++] = new AliHBTVyCut(min,max); | |
187 | } | |
188 | /******************************************************************/ | |
189 | ||
190 | void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max) | |
191 | { | |
192 | AliHbtBaseCut* cut = FindCut(kHbtVz); | |
193 | if(cut) cut->SetRange(min,max); | |
194 | else fCuts[fNCuts++] = new AliHBTVzCut(min,max); | |
195 | } | |
196 | ||
197 | /******************************************************************/ | |
198 | void AliHBTParticleCut::Streamer(TBuffer &b) | |
199 | { | |
200 | // Stream all objects in the array to or from the I/O buffer. | |
201 | ||
202 | UInt_t R__s, R__c; | |
203 | if (b.IsReading()) | |
204 | { | |
d0c23b58 | 205 | /* Version_t v = */ b.ReadVersion(&R__s, &R__c); |
1b446896 | 206 | TObject::Streamer(b); |
207 | b >> fPID; | |
208 | b >> fNCuts; | |
209 | for (Int_t i = 0;i<fNCuts;i++) | |
210 | { | |
211 | b >> fCuts[i]; | |
212 | } | |
213 | b.CheckByteCount(R__s, R__c,AliHBTParticleCut::IsA()); | |
214 | } | |
215 | else | |
216 | { | |
217 | R__c = b.WriteVersion(AliHBTParticleCut::IsA(), kTRUE); | |
218 | TObject::Streamer(b); | |
219 | b << fPID; | |
220 | b << fNCuts; | |
221 | for (Int_t i = 0;i<fNCuts;i++) | |
222 | { | |
223 | b << fCuts[i]; | |
224 | } | |
225 | b.SetByteCount(R__c, kTRUE); | |
226 | } | |
227 | } | |
228 | ||
229 | void AliHBTParticleCut::Print(void) | |
230 | { | |
231 | cout<<"Printing AliHBTParticleCut, this = "<<this<<endl; | |
232 | cout<<"fPID "<<fPID<<endl; | |
233 | cout<<"fNCuts "<<fNCuts <<endl; | |
234 | for (Int_t i = 0;i<fNCuts;i++) | |
235 | { | |
236 | cout<<" fCuts["<<i<<"] "<<fCuts[i]<<endl<<" "; | |
237 | fCuts[i]->Print(); | |
238 | } | |
239 | } | |
240 | ||
241 | /******************************************************************/ | |
242 | /******************************************************************/ | |
243 | ||
244 | ClassImp(AliHBTEmptyParticleCut) | |
245 | void AliHBTEmptyParticleCut::Streamer(TBuffer &b) | |
246 | { | |
247 | AliHBTParticleCut::Streamer(b); | |
248 | } | |
249 | /******************************************************************/ | |
250 | /******************************************************************/ | |
251 | /******************************************************************/ | |
252 | ||
253 | /******************************************************************/ | |
254 | /******************************************************************/ | |
255 | /******************************************************************/ | |
256 | ||
257 | ClassImp(AliHbtBaseCut) | |
258 | void AliHbtBaseCut::Print(void) | |
259 | { | |
260 | cout<<"fMin="<<fMin <<", fMax=" <<fMax<<" "; | |
261 | PrintProperty(); | |
262 | } | |
263 | void AliHbtBaseCut::PrintProperty(void) | |
264 | { | |
265 | switch (fProperty) | |
266 | { | |
267 | case kHbtP: | |
268 | cout<<"kHbtP"; break; | |
269 | case kHbtPt: | |
270 | cout<<"kHbtPt"; break; | |
271 | case kHbtE: | |
272 | cout<<"kHbtE"; break; | |
273 | case kHbtRapidity: | |
274 | cout<<"kHbtRapidity"; break; | |
275 | case kHbtPseudoRapidity: | |
276 | cout<<"kHbtPseudoRapidity"; break; | |
277 | case kHbtPx: | |
278 | cout<<"kHbtPx"; break; | |
279 | case kHbtPy: | |
280 | cout<<"kHbtPy"; break; | |
281 | case kHbtPz: | |
282 | cout<<"kHbtPz"; break; | |
283 | case kHbtPhi: | |
284 | cout<<"kHbtPhi"; break; | |
285 | case kHbtTheta: | |
286 | cout<<"kHbtTheta"; break; | |
287 | case kHbtVx: | |
288 | cout<<"kHbtVx"; break; | |
289 | case kHbtVy: | |
290 | cout<<"kHbtVy"; break; | |
291 | case kHbtVz: | |
292 | cout<<"kHbtVz"; break; | |
293 | case kHbtNone: | |
294 | cout<<"kHbtNone"; break; | |
295 | default: | |
296 | cout<<"Property Not Found"; | |
297 | } | |
298 | cout<<endl; | |
299 | } | |
300 | ClassImp( AliHBTMomentumCut ) | |
301 | ||
302 | ClassImp( AliHBTPtCut ) | |
303 | ClassImp( AliHBTEnergyCut ) | |
304 | ClassImp( AliHBTRapidityCut ) | |
305 | ClassImp( AliHBTPseudoRapidityCut ) | |
306 | ClassImp( AliHBTPxCut ) | |
307 | ClassImp( AliHBTPyCut ) | |
308 | ClassImp( AliHBTPzCut ) | |
309 | ClassImp( AliHBTPhiCut ) | |
310 | ClassImp( AliHBTThetaCut ) | |
311 | ClassImp( AliHBTVxCut ) | |
312 | ClassImp( AliHBTVyCut ) | |
313 | ClassImp( AliHBTVzCut ) | |
314 | ||
315 |