Bug correction
[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   
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
195 Int_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
203   
204   AliHBTPair ppair;
205
206   AliHBTPair* partpair = &ppair;
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 /*************************************************************************************/ 
293 Int_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      
416 Int_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 /*************************************************************************************/ 
575 Int_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 /*************************************************************************************/ 
691 Int_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 /*************************************************************************************/