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