AntiMerging cut implemented
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 14 Jan 2004 14:18:45 +0000 (14:18 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 14 Jan 2004 14:18:45 +0000 (14:18 +0000)
HBTAN/AliHBTAnalysis.cxx
HBTAN/AliHBTAnalysis.h
HBTAN/AliHBTPairCut.cxx
HBTAN/AliHBTPairCut.h
HBTAN/AliHBTParticle.cxx
HBTAN/AliHBTTrackPoints.cxx
HBTAN/AliHBTTrackPoints.h
HBTAN/HBTAnalysisLinkDef.h
HBTAN/hbtanalysis.C

index e85e571..d68057d 100644 (file)
 #include "AliHBTFunction.h"
 #include "AliHBTMonitorFunction.h"
 #include "AliHBTEventBuffer.h"
+#include "AliHBTPairCut.h"
  
+#include <TSystem.h>
 #include <TBenchmark.h>
 #include <TList.h>
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
 
 ClassImp(AliHBTAnalysis)
 
@@ -48,20 +54,19 @@ AliHBTAnalysis::AliHBTAnalysis():
   fNTrackMonitorFunctions(0),
   fNParticleMonitorFunctions(0), 
   fNParticleAndTrackMonitorFunctions(0),
+  fTrackFunctions ( new AliHBTOnePairFctn* [fgkFctnArraySize]),
+  fParticleFunctions ( new AliHBTOnePairFctn* [fgkFctnArraySize]),
+  fParticleAndTrackFunctions ( new AliHBTTwoPairFctn* [fgkFctnArraySize]),
+  fParticleMonitorFunctions ( new AliHBTMonOneParticleFctn* [fgkFctnArraySize]),    
+  fTrackMonitorFunctions ( new AliHBTMonOneParticleFctn* [fgkFctnArraySize]),    
+  fParticleAndTrackMonitorFunctions ( new AliHBTMonTwoParticleFctn* [fgkFctnArraySize]),    
+  fPairCut(new AliHBTEmptyPairCut()),//empty cut - accepts all particles
+  fAntiMergingCut(0x0),
   fBufferSize(2),
   fDisplayMixingInfo(fgkDefaultMixingInfo),
   fIsOwner(kFALSE)
  {
-//default constructor
-   fTrackFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
-   fParticleFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
-   fParticleAndTrackFunctions = new AliHBTTwoPairFctn* [fgkFctnArraySize];
-   
-   fParticleMonitorFunctions = new AliHBTMonOneParticleFctn* [fgkFctnArraySize];    
-   fTrackMonitorFunctions = new AliHBTMonOneParticleFctn* [fgkFctnArraySize];    
-   fParticleAndTrackMonitorFunctions = new AliHBTMonTwoParticleFctn* [fgkFctnArraySize];    
-
-   fPairCut = new AliHBTEmptyPairCut();//empty cut - accepts all particles
+   //default constructor
  }
 /*************************************************************************************/ 
 
@@ -81,6 +86,7 @@ AliHBTAnalysis::AliHBTAnalysis(const AliHBTAnalysis& in):
   fTrackMonitorFunctions(0x0),
   fParticleAndTrackMonitorFunctions(0x0),
   fPairCut(0x0),
+  fAntiMergingCut(0x0),
   fBufferSize(fgkDefaultBufferSize),
   fDisplayMixingInfo(fgkDefaultMixingInfo),
   fIsOwner(kFALSE)
@@ -113,6 +119,7 @@ AliHBTAnalysis::~AliHBTAnalysis()
    delete [] fParticleAndTrackMonitorFunctions; 
 
    delete fPairCut; // always have an copy of an object - we create we dstroy
+   delete fAntiMergingCut;
  }
 
 /*************************************************************************************/ 
@@ -257,9 +264,12 @@ void AliHBTAnalysis::Process(Option_t* option)
 
 void AliHBTAnalysis::ProcessTracksAndParticles()
 {
+//Makes analysis for both tracks and particles
+//mainly for resolution study and analysies with weighting algirithms
 //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
 //the loops are splited
   
+// cuta on particles only
   
   AliHBTParticle * part1, * part2;
   AliHBTParticle * track1, * track2;
@@ -373,9 +383,9 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
             track2= trackEvent->GetParticle(k);
             trackpair->SetParticles(track1,track2);
 
-            if(fPairCut->Pass(trackpair) ) //check pair cut 
+            if(fPairCut->Pass(partpair) ) //check pair cut 
               { //do not meets crietria of the pair cut, try with swapped pairs
-                if( fPairCut->Pass(trackpair->GetSwapedPair()) )
+                if( fPairCut->Pass(partpair->GetSwapedPair()) )
                   continue; //swaped pairs do not meet criteria of pair cut as well, take next particle
                 else 
                  { //swaped pair meets all the criteria
@@ -388,6 +398,7 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
                tmptrackpair = trackpair;
                tmppartpair = partpair;
              }
+             
             for(ii = 0;ii<fNParticleFunctions;ii++)
                    fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
                 
@@ -439,6 +450,11 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
                   tmptrackpair = trackpair;
                   tmppartpair = partpair;
                  }
+
+                //Anti merging cut is only on tracks makes the background
+                if (fAntiMergingCut) 
+                  if (fAntiMergingCut->Pass(trackpair)) continue;
+
                 for(ii = 0;ii<fNParticleFunctions;ii++)
                   fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
                  
@@ -574,11 +590,14 @@ void AliHBTAnalysis::ProcessTracks()
                   tmptrackpair = trackpair;
                  }
                  
+                //Anti merging cut is only on tracks makes the background
+                if (fAntiMergingCut) 
+                  if (fAntiMergingCut->Pass(trackpair)) continue;
+
                 for(ii = 0;ii<fNTrackFunctions;ii++)
                   fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
                  
              }//for(Int_t l = 0; l<N2;l++)   //  ... on all particles
-            
           }
        }
       trackEvent1 = trackbuffer.Push(trackEvent1); 
@@ -711,6 +730,18 @@ void AliHBTAnalysis::ProcessParticles()
       partEvent1 = partbuffer.Push(partEvent1); 
     }//while (fReader->Next() == kFALSE)
 }
+/*************************************************************************************/ 
+
+void AliHBTAnalysis::SetAntiMergingCut(Float_t x)
+{
+  if (x < 0)
+   {
+     Error("SetAntiMergingCut","Value less then 0");
+     return;
+   }
+  if (fAntiMergingCut == 0x0) fAntiMergingCut = new AliHBTAvSeparationCut(x);
+  else fAntiMergingCut->SetMinimum(x);
+}
 /*************************************************************************************/
 
 void AliHBTAnalysis::WriteFunctions()
@@ -1448,3 +1479,20 @@ Bool_t AliHBTAnalysis::IsNonIdentAnalysis()
  
  return kTRUE;
 }
+
+/*************************************************************************************/ 
+
+void AliHBTAnalysis::PressAnyKey()
+{ //small utility function that helps to make comfortable macros
+  char c;
+  int nread = -1;
+  fcntl(0,  F_SETFL, O_NONBLOCK);
+  ::Info("","Press Any Key to continue ...");
+  while (nread<1) 
+   {
+     nread = read(0, &c, 1);
+     gSystem->ProcessEvents();
+   }
+}
+
+
index ffda7dd..aac3848 100644 (file)
@@ -35,6 +35,7 @@ class AliHBTTwoPairFctn;
 
 class AliHBTMonOneParticleFctn;
 class AliHBTMonTwoParticleFctn;
+class AliHBTAvSeparationCut;
 
 class TList;
 
@@ -49,6 +50,8 @@ class AliHBTAnalysis: public TObject
      virtual void Process(Option_t* option = "TracksAndParticles");
      
      void SetGlobalPairCut(AliHBTPairCut* cut);
+     void SetAntiMergingCut(AliHBTAvSeparationCut *am){fAntiMergingCut = am;}
+     void SetAntiMergingCut(Float_t x);
      
      void AddTrackFunction(AliHBTOnePairFctn* f);
      void AddParticleFunction(AliHBTOnePairFctn* f);
@@ -71,6 +74,8 @@ class AliHBTAnalysis: public TObject
      void   Init();
      void   ResetFunctions();
      void   SetDisplayInfo(Int_t howoften){fDisplayMixingInfo = howoften;}//defines every each line info about mixing is displayed
+     
+     static void PressAnyKey();//small utility function that helps to make comfortable macros
    protected:
      
      Bool_t RunCoherencyCheck();
@@ -112,7 +117,8 @@ class AliHBTAnalysis: public TObject
      /* Control parameters  */
      /**********************************************/
 
-     AliHBTPairCut *fPairCut;//! Pair cut applied for all mixed particles
+     AliHBTPairCut*          fPairCut;//! Pair cut applied for all mixed particles
+     AliHBTAvSeparationCut*  fAntiMergingCut;//Anti-Splitting cut (only denominator)
       
      Int_t  fBufferSize; //!defines the size of buffer for mixed events; -1==MIX All
      Int_t  fDisplayMixingInfo;//!defines every which particle mixing info is displayed
index f72c7a8..e975131 100644 (file)
@@ -1,7 +1,9 @@
 /* $Id$ */
-
-//-------------------------------------------------------------------
+//____________________________________
+/////////////////////////////////////////////////////////////////////////
+//
 // Class AliHBTPairCut:
+//
 // implements cut on the pair of particles
 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
 // Author: Piotr.Skowronski@cern.ch
@@ -10,6 +12,7 @@
 #include "AliHBTPairCut.h"
 #include "AliHBTPair.h"
 #include "AliHBTParticleCut.h"
+#include "AliHBTTrackPoints.h"
 
 ClassImp(AliHBTPairCut)
 const Int_t AliHBTPairCut::fgkMaxCuts = 50;
@@ -225,6 +228,14 @@ void AliHBTPairCut::SetKStarRange(Double_t min, Double_t max)
   else fCuts[fNCuts++] = new AliHBTKStarCut(min,max);
 }
 /**********************************************************/
+void AliHBTPairCut::SetAvSeparationRange(Double_t min, Double_t max)
+{
+  //sets avarage separation cut ->Anti-Merging cut
+  AliHbtBasePairCut* cut= FindCut(kHbtPairCutPropAvSepar);
+  if(cut) cut->SetRange(min,max);
+  else fCuts[fNCuts++] = new AliHBTAvSeparationCut(min,max);
+}
+/**********************************************************/
 
 AliHbtBasePairCut* AliHBTPairCut::FindCut(AliHBTPairCutProperty property)
 {
@@ -299,3 +310,27 @@ ClassImp(AliHBTKtCut)
 ClassImp(AliHBTQSideCMSLCCut)
 ClassImp(AliHBTQOutCMSLCCut)
 ClassImp(AliHBTQLongCMSLCCut)
+ClassImp(AliHBTAvSeparationCut)
+
+    
+Double_t AliHBTAvSeparationCut::GetValue(AliHBTPair* pair) const 
+{
+  //chacks if avarage distance of two tracks is in given range
+  Warning("Pass","Checking Av Separation."); 
+  AliHBTTrackPoints* tpts1 = pair->Particle1()->GetTrackPoints();
+  if ( tpts1 == 0x0)
+   {
+     Warning("Pass","Track 1 does not have Track Points. Pair NOT Passed.");
+     return -10e5;
+   }
+
+  AliHBTTrackPoints* tpts2 = pair->Particle2()->GetTrackPoints();
+  if ( tpts2 == 0x0)
+   {
+     Warning("Pass","Track 2 does not have Track Points. Pair NOT Passed.");
+     return -10e5;
+   }
+   
+  return tpts1->AvarageDistance(*tpts2);
+}
+
index caf9ef6..69e86f2 100644 (file)
@@ -21,6 +21,7 @@ enum AliHBTPairCutProperty
   kHbtPairCutPropQSideCMSLC,
   kHbtPairCutPropQOutCMSLC,
   kHbtPairCutPropQLongCMSLC,
+  kHbtPairCutPropAvSepar,
   kHbtPairCutPropNone
 };
 
@@ -49,7 +50,8 @@ class AliHBTPairCut: public TNamed
   void SetQOutCMSLRange(Double_t min, Double_t max);
   void SetQSideCMSLRange(Double_t min, Double_t max);
   void SetQLongCMSLRange(Double_t min, Double_t max);
-  
+  void SetAvSeparationRange(Double_t min,Double_t max = 10e5);
+      
   AliHBTParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
   AliHBTParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
   
@@ -129,6 +131,9 @@ class AliHbtBasePairCut: public TObject
 
 inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
 {
+  //checks if pair proprty is in range
+  //null pointer check is made by AliHBTPairCut, so here is unnecesary
+  
   Double_t value = GetValue(pair);
   if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
   else return kTRUE; //rejected
@@ -209,4 +214,17 @@ class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
   ClassDef(AliHBTQLongCMSLCCut,1)
 };
 
+  
+class AliHBTAvSeparationCut: public AliHbtBasePairCut
+{
+ public:
+  AliHBTAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
+    AliHbtBasePairCut(min,max,kHbtPairCutPropAvSepar){}
+  virtual ~AliHBTAvSeparationCut(){}
+  
+ protected:
+  virtual Double_t  GetValue(AliHBTPair* pair) const;
+  ClassDef(AliHBTAvSeparationCut,1)
+};
+  
 #endif
index bc8380d..6524d8c 100644 (file)
@@ -73,7 +73,8 @@ AliHBTParticle::AliHBTParticle(const AliHBTParticle& in):
    fNPids(in.fNPids),fPids(new Int_t[fNPids]),fPidProb(new Float_t[fNPids]),
    fCalcMass(in.GetCalcMass()),
    fPx(in.Px()),fPy(in.Py()),fPz(in.Pz()),fE(in.Energy()), 
-   fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T())
+   fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T()),
+   fTrackPoints(0x0) 
 {
  //Copy constructor
  for(Int_t i = 0; i<fNPids; i++)
@@ -81,8 +82,12 @@ AliHBTParticle::AliHBTParticle(const AliHBTParticle& in):
     fPids[i] =  in.fPids[i];
     fPidProb[i] = in.fPidProb[i];
   }
+ //fTrackPoints = (in.fTrackPoints)?(AliHBTTrackPoints*)in.fTrackPoints->Clone():0x0;
   
- fTrackPoints = (in.fTrackPoints)?(AliHBTTrackPoints*)fTrackPoints->Clone():0x0;
+ if (in.fTrackPoints)
+   fTrackPoints = (AliHBTTrackPoints*)in.fTrackPoints->Clone();
+   
   
 }
 
index e23d5ed..79e5df2 100644 (file)
@@ -1,4 +1,17 @@
 #include "AliHBTTrackPoints.h"
+//_________________________________
+////////////////////////////////////////////////////////////
+//                                                        //
+// class AliHBTTrackPoints                                //
+//                                                        //
+// used by Anti-Merging cut                               //
+// contains set of poits the lay on track trajectory      //
+// according to reconstructed track parameters -          //
+// NOT CLUSTERS POSITIONS!!!                              //
+// Anti-Merging cut is applied only on tracks coming from //
+// different events (that are use to fill deniminators)   //
+//                                                        //
+////////////////////////////////////////////////////////////
 #include "AliTPCtrack.h"
 #include <TMath.h>
 #include "AliTrackReference.h"
@@ -6,6 +19,7 @@
 
 ClassImp(AliHBTTrackPoints)
 
+Int_t AliHBTTrackPoints::fgDebug = 0;
 AliHBTTrackPoints::AliHBTTrackPoints():
  fN(0),
  fX(0x0),
@@ -14,6 +28,7 @@ AliHBTTrackPoints::AliHBTTrackPoints():
 {
   //constructor
 }
+/***************************************************************/
 
 AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliTPCtrack* track, Float_t dr, Float_t r0):
  fN(n),
@@ -63,10 +78,10 @@ AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliTPCtrack* track, Float_t dr, Fl
   Double_t r = TMath::Hypot(x,y);
   
 
-  if (GetDebug()) 
+  if (GetDebug() > 9) 
     Info("AliHBTTrackPoints","Radius0 %f, Real Radius %f",r0,r); 
   
-  if (GetDebug()) 
+  if (GetDebug() > 5) 
     Info("AliHBTTrackPoints","Phi Global at first padraw %f, Phi locat %f",phi0global,phi0local);
   Double_t c=track->GetC();
   Double_t eta = track->GetEta();
@@ -97,14 +112,14 @@ AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliTPCtrack* track, Float_t dr, Fl
      fX[i] = rc*TMath::Cos(phi);
      fY[i] = rc*TMath::Sin(phi);
      
-     if ( GetDebug() )
+     if ( GetDebug() > 2 )
       {
         Info("AliHBTTrackPoints","X %f Y %f Z %f R asked %f R obtained %f",
              fX[i],fY[i],fZ[i],rc,TMath::Hypot(fX[i],fY[i]));
       }
    }
 }
-
+/***************************************************************/
 
 AliHBTTrackPoints::~AliHBTTrackPoints()
 {
@@ -113,6 +128,7 @@ AliHBTTrackPoints::~AliHBTTrackPoints()
   delete [] fY;
   delete [] fZ;
 }
+/***************************************************************/
 
 void AliHBTTrackPoints::PositionAt(Int_t n, Float_t &x,Float_t &y,Float_t &z)
 {
@@ -126,13 +142,12 @@ void AliHBTTrackPoints::PositionAt(Int_t n, Float_t &x,Float_t &y,Float_t &z)
   x = fX[n];
   y = fY[n];
   z = fZ[n];
-  if ( GetDebug() )
+  if ( GetDebug() > 1 )
     {
       Info("AliHBTTrackPoints","n %d; X %f; Y %f; Z %f",n,x,y,z);
     }
-
 }
-
+/***************************************************************/
 
 Double_t AliHBTTrackPoints::AvarageDistance(const AliHBTTrackPoints& tr)
 {
@@ -151,18 +166,39 @@ Double_t AliHBTTrackPoints::AvarageDistance(const AliHBTTrackPoints& tr)
   Double_t sum;
   for (Int_t i = 0; i<fN; i++)
    {
-      if (fR[i] != tr.fR[i])
-       {
-         Error("AvarageDistance","Different radii");
-         return -1;
-       }
-      Double_t dx = fX-tr.fX;
-      Double_t dy = fY-tr.fY;
-      Double_t dz = fZ-tr.fZ;
-      sum+=TMath::Sqrt(dx*dx + dy*dy + dz*dz);
+     if (GetDebug()>9)
+      {
+//       Float_t r1sq = fX[i]*fX[i]+fY[i]*fY[i];
+//       Float_t r2sq = tr.fX[i]*tr.fX[i]+tr.fY[i]*tr.fY[i];
+       Float_t r1sq = TMath::Hypot(fX[i],fY[i]);
+       Float_t r2sq = TMath::Hypot(tr.fX[i],tr.fY[i]);
+       Info("AvarageDistance","radii: %f %f",r1sq,r2sq);
+      } 
+
+      
+     Double_t dx = fX[i]-tr.fX[i];
+     Double_t dy = fY[i]-tr.fY[i];
+     Double_t dz = fZ[i]-tr.fZ[i];
+     sum+=TMath::Sqrt(dx*dx + dy*dy + dz*dz);
+     
+     if (GetDebug()>0)
+      {
+       Info("AvarageDistance","Diff: x ,y z: %f , %f, %f",dx,dy,dz);
+       Info("AvarageDistance","xxyyzz %f %f %f %f %f %f",
+            fX[i],tr.fX[i],fY[i],tr.fY[i],fZ[i],tr.fZ[i]);
+      } 
    }
-  return sum/((Double_t)fN);
+   
+  Double_t retval = sum/((Double_t)fN);
+  if ( GetDebug() )
+    {
+      Info("AvarageDistance","Avarage distance is %f.",retval);
+    }
+  return retval;
 }
+/***************************************************************/
+/***************************************************************/
+/***************************************************************/
 
 #include "AliRun.h"
 #include "AliRunLoader.h"
index 798d742..a0de4a0 100644 (file)
@@ -1,6 +1,18 @@
 #ifndef ALIHBTTRACKPOINTS_H
 #define ALIHBTTRACKPOINTS_H
-
+//_________________________________
+////////////////////////////////////////////////////////////
+//                                                        //
+// class AliHBTTrackPoints                                //
+//                                                        //
+// used by Anti-Merging cut                               //
+// contains set of poits the lay on track trajectory      //
+// according to reconstructed track parameters -          //
+// NOT CLUSTERS POSITIONS!!!                              //
+// Anti-Merging cut is applied only on tracks coming from //
+// different events (that are use to fill deniminators)   //
+//                                                        //
+////////////////////////////////////////////////////////////
 #include <TObject.h>
 
 class AliTPCtrack;
@@ -16,7 +28,8 @@ class AliHBTTrackPoints: public TObject
     
     Double_t AvarageDistance(const AliHBTTrackPoints& tr);
     void PositionAt(Int_t n, Float_t &x, Float_t &y, Float_t &z);
-    Int_t GetDebug() const {return 10;}
+    Int_t GetDebug() const {return fgDebug;}
+    void  SetDebug(Int_t deblevel){fgDebug = deblevel;} 
     static void tp(Int_t entr);
   protected:
   private:
@@ -24,8 +37,8 @@ class AliHBTTrackPoints: public TObject
     Float_t* fX;//[fN]
     Float_t* fY;//[fN]
     Float_t* fZ;//[fN]
-    Float_t* fR;//! [fN] radii
-    
+//    Float_t* fR;//! [fN] radii
+    static Int_t fgDebug;//! debug level
     ClassDef(AliHBTTrackPoints,1)
 };
 #endif
index b2f0188..0fad6c9 100644 (file)
@@ -48,7 +48,8 @@
 #pragma link C++ class AliHBTQSideCMSLCCut+;
 #pragma link C++ class AliHBTQOutCMSLCCut+;
 #pragma link C++ class AliHBTQLongCMSLCCut+;
-
+#pragma link C++ class AliHBTAvSeparationCut+;
+    
 #pragma link C++ class AliHBTMomentumCut+;
 #pragma link C++ class AliHBTPtCut+;
 #pragma link C++ class AliHBTEnergyCut+;
index 2ffa506..14ae5dd 100644 (file)
@@ -24,6 +24,8 @@ void hbtanalysis(Option_t* datatype, Option_t* processopt="TracksAndParticles",
                 Int_t first = -1,Int_t last = -1, 
                 char *outfile = "hbtanalysis.root")
  {
+   
+  AliHBTTrackPoints::SetDebug(1);
 //HBT Anlysis Macro
 //Anlyzes TPC recontructed tracks and simulated particles that corresponds to them
 
@@ -49,6 +51,7 @@ void hbtanalysis(Option_t* datatype, Option_t* processopt="TracksAndParticles",
 //  const char* basedir="rfio:/castor/cern.ch/user/s/skowron/";
 //  const char* serie="standard";
 //  const char* field = "0.4";
+
   const char* basedir=".";
   const char* serie="";
   const char* field = "";
@@ -88,6 +91,7 @@ void hbtanalysis(Option_t* datatype, Option_t* processopt="TracksAndParticles",
   else if(!TPC)
    {
     reader = new AliHBTReaderTPC();
+    ((AliHBTReaderTPC*)reader)->SetNumberOfTrackPoints(5,30.);
    }
   else if(!ITSv1)
    {
@@ -137,6 +141,22 @@ void hbtanalysis(Option_t* datatype, Option_t* processopt="TracksAndParticles",
   
   analysis->SetReader(reader);
 
+  AliHBTPairCut *paircut = new AliHBTPairCut();
+  Float_t qinvmin = 0.0;
+  Float_t qinvmax = 0.05;//50MeV
+  paircut->SetQInvRange(qinvmin,qinvmax);  
+  
+ // paircut->SetAvSeparationRange(10.,10000.);  
+  
+//  AliHBTParticleCut* partcut= new AliHBTParticleCut();
+//  partcut->SetPID(kPiPlus);
+//  paircut->SetFirstPartCut(partcut);
+//  partcut->SetPID(kPiMinus);
+//  paircut->SetSecondPartCut(partcut);
+  
+  analysis->SetGlobalPairCut(paircut);
+  analysis->SetAntiMergingCut(5.);//in cm
+  
   /***********************************************************/    
   /*****   W E I G H T S        ******************************/    
   /***********************************************************/    
@@ -152,27 +172,15 @@ void hbtanalysis(Option_t* datatype, Option_t* processopt="TracksAndParticles",
   AliHBTLLWeights::Instance()->Set();
 
   //example function
-  AliHBTWeightTheorQInvFctn  *wqinvcfP = new AliHBTWeightTheorQInvFctn(nbins,qmax);
-  wqinvcfP->SetNumberOfBinsToScale(binstoscale);
-  wqinvcfP->Rename("wqinvcfP","Lednicky Q_{inv} Theoretical Correlation Function "+system);
+  AliHBTWeightTheorQInvFctn  *wqinvcfP = new AliHBTWeightTheorQInvFctn(100,qinvmax);
+  wqinvcfP->SetNumberOfBinsToScale(30);
+  wqinvcfP->Rename("wqinvcfP","Lednicky Q_{inv} Theoretical Correlation Function");
   analysis->AddParticleFunction(wqinvcfP);
 
   /************************************************************/
   /****   Q INV Correlation Function   ************************/
   /************************************************************/
    
-  AliHBTPairCut *paircut = new AliHBTPairCut();
-  Float_t qinvmin = 0.0;
-  Float_t qinvmax = 0.05;//50MeV
-  paircut->SetQInvRange(qinvmin,qinvmax);  
-  
-//  AliHBTParticleCut* partcut= new AliHBTParticleCut();
-//  partcut->SetPID(kPiPlus);
-//  paircut->SetFirstPartCut(partcut);
-//  partcut->SetPID(kPiMinus);
-//  paircut->SetSecondPartCut(partcut);
-  
-//  analysis->SetGlobalPairCut(paircut);
 
   AliHBTQInvCorrelFctn * qinvcfT = new AliHBTQInvCorrelFctn(100,qinvmax);
   AliHBTQInvCorrelFctn * qinvcfP = new AliHBTQInvCorrelFctn(100,qinvmax);