Added preprocessor conditionals to support ROOT > 5.11.2.
[u/mrichter/AliRoot.git] / HBTAN / AliHBTAnalysisStavinskyMixing.cxx
CommitLineData
b74dff53 1#include "AliHBTAnalysisStavinskyMixing.h"
2//_________________________________________________________
3////////////////////////////////////////////////////////////////////////////
4//
5// class AliHBTAnalysisStavinskyMixing
6//
7// Central Object Of HBTAnalyser:
8// This class performs main looping within HBT Analysis
9// User must plug a reader of Type AliReader
10// User plugs in coorelation and monitor functions
11// as well as monitor functions
12//
13// HBT Analysis Tool, which is integral part of AliRoot,
14// ALICE Off-Line framework:
15//
16// Piotr.Skowronski@cern.ch
c7ffd78f 17// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
b74dff53 18//
19////////////////////////////////////////////////////////////////////////////
20//_________________________________________________________
21
22
23#include <TSystem.h>
24#include <TFile.h>
25
26#include "AliAOD.h"
27#include "AliAODParticle.h"
28#include "AliAODPairCut.h"
29#include "AliEventCut.h"
30
31#include "AliEventBuffer.h"
32
33#include "AliReader.h"
34#include "AliHBTPair.h"
35#include "AliHBTFunction.h"
36#include "AliHBTMonitorFunction.h"
37
38
39ClassImp(AliHBTAnalysisStavinskyMixing)
40
41
42Int_t AliHBTAnalysisStavinskyMixing::ProcessRecAndSim(AliAOD* aodrec, AliAOD* aodsim)
43{
44//Does analysis for both tracks and particles
45//mainly for resolution study and analysies with weighting algirithms
46
47// cut on particles only -- why?
48// - PID: when we make resolution analysis we want to take only tracks with correct PID
49// We need cut on tracks because there are data characteristic
50
51 AliVAODParticle * part1, * part2;
52 AliVAODParticle * track1, * track2;
53
54 AliAOD * trackEvent = aodrec, *partEvent = aodsim;
55 AliAOD* trackEvent1 = new AliAOD();
56 AliAOD* partEvent1 = new AliAOD();
57
b74dff53 58
59// Int_t N1, N2, N=0; //number of particles in current event(we prcess two events in one time)
60
61// Int_t nev = fReader->GetNumberOfTrackEvents();
62 static AliHBTPair tpair;
63 static AliHBTPair ppair;
64
65 AliHBTPair* trackpair = &tpair;
66 AliHBTPair* partpair = &ppair;
67
68 AliHBTPair * tmptrackpair;//temprary pointers to pairs
69 AliHBTPair * tmppartpair;
70
71 register UInt_t ii;
72
73
74
75 if ( !partEvent || !trackEvent )
76 {
77 Error("ProcessRecAndSim","<<%s>> Can not get event",GetName());
78 return 1;
79 }
80
81 if ( partEvent->GetNumberOfParticles() != trackEvent->GetNumberOfParticles() )
82 {
83 Error("ProcessRecAndSim",
84 "Number of simulated particles (%d) not equal to number of reconstructed tracks (%d). Skipping Event.",
85 partEvent->GetNumberOfParticles() , trackEvent->GetNumberOfParticles());
86 return 2;
87 }
88
89
90 for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
91 {
92 /***************************************/
93 /****** Looping same events ********/
94 /****** filling numerators ********/
95 /***************************************/
96 if ( (j%fDisplayMixingInfo) == 0)
97 Info("ProcessTracksAndParticles",
98 "Mixing particle %d with particles from the same event",j);
99
100 part1= partEvent->GetParticle(j);
101 track1= trackEvent->GetParticle(j);
102
103 Bool_t firstcut = (this->*fkPass1)(part1,track1);
104 if (fBufferSize != 0)
105 if ( (firstcut == kFALSE) || ( (this->*fkPass2)(part1,track1) == kFALSE ) )
106 {
107 //accepted by any cut
108 // we have to copy because reader keeps only one event
109
110 partEvent1->AddParticle(part1);
111 trackEvent1->AddParticle(track1);
112 }
113
114 if (firstcut) continue;
115
116 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
117 fParticleMonitorFunctions[ii]->Process(part1);
118 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
119 fTrackMonitorFunctions[ii]->Process(track1);
120 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
121 fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
122
123 if (fNoCorrfctns) continue;
124
125 for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
126 {
127 part2= partEvent->GetParticle(k);
128 if (part1->GetUID() == part2->GetUID()) continue;
129 partpair->SetParticles(part1,part2);
130
131 track2= trackEvent->GetParticle(k);
132 trackpair->SetParticles(track1,track2);
133
134 if( (this->*fkPass)(partpair,trackpair) ) //check pair cut
135 { //do not meets crietria of the pair cut, try with swapped pairs
136 if( (this->*fkPass)((AliHBTPair*)partpair->GetSwappedPair(),(AliHBTPair*)trackpair->GetSwappedPair()) )
137 continue; //swaped pairs do not meet criteria of pair cut as well, take next particle
138 else
139 { //swaped pair meets all the criteria
140 tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
141 tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
142 }
143 }
144 else
145 {//meets criteria of the pair cut
146 tmptrackpair = trackpair;
147 tmppartpair = partpair;
148 }
149
150 for(ii = 0;ii<fNParticleFunctions;ii++)
151 fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
152
153 for(ii = 0;ii<fNTrackFunctions;ii++)
154 fTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
155
156 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
157 fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair,tmppartpair);
158
159
160 /***************************************/
161 /***** Filling denominators *********/
162 /***************************************/
163
164 tmppartpair->MirrorSecond();
165 tmptrackpair->MirrorSecond();
166
167 if((this->*fkPass)(tmppartpair,tmptrackpair) == kFALSE)
168 {
169 for(ii = 0;ii<fNParticleFunctions;ii++)
170 fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
171
172 for(ii = 0;ii<fNTrackFunctions;ii++)
173 fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
174
175 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
176 fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair,tmppartpair);
177
178 }
179
180 tmppartpair->DeleteSecond();
181 tmptrackpair->DeleteSecond();
182
183 //end of 2nd loop over particles from the same event
184 }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
185
186 //end of loop over particles from first event
187 }//for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
188 delete fPartBuffer->Push(partEvent1);
189 delete fTrackBuffer->Push(trackEvent1);
190 //end of loop over events
191 return 0;
192}
193/*************************************************************************************/
194
195Int_t AliHBTAnalysisStavinskyMixing::ProcessSim(AliAOD* /*aodrec*/, AliAOD* aodsim)
196{
197 //Does analysis of simulated data
198 AliVAODParticle * part1, * part2;
199
200 AliAOD* partEvent = aodsim;
201 AliAOD* partEvent1 = new AliAOD();
202
2da636ed 203
204 AliHBTPair ppair;
205
206 AliHBTPair* partpair = &ppair;
b74dff53 207
208 AliHBTPair * tmppartpair;
209
210 register UInt_t ii;
211
212
213 if ( !partEvent )
214 {
215 Error("ProcessRecAndSim","Can not get event");
216 return 1;
217 }
218
219
220 for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
221 {
222 /***************************************/
223 /****** Looping same events ********/
224 /****** filling numerators ********/
225 /***************************************/
226 Warning("ProcessTracksAndParticles","Non-std MIXING");
227 if ( (j%fDisplayMixingInfo) == 0)
228 Info("ProcessTracksAndParticles",
229 "Mixing particle %d with particles from the same event",j);
230
231 part1= partEvent->GetParticle(j);
232
233 Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(part1);
234
235 if (fBufferSize != 0)
236 if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(part1) == kFALSE ) )
237 {
238 //accepted by any cut
239 // we have to copy because reader keeps only one event
240
241 partEvent1->AddParticle(part1);
242 }
243
244 if (firstcut) continue;
245
246 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
247 fParticleMonitorFunctions[ii]->Process(part1);
248
249 if ( fNParticleFunctions == 0 ) continue;
250
251 for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
252 {
253 part2= partEvent->GetParticle(k);
254 if (part1->GetUID() == part2->GetUID()) continue;
255 partpair->SetParticles(part1,part2);
256
257 if(fPairCut->Rejected(partpair)) //check pair cut
258 { //do not meets crietria of the
259 if( fPairCut->Rejected((AliHBTPair*)partpair->GetSwappedPair()) ) continue;
260 else tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
261 }
262 else
263 {
264 tmppartpair = partpair;
265 }
266
267 for(ii = 0;ii<fNParticleFunctions;ii++)
268 fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
269
270
271 /***************************************/
272 /***** Filling denominators *********/
273 /***************************************/
274
275 tmppartpair->MirrorSecond();
276
277 if(fPairCut->Rejected(partpair) == kFALSE)
278 {
279 for(ii = 0;ii<fNParticleFunctions;ii++)
280 fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
281 }
282 tmppartpair->DeleteSecond();
283
284 //end of 2nd loop over particles from the same event
285 }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
286
287 }
288 delete fPartBuffer->Push(partEvent1);
289 //end of loop over events
290 return 0;
291}
292/*************************************************************************************/
293Int_t AliHBTAnalysisStavinskyMixing::ProcessRec(AliAOD* aodrec, AliAOD* /*aodsim*/)
294{
295 //Does analysis of reconstructed data
296 AliVAODParticle * track1, * track2;
297
298 AliAOD* trackEvent = aodrec;
299 AliAOD* trackEvent1 = new AliAOD();
300
301 AliAOD* trackEvent2;
302
303 AliHBTPair tpair;
304
305 AliHBTPair* trackpair = &tpair;
306
307 AliHBTPair * tmptrackpair;
308
309 register UInt_t ii;
310
311
312 if ( !trackEvent )
313 {
314 Error("ProcessRecAndSim","Can not get event");
315 return 1;
316 }
317
318
319 for (Int_t j = 0; j<trackEvent->GetNumberOfParticles() ; j++)
320 {
321 /***************************************/
322 /****** Looping same events ********/
323 /****** filling numerators ********/
324 /***************************************/
325 if ( (j%fDisplayMixingInfo) == 0)
326 Info("ProcessTracksAndParticles",
327 "Mixing Particle %d with Particles from the same event",j);
328
329 track1= trackEvent->GetParticle(j);
330
331 Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(track1);
332
333 if (fBufferSize != 0)
334 if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(track1) == kFALSE ) )
335 {
336 //accepted by any cut
337 // we have to copy because reader keeps only one event
338
339 trackEvent1->AddParticle(track1);
340 }
341
342 if (firstcut) continue;
343
344 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
345 fParticleMonitorFunctions[ii]->Process(track1);
346
347 if ( fNParticleFunctions == 0 ) continue;
348
349 for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
350 {
351 track2= trackEvent->GetParticle(k);
352 if (track1->GetUID() == track2->GetUID()) continue;
353 trackpair->SetParticles(track1,track2);
354
355 if(fPairCut->Rejected(trackpair)) //check pair cut
356 { //do not meets crietria of the
357 if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) ) continue;
358 else tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
359 }
360 else
361 {
362 tmptrackpair = trackpair;
363 }
364
365 for(ii = 0;ii<fNTrackFunctions;ii++)
366 fParticleFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
367
368 //end of 2nd loop over Particles from the same event
369 }//for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
370
371 /***************************************/
372 /***** Filling denominators *********/
373 /***************************************/
374 if (fBufferSize == 0) continue;
375
376 fTrackBuffer->ResetIter();
377 Int_t m = 0;
378 while (( trackEvent2 = fTrackBuffer->Next() ))
379 {
380 m++;
381 if ( (j%fDisplayMixingInfo) == 0)
382 Info("ProcessParticles",
383 "Mixing Particle %d from current event with Particles from event %d",j,-m);
384 for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all Particles
385 {
386
387 track2= trackEvent2->GetParticle(l);
388 trackpair->SetParticles(track1,track2);
389
390 if( fPairCut->Rejected(trackpair) ) //check pair cut
391 { //do not meets crietria of the
392 if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) )
393 continue;
394 else
395 {
396 tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
397 }
398 }
399 else
400 {//meets criteria of the pair cut
401 tmptrackpair = trackpair;
402 }
403
404 for(ii = 0;ii<fNTrackFunctions;ii++)
405 fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
406
407 }//for(Int_t l = 0; l<N2;l++) // ... on all Particles
408 }
409 }
410 delete fTrackBuffer->Push(trackEvent1);
411 //end of loop over events
412 return 0;
413}
414/*************************************************************************************/
415
416Int_t AliHBTAnalysisStavinskyMixing::ProcessRecAndSimNonId(AliAOD* aodrec, AliAOD* aodsim)
417{
418//Analyzes both reconstructed and simulated data
419 if (aodrec == 0x0)
420 {
421 Error("ProcessTracksAndParticlesNonIdentAnal","Reconstructed event is NULL");
422 return 1;
423 }
424
425 if (aodsim == 0x0)
426 {
427 Error("ProcessTracksAndParticlesNonIdentAnal","Simulated event is NULL");
428 return 1;
429 }
430
431 if ( aodrec->GetNumberOfParticles() != aodsim->GetNumberOfParticles() )
432 {
433 Error("ProcessTracksAndParticlesNonIdentAnal",
434 "Number of simulated particles (%d) not equal to number of reconstructed tracks (%d)",
435 aodsim->GetNumberOfParticles() , aodrec->GetNumberOfParticles());
436 return 2;
437 }
438
439
440 AliVAODParticle * part1, * part2;
441 AliVAODParticle * track1, * track2;
442
443 static AliAOD aodrec1;
444 static AliAOD aodsim1;
445
446 AliAOD * trackEvent1=&aodrec1,*partEvent1=&aodsim1;//Particle that passes first particle cut, this event
447 trackEvent1->Reset();
448 partEvent1->Reset();
449 AliAOD * trackEvent2=0x0,*partEvent2=0x0;//Particle that passes second particle cut, this event
450 AliAOD * trackEvent3=0x0,*partEvent3=0x0;//Particle that passes second particle cut, events from buffer
451
452 AliAOD* rawtrackEvent = aodrec;//this we get from Reader
453 AliAOD* rawpartEvent = aodsim;//this we get from Reader
454
455 static AliHBTPair tpair;
456 static AliHBTPair ppair;
457
458 AliHBTPair* trackpair = &tpair;
459 AliHBTPair* partpair = &ppair;
460
461 register UInt_t ii;
462
463 /********************************/
464 /* Filtering out */
465 /********************************/
466 if ( ( (partEvent2==0x0) || (trackEvent2==0x0)) )//in case fBufferSize == 0 and pointers are created do not eneter
467 {
468 partEvent2 = new AliAOD();
469 trackEvent2 = new AliAOD();
470 }
471
472 FilterOut(partEvent1, partEvent2, rawpartEvent, trackEvent1, trackEvent2, rawtrackEvent);
473
474 for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
475 {
476 if ( (j%fDisplayMixingInfo) == 0)
477 Info("ProcessTracksAndParticlesNonIdentAnal",
478 "Mixing particle %d from current event with particles from current event",j);
479
480 part1= partEvent1->GetParticle(j);
481 track1= trackEvent1->GetParticle(j);
482
483
484 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
485 fParticleMonitorFunctions[ii]->Process(part1);
486 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
487 fTrackMonitorFunctions[ii]->Process(track1);
488 for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
489 fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
490
491 if (fNoCorrfctns) continue;
492
493 /***************************************/
494 /****** filling numerators ********/
495 /****** (particles from event2) ********/
496 /***************************************/
497
498 for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
499 {
500 part2= partEvent2->GetParticle(k);
501 if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
502 partpair->SetParticles(part1,part2);
503
504 track2= trackEvent2->GetParticle(k);
505 trackpair->SetParticles(track1,track2);
506
507 if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
508 { //do not meets crietria of the pair cut
509 continue;
510 }
511 else
512 {//meets criteria of the pair cut
513 for(ii = 0;ii<fNParticleFunctions;ii++)
514 fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
515
516 for(ii = 0;ii<fNTrackFunctions;ii++)
517 fTrackFunctions[ii]->ProcessSameEventParticles(trackpair);
518
519 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
520 fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(trackpair,partpair);
521 }
522 }
523
524 if ( fBufferSize == 0) continue;//do not mix diff histograms
525 /***************************************/
526 /***** Filling denominators *********/
527 /***************************************/
528 fPartBuffer->ResetIter();
529 fTrackBuffer->ResetIter();
530
531 Int_t nmonitor = 0;
532
533 while ( (partEvent3 = fPartBuffer->Next() ) != 0x0)
534 {
535 trackEvent3 = fTrackBuffer->Next();
536
537 if ( (j%fDisplayMixingInfo) == 0)
538 Info("ProcessTracksAndParticlesNonIdentAnal",
539 "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
540
541 for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
542 {
543 part2= partEvent3->GetParticle(k);
544 partpair->SetParticles(part1,part2);
545
546 track2= trackEvent3->GetParticle(k);
547 trackpair->SetParticles(track1,track2);
548
549 if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
550 { //do not meets crietria of the pair cut
551 continue;
552 }
553 else
554 {//meets criteria of the pair cut
555 UInt_t ii;
556 for(ii = 0;ii<fNParticleFunctions;ii++)
557 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
558
559 for(ii = 0;ii<fNTrackFunctions;ii++)
560 fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
561
562 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
563 fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(trackpair,partpair);
564 }
565 }// for particles event2
566 }//while event2
567 }//for over particles in event1
568
569 delete fPartBuffer->Push(partEvent2);
570 delete fTrackBuffer->Push(trackEvent2);
571
572 return 0;
573}
574/*************************************************************************************/
575Int_t AliHBTAnalysisStavinskyMixing::ProcessSimNonId(AliAOD* /*aodrec*/, AliAOD* aodsim)
576{
577//does analysis of simulated (MC) data in non-identical mode
578//i.e. when particles selected by first part. cut are a disjunctive set than particles
579//passed by the second part. cut
580 if (aodsim == 0x0)
581 {
582 return 1;
583 }
584
585
586 AliVAODParticle * part1, * part2;
587
588 static AliAOD aodsim1;
589
590 AliAOD* partEvent1=&aodsim1;//Particle that passes first particle cut, this event
591 partEvent1->Reset();
592 AliAOD* partEvent2=0x0;//Particle that passes second particle cut, this event
593 AliAOD* partEvent3=0x0;//Particle that passes second particle cut, events from buffer
594
595 AliAOD* rawpartEvent = aodsim;//this we get from Reader
596
597 static AliHBTPair ppair;
598
599 AliHBTPair* partpair = &ppair;
600
601 register UInt_t ii;
602
603 /********************************/
604 /* Filtering out */
605 /********************************/
606 if (partEvent2==0x0)//in case fBufferSize == 0 and pointers are created do not eneter
607 {
608 partEvent2 = new AliAOD();
609 }
610
611 FilterOut(partEvent1, partEvent2, rawpartEvent);
612
613 for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
614 {
615 if ( (j%fDisplayMixingInfo) == 0)
616 Info("ProcessParticlesNonIdentAnal",
617 "Mixing particle %d from current event with particles from current event",j);
618
619 part1= partEvent1->GetParticle(j);
620
621
622 for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
623 fParticleMonitorFunctions[ii]->Process(part1);
624
625 if (fNParticleFunctions == 0) continue;
626
627 /***************************************/
628 /****** filling numerators ********/
629 /****** (particles from event2) ********/
630 /***************************************/
631
632 for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
633 {
634 part2= partEvent2->GetParticle(k);
635 if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
636 partpair->SetParticles(part1,part2);
637
638
639 if(fPairCut->PassPairProp(partpair) ) //check pair cut
640 { //do not meets crietria of the pair cut
641 continue;
642 }
643 else
644 {//meets criteria of the pair cut
645 for(ii = 0;ii<fNParticleFunctions;ii++)
646 fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
647 }
648 }
649
650 if ( fBufferSize == 0) continue;//do not mix diff histograms
651 /***************************************/
652 /***** Filling denominators *********/
653 /***************************************/
654 fPartBuffer->ResetIter();
655
656 Int_t nmonitor = 0;
657
658 while ( (partEvent3 = fPartBuffer->Next() ) != 0x0)
659 {
660
661 if ( (j%fDisplayMixingInfo) == 0)
662 Info("ProcessParticlesNonIdentAnal",
663 "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
664
665 for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
666 {
667 part2= partEvent3->GetParticle(k);
668 partpair->SetParticles(part1,part2);
669
670
671 if(fPairCut->PassPairProp(partpair) ) //check pair cut
672 { //do not meets crietria of the pair cut
673 continue;
674 }
675 else
676 {//meets criteria of the pair cut
677 for(ii = 0;ii<fNParticleFunctions;ii++)
678 {
679 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
680 }
681 }
682 }// for particles event2
683 }//while event2
684 }//for over particles in event1
685
686 delete fPartBuffer->Push(partEvent2);
687
688 return 0;
689}
690/*************************************************************************************/
691Int_t AliHBTAnalysisStavinskyMixing::ProcessRecNonId(AliAOD* aodrec, AliAOD* /*aodsim*/)
692{
693//Analyzes both reconstructed and simulated data
694 if (aodrec == 0x0)
695 {
696 return 1;
697 }
698
699 AliVAODParticle * track1, * track2;
700
701 static AliAOD aodrec1;
702 AliAOD * trackEvent1=&aodrec1;//Particle that passes first particle cut, this event
703 trackEvent1->Reset();
704 AliAOD * trackEvent2=0x0;//Particle that passes second particle cut, this event
705 AliAOD * trackEvent3=0x0;//Particle that passes second particle cut, events from buffer
706 AliAOD* rawtrackEvent = aodrec;//this we get from Reader
707
708 static AliHBTPair tpair;
709
710 AliHBTPair* trackpair = &tpair;
711
712 register UInt_t ii;
713
714
715 /********************************/
716 /* Filtering out */
717 /********************************/
718 if ( trackEvent2==0x0 )//in case fBufferSize == 0 and pointers are created do not eneter
719 {
720 trackEvent2 = new AliAOD();
721 }
722
723 FilterOut(trackEvent1, trackEvent2, rawtrackEvent);
724
725 for (Int_t j = 0; j<trackEvent1->GetNumberOfParticles() ; j++)
726 {
727 if ( (j%fDisplayMixingInfo) == 0)
728 Info("ProcessTracksNonIdentAnal",
729 "Mixing particle %d from current event with particles from current event",j);
730
731 track1= trackEvent1->GetParticle(j);
732
733
734 for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
735 fTrackMonitorFunctions[ii]->Process(track1);
736
737 if (fNTrackFunctions == 0x0) continue;
738
739 /***************************************/
740 /****** filling numerators ********/
741 /****** (particles from event2) ********/
742 /***************************************/
743
744 for (Int_t k = 0; k < trackEvent2->GetNumberOfParticles() ; k++) //partEvent1 and partEvent2 are particles from the same event but separated to two groups
745 {
746 track2= trackEvent2->GetParticle(k);
747 if (track1->GetUID() == track2->GetUID()) continue;//this is the same particle but with different PID
748 trackpair->SetParticles(track1,track2);
749
750
751 if( fPairCut->PassPairProp(trackpair)) //check pair cut
752 { //do not meets crietria of the pair cut
753 continue;
754 }
755 else
756 {//meets criteria of the pair cut
757 UInt_t ii;
758 for(ii = 0;ii<fNTrackFunctions;ii++)
759 fTrackFunctions[ii]->ProcessSameEventParticles(trackpair);
760 }
761 }
762
763 if ( fBufferSize == 0) continue;//do not mix diff histograms
764 /***************************************/
765 /***** Filling denominators *********/
766 /***************************************/
767 fTrackBuffer->ResetIter();
768
769 Int_t nmonitor = 0;
770
771 while ( (trackEvent3 = fTrackBuffer->Next() ) != 0x0)
772 {
773 if ( (j%fDisplayMixingInfo) == 0)
774 Info("ProcessTracksNonIdentAnal",
775 "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
776
777 for (Int_t k = 0; k < trackEvent3->GetNumberOfParticles() ; k++)
778 {
779 track2= trackEvent3->GetParticle(k);
780 trackpair->SetParticles(track1,track2);
781
782 if( fPairCut->PassPairProp(trackpair)) //check pair cut
783 { //do not meets crietria of the pair cut
784 continue;
785 }
786 else
787 {//meets criteria of the pair cut
788 for(ii = 0;ii<fNTrackFunctions;ii++)
789 fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
790 }
791 }// for particles event2
792 }//while event2
793 }//for over particles in event1
794
795 delete fTrackBuffer->Push(trackEvent2);
796
797 return 0;
798}
799/*************************************************************************************/