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