Analysis using Stavinsky mixing method
[u/mrichter/AliRoot.git] / HBTAN / AliHBTAnalysisStavinskyMixing.cxx
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
39 ClassImp(AliHBTAnalysisStavinskyMixing)
40
41
42 Int_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
196 Int_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 /*************************************************************************************/ 
295 Int_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      
418 Int_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 /*************************************************************************************/ 
577 Int_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 /*************************************************************************************/ 
693 Int_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 /*************************************************************************************/