Catching up to NewIO -> Particle stores all passible PID and their probabilities
[u/mrichter/AliRoot.git] / HBTAN / AliHBTAnalysis.cxx
index 0822a98..d6656d0 100644 (file)
@@ -1,3 +1,5 @@
+#include "TH2D.h"
+#include "TH3D.h"
 #include "AliHBTAnalysis.h"
 #include "AliHBTRun.h"
 #include "AliHBTEvent.h"
 #include <TBenchmark.h>
 #include <TList.h>
 
+//_________________________________________________________
+///////////////////////////////////////////////////////////
+//
+//Central Object Of HBTAnalyser: 
+//This class performs main looping within HBT Analysis
+//User must plug a reader of Type AliHBTReader
+//User plugs in coorelation and monitor functions
+//as well as monitor functions
+//
+//HBT Analysis Tool, which is integral part of AliRoot,
+//ALICE Off-Line framework:
+//
+//Piotr.Skowronski@cern.ch
+//more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
+//
+//_________________________________________________________
+
 ClassImp(AliHBTAnalysis)
 
 const UInt_t AliHBTAnalysis::fgkFctnArraySize = 100;
@@ -19,17 +38,18 @@ const UInt_t AliHBTAnalysis::fgkDefaultMixingInfo = 1000;
 const Int_t  AliHBTAnalysis::fgkDefaultBufferSize = 5;
 
 AliHBTAnalysis::AliHBTAnalysis():
- fReader(0x0),
- fNTrackFunctions(0),
- fNParticleFunctions(0),
- fNParticleAndTrackFunctions(0),
- fNTrackMonitorFunctions(0),
- fNParticleMonitorFunctions(0), 
- fNParticleAndTrackMonitorFunctions(0),
- fBufferSize(2),
- fDisplayMixingInfo(fgkDefaultMixingInfo),
- fIsOwner(kFALSE)
+  fReader(0x0),
+  fNTrackFunctions(0),
+  fNParticleFunctions(0),
+  fNParticleAndTrackFunctions(0),
+  fNTrackMonitorFunctions(0),
+  fNParticleMonitorFunctions(0), 
+  fNParticleAndTrackMonitorFunctions(0),
+  fBufferSize(2),
+  fDisplayMixingInfo(fgkDefaultMixingInfo),
+  fIsOwner(kFALSE)
  {
+//default constructor
    fTrackFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
    fParticleFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
    fParticleAndTrackFunctions = new AliHBTTwoPairFctn* [fgkFctnArraySize];
@@ -43,29 +63,31 @@ AliHBTAnalysis::AliHBTAnalysis():
 /*************************************************************************************/ 
 
 AliHBTAnalysis::AliHBTAnalysis(const AliHBTAnalysis& in):
- fReader(0x0),
- fNTrackFunctions(0),
- fNParticleFunctions(0),
- fNParticleAndTrackFunctions(0),
- fNTrackMonitorFunctions(0),
- fNParticleMonitorFunctions(0), 
- fNParticleAndTrackMonitorFunctions(0),
- fTrackFunctions(0x0),
- fParticleFunctions(0x0),
- fParticleAndTrackFunctions(0x0),
- fParticleMonitorFunctions(0x0),
- fTrackMonitorFunctions(0x0),
- fParticleAndTrackMonitorFunctions(0x0),
- fPairCut(0x0),
- fBufferSize(fgkDefaultBufferSize),
- fDisplayMixingInfo(fgkDefaultMixingInfo),
- fIsOwner(kFALSE)
+  fReader(0x0),
+  fNTrackFunctions(0),
+  fNParticleFunctions(0),
+  fNParticleAndTrackFunctions(0),
+  fNTrackMonitorFunctions(0),
+  fNParticleMonitorFunctions(0), 
+  fNParticleAndTrackMonitorFunctions(0),
+  fTrackFunctions(0x0),
+  fParticleFunctions(0x0),
+  fParticleAndTrackFunctions(0x0),
+  fParticleMonitorFunctions(0x0),
+  fTrackMonitorFunctions(0x0),
+  fParticleAndTrackMonitorFunctions(0x0),
+  fPairCut(0x0),
+  fBufferSize(fgkDefaultBufferSize),
+  fDisplayMixingInfo(fgkDefaultMixingInfo),
+  fIsOwner(kFALSE)
  {
+//copy constructor
    Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
  }
 /*************************************************************************************/ 
-const AliHBTAnalysis& AliHBTAnalysis::operator=(const AliHBTAnalysis& right)
+AliHBTAnalysis& AliHBTAnalysis::operator=(const AliHBTAnalysis& right)
  {
+//operator =
    Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
    return *this;
  }
@@ -90,27 +112,79 @@ AliHBTAnalysis::~AliHBTAnalysis()
  }
 
 /*************************************************************************************/ 
+
 void AliHBTAnalysis::DeleteFunctions()
 {
+ //Deletes all functions added to analysis
  UInt_t ii;
  for(ii = 0;ii<fNParticleFunctions;ii++)
    delete fParticleFunctions[ii];
+ fNParticleFunctions = 0;
                 
  for(ii = 0;ii<fNTrackFunctions;ii++)
    delete fTrackFunctions[ii];
-
+ fNTrackFunctions = 0;
  for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
    delete fParticleAndTrackFunctions[ii];
+ fNParticleAndTrackFunctions = 0;
  
  for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
    delete fParticleMonitorFunctions[ii];
+ fNParticleMonitorFunctions = 0;
    
  for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
    delete fTrackMonitorFunctions[ii];
+ fNTrackMonitorFunctions = 0;
    
  for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
    delete fParticleAndTrackMonitorFunctions[ii];
+ fNParticleAndTrackMonitorFunctions = 0;
+}
+/*************************************************************************************/ 
+
+void AliHBTAnalysis::Init()
+{
+//Initializeation method
+//calls Init for all functions
+ UInt_t ii;
+ for(ii = 0;ii<fNParticleFunctions;ii++)
+   fParticleFunctions[ii]->Init();
+                
+ for(ii = 0;ii<fNTrackFunctions;ii++)
+   fTrackFunctions[ii]->Init();
+
+ for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
+   fParticleAndTrackFunctions[ii]->Init();
+ for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
+   fParticleMonitorFunctions[ii]->Init();
+   
+ for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
+   fTrackMonitorFunctions[ii]->Init();
+   
+ for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
+   fParticleAndTrackMonitorFunctions[ii]->Init();
 }
+/*************************************************************************************/ 
+
+void AliHBTAnalysis::ResetFunctions()
+{
+//In case fOwner is true, deletes all functions
+//in other case, just set number of analysis to 0
+ if (fIsOwner) DeleteFunctions();
+ else
+  {
+    fNParticleFunctions = 0;
+    fNTrackFunctions = 0;
+    fNParticleAndTrackFunctions = 0;
+    fNParticleMonitorFunctions = 0;
+    fNTrackMonitorFunctions = 0;
+    fNParticleAndTrackMonitorFunctions = 0;
+  }
+}
+/*************************************************************************************/ 
+
 void AliHBTAnalysis::Process(Option_t* option)
 {
  //default option  = "TracksAndParticles"
@@ -143,7 +217,6 @@ void AliHBTAnalysis::Process(Option_t* option)
    return;
   }
  
  const char *oT = strstr(option,"Tracks");
  const char *oP = strstr(option,"Particles");
  
@@ -168,6 +241,7 @@ void AliHBTAnalysis::Process(Option_t* option)
               "Coherency check not passed. Maybe change the option?\n");
         return;
       }
+    Init();
     if (nonid) ProcessTracksAndParticlesNonIdentAnal();
     else ProcessTracksAndParticles();
     return;
@@ -180,6 +254,7 @@ void AliHBTAnalysis::Process(Option_t* option)
        Error("Process","There is no data to analyze.");
        return;
      }
+    Init();
     if (nonid) ProcessTracksNonIdentAnal();
     else ProcessTracks();
     return;
@@ -192,18 +267,17 @@ void AliHBTAnalysis::Process(Option_t* option)
        Error("Process","There is no data to analyze.");
        return;
      }
+    Init();
     if (nonid) ProcessParticlesNonIdentAnal();
     else ProcessParticles();
     return;
   }
  
 }
-
 /*************************************************************************************/ 
 
 void AliHBTAnalysis::ProcessTracksAndParticles()
 {
-
 //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
 //the loops are splited
   
@@ -216,7 +290,7 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
   
 //  Int_t N1, N2, N=0; //number of particles in current event(we prcess two events in one time)
   
-  Int_t Nev = fReader->GetNumberOfTrackEvents();
+  Int_t nev = fReader->GetNumberOfTrackEvents();
   
   /***************************************/
   /******   Looping same events   ********/
@@ -230,7 +304,7 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
 
   register UInt_t ii;
   
-  for (Int_t i = 0;i<Nev;i++)
+  for (Int_t i = 0;i<nev;i++)
     {
       partEvent= fReader->GetParticleEvent(i);
       trackEvent = fReader->GetTrackEvent(i);
@@ -252,11 +326,11 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
          if (fPairCut->GetFirstPartCut()->Pass(part1)) continue;
 
          for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
-           fParticleMonitorFunctions[ii]->ProcessSameEventParticles(part1);
+           fParticleMonitorFunctions[ii]->Process(part1);
          for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
-           fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+           fTrackMonitorFunctions[ii]->Process(track1);
          for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
-           fParticleAndTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1,part1);
+           fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
 
          if ( (fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
            continue; 
@@ -300,7 +374,7 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
   /***** Filling denominators    *********/
   /***************************************/
   if (fBufferSize != 0)
-   for (Int_t i = 0;i<Nev-1;i++)   //In each event (but last) ....
+   for (Int_t i = 0;i<nev-1;i++)   //In each event (but last) ....
     {
   
       if ((fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
@@ -318,20 +392,20 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
 
            if (fPairCut->GetFirstPartCut()->Pass(part1)) continue;
  
-           Int_t NNN;
+           Int_t maxeventnumber;
            
-           if ( ((i+fBufferSize) >= Nev) ||( fBufferSize < 0) ) //if buffer size is negative 
+           if ( ((i+fBufferSize) >= nev) ||( fBufferSize < 0) ) //if buffer size is negative 
                                                                 //or current event+buffersize is greater
                                                                 //than max nuber of events
              {
-               NNN = Nev; //set the max event number 
+               maxeventnumber = nev; //set the max event number 
              }
            else 
              {
-               NNN = i+fBufferSize; //set the current event number + fBufferSize
+               maxeventnumber = i+fBufferSize; //set the current event number + fBufferSize
              }
  
-           for (Int_t k = i+1; k<NNN;k++)  // ... Loop over next event
+           for (Int_t k = i+1; k<maxeventnumber;k++)  // ... Loop over next event
             {
              
              partEvent2= fReader->GetParticleEvent(k);
@@ -375,7 +449,7 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
                 for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
                   fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair,tmppartpair);
               }//for(Int_t l = 0; l<N2;l++)   //  ... on all particles
-            }//for (Int_t k = i+1; k<NNN;k++)  // ... Loop over next event
+            }//for (Int_t k = i+1; k<maxeventnumber;k++)  // ... Loop over next event
        }
     } 
   /***************************************/
@@ -384,14 +458,14 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
 
 void AliHBTAnalysis::ProcessTracks()
 {
-  //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
+//In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
 //the loops are splited
   AliHBTParticle * track1, * track2;
   AliHBTEvent * trackEvent;
   AliHBTEvent * trackEvent2;
 
   UInt_t ii;
-  Int_t Nev = fReader->GetNumberOfTrackEvents();
+  Int_t nev = fReader->GetNumberOfTrackEvents();
 
   AliHBTPair * trackpair = new AliHBTPair();
   AliHBTPair * tmptrackpair; //temporary pointer 
@@ -400,7 +474,7 @@ void AliHBTAnalysis::ProcessTracks()
   /******   Looping same events   ********/
   /******   filling numerators    ********/
   /***************************************/
-  for (Int_t i = 0;i<Nev;i++)
+  for (Int_t i = 0;i<nev;i++)
     {
       trackEvent = fReader->GetTrackEvent(i);
       if (!trackEvent) continue;
@@ -415,7 +489,7 @@ void AliHBTAnalysis::ProcessTracks()
          if (fPairCut->GetFirstPartCut()->Pass(track1)) continue;
 
          for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
-           fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+           fTrackMonitorFunctions[ii]->Process(track1);
 
          if ( fNTrackFunctions ==0 )
            continue; 
@@ -443,7 +517,7 @@ void AliHBTAnalysis::ProcessTracks()
   /***** Filling diff histogram *********/
   /***************************************/
   if (fBufferSize != 0)
-   for (Int_t i = 0;i<Nev-1;i++)   //In each event (but last) ....
+   for (Int_t i = 0;i<nev-1;i++)   //In each event (but last) ....
     {
       if ( fNTrackFunctions ==0 )
         continue; 
@@ -456,26 +530,26 @@ void AliHBTAnalysis::ProcessTracks()
          track1= trackEvent->GetParticle(j);
          if (fPairCut->GetFirstPartCut()->Pass(track1)) continue;
 
-         Int_t NNN;
+         Int_t maxeventnumber;
            
-         if ( ((i+fBufferSize) >= Nev) ||( fBufferSize < 0) ) //if buffer size is negative 
+         if ( ((i+fBufferSize) >= nev) ||( fBufferSize < 0) ) //if buffer size is negative 
                                                               //or current event+buffersize is greater
                                                               //than max nuber of events
           {
-            NNN = Nev; //set the max event number 
+            maxeventnumber = nev; //set the max event number 
           }
          else 
           {
-            NNN = i+fBufferSize; //set the current event number + fBufferSize
+            maxeventnumber = i+fBufferSize; //set the current event number + fBufferSize
           }
  
-         for (Int_t k = i+1; k<NNN;k++)  // ... Loop over next event
+         for (Int_t k = i+1; k<maxeventnumber;k++)  // ... Loop over next event
           {
             trackEvent2 = fReader->GetTrackEvent(k);
             if (!trackEvent2) continue;
              
             if ( (j%fDisplayMixingInfo) == 0) 
-                 Info("ProcessTracksAndParticles",
+                 Info("ProcessTracks",
                       "Mixing particle %d from event %d with particles from event %d",j,i,k);
             
             for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++)   //  ... on all particles
@@ -496,7 +570,7 @@ void AliHBTAnalysis::ProcessTracks()
                    fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
                
              }//for(Int_t l = 0; l<N2;l++)   //  ... on all particles
-          }//for (Int_t k = i+1; k<NNN;k++)  // ... Loop over next event
+          }//for (Int_t k = i+1; k<maxeventnumber;k++)  // ... Loop over next event
        }
     } 
   /***************************************/
@@ -516,13 +590,13 @@ void AliHBTAnalysis::ProcessParticles()
   AliHBTPair * partpair = new AliHBTPair();
   AliHBTPair * tmppartpair; //temporary pointer to the pair
   
-  Int_t Nev = fReader->GetNumberOfPartEvents();
+  Int_t nev = fReader->GetNumberOfPartEvents();
   
   /***************************************/
   /******   Looping same events   ********/
   /******   filling numerators    ********/
   /***************************************/
-  for (Int_t i = 0;i<Nev;i++)
+  for (Int_t i = 0;i<nev;i++)
     {
       partEvent= fReader->GetParticleEvent(i);
       if (!partEvent) continue;
@@ -539,7 +613,7 @@ void AliHBTAnalysis::ProcessParticles()
         
          UInt_t zz;
          for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
-           fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+           fParticleMonitorFunctions[zz]->Process(part1);
 
          if ( fNParticleFunctions ==0 )
            continue; 
@@ -574,7 +648,7 @@ void AliHBTAnalysis::ProcessParticles()
   /***** Filling diff histogram *********/
   /***************************************/
   if (fBufferSize != 0) //less then 0 mix everything, == 0 do not mix denominator
-   for (Int_t i = 0;i<Nev-1;i++)   //In each event (but last)....
+   for (Int_t i = 0;i<nev-1;i++)   //In each event (but last)....
     {
       if ( fNParticleFunctions ==0 )
         continue; 
@@ -586,20 +660,20 @@ void AliHBTAnalysis::ProcessParticles()
        {
            part1= partEvent->GetParticle(j);
            if (fPairCut->GetFirstPartCut()->Pass(part1)) continue;
-           Int_t NNN;
+           Int_t maxeventnumber;
 
-           if ( ((i+fBufferSize) >= Nev) ||( fBufferSize < 0) ) //if buffer size is negative 
+           if ( ((i+fBufferSize) >= nev) ||( fBufferSize < 0) ) //if buffer size is negative 
                                                                 //or current event+buffersize is greater
                                                                 //than max nuber of events
             {
-             NNN = Nev; //set the max event number 
+             maxeventnumber = nev; //set the max event number 
             }
            else 
             {
-             NNN = i+fBufferSize; //set the current event number + fBufferSize
+             maxeventnumber = i+fBufferSize; //set the current event number + fBufferSize
             }
            
-           for (Int_t k = i+1; k<NNN;k++)  // ... Loop over next event
+           for (Int_t k = i+1; k<maxeventnumber;k++)  // ... Loop over next event
             {
              
              partEvent2= fReader->GetParticleEvent(k);
@@ -628,7 +702,7 @@ void AliHBTAnalysis::ProcessParticles()
                   fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
                
               }//for(Int_t l = 0; l<N2;l++)   //  ... on all particles
-            }//for (Int_t k = i+1; k<NNN;k++)  // ... Loop over next event
+            }//for (Int_t k = i+1; k<maxeventnumber;k++)  // ... Loop over next event
        }
     } 
   /***************************************/
@@ -836,7 +910,7 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
 
   AliHBTEvent * rawtrackEvent, *rawpartEvent;
   
-  Int_t Nev = fReader->GetNumberOfTrackEvents();
+  Int_t nev = fReader->GetNumberOfTrackEvents();
 
   AliHBTPair * trackpair = new AliHBTPair();
   AliHBTPair * partpair = new AliHBTPair();
@@ -855,7 +929,7 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
   Info("ProcessTracksAndParticlesNonIdentAnal","*****  NON IDENT MODE ****************");
   Info("ProcessTracksAndParticlesNonIdentAnal","**************************************");
   
-  for (Int_t i = 0;i<Nev;i++)
+  for (Int_t i = 0;i<nev;i++)
     {
       rawpartEvent  = fReader->GetParticleEvent(i);
       rawtrackEvent = fReader->GetTrackEvent(i);
@@ -890,11 +964,11 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
          track1= trackEvent1->GetParticle(j);
 
          for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
-           fParticleMonitorFunctions[ii]->ProcessSameEventParticles(part1);
+           fParticleMonitorFunctions[ii]->Process(part1);
          for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
-           fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+           fTrackMonitorFunctions[ii]->Process(track1);
          for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
-           fParticleAndTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1,part1);
+           fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
 
          /***************************************/
          /******   filling numerators    ********/
@@ -969,7 +1043,6 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
        }//for over particles in event1
      
      if ( fBufferSize == 0) continue;//do not mix diff histograms-> do not add to buffer list
-     Info("ProcessTracksAndParticlesNonIdentAnal","Adding Event2's to lists and setting to null");
      pbuffer.AddFirst(partEvent2);
      tbuffer.AddFirst(trackEvent2);
      partEvent2 = 0x0;
@@ -994,6 +1067,7 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
  
 void AliHBTAnalysis::ProcessTracksNonIdentAnal()
 {
+//Process Tracks only with non identical mode
   AliHBTParticle * track1, * track2;
 
   AliHBTEvent * trackEvent1=0x0;
@@ -1002,7 +1076,7 @@ void AliHBTAnalysis::ProcessTracksNonIdentAnal()
 
   AliHBTEvent * rawtrackEvent;
   
-  Int_t Nev = fReader->GetNumberOfTrackEvents();
+  Int_t nev = fReader->GetNumberOfTrackEvents();
 
   AliHBTPair * trackpair = new AliHBTPair();
 
@@ -1017,7 +1091,7 @@ void AliHBTAnalysis::ProcessTracksNonIdentAnal()
   Info("ProcessTracksNonIdentAnal","*****  NON IDENT MODE ****************");
   Info("ProcessTracksNonIdentAnal","**************************************");
   
-  for (Int_t i = 0;i<Nev;i++)
+  for (Int_t i = 0;i<nev;i++)
     {
       rawtrackEvent = fReader->GetTrackEvent(i);
       if (rawtrackEvent == 0x0)  continue;//in case of any error
@@ -1047,7 +1121,7 @@ void AliHBTAnalysis::ProcessTracksNonIdentAnal()
          track1= trackEvent1->GetParticle(j);
 
          for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
-           fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+           fTrackMonitorFunctions[ii]->Process(track1);
 
          /***************************************/
          /******   filling numerators    ********/
@@ -1120,6 +1194,7 @@ void AliHBTAnalysis::ProcessTracksNonIdentAnal()
 
 void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
 {
+//process paricles only with non identical mode
   AliHBTParticle * part1 = 0x0, * part2 = 0x0;
 
   AliHBTEvent * partEvent1 = 0x0;
@@ -1128,7 +1203,7 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
 
   AliHBTEvent * rawpartEvent = 0x0;
 
-  Int_t Nev = fReader->GetNumberOfPartEvents();
+  Int_t nev = fReader->GetNumberOfPartEvents();
 
   AliHBTPair * partpair = new AliHBTPair();
 
@@ -1142,7 +1217,7 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
   Info("ProcessParticlesNonIdentAnal","*****  NON IDENT MODE ****************");
   Info("ProcessParticlesNonIdentAnal","**************************************");
 
-  for (Int_t i = 0;i<Nev;i++)
+  for (Int_t i = 0;i<nev;i++)
     {
       rawpartEvent  = fReader->GetParticleEvent(i);
       if ( rawpartEvent == 0x0  ) continue;//in case of any error
@@ -1173,7 +1248,7 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
 
          UInt_t zz;
          for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
-           fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+           fParticleMonitorFunctions[zz]->Process(part1);
 
          /***************************************/
          /******   filling numerators    ********/