Chages concerning coding convetion requirements.
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Nov 2003 08:58:39 +0000 (08:58 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Nov 2003 08:58:39 +0000 (08:58 +0000)
HBTAN/AliHBTParticleCut.cxx
HBTAN/AliHBTParticleCut.h

index 838781f..4657a3f 100644 (file)
@@ -1,14 +1,36 @@
+//__________________________________________________________________________
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+// class AliHBTParticleCut                                                //
+//                                                                        //
+// Classes for single particle cuts                                       //
+// User should use only AliHBTParticleCut, eventually                     //
+// EmptyCut which passes all particles                                    //
+// There is all interface for setting cuts on all particle properties     //
+// The main method is Pass - which returns                                //
+//         True to reject particle                                        //
+//         False in case it meets all the criteria of the given cut       //
+//                                                                        //
+// User should create (and also destroy) cuts himself                     // 
+// and then pass them to the Analysis And Function by a proper method     //
+//                                                                        //
+//                                                                        //
+// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html   //
+// resonsible: Piotr Skowronski@cern.ch                                   //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
 #include "AliHBTParticleCut.h"
 
 #include <Riostream.h>
 
 ClassImp(AliHBTParticleCut)
-const Int_t AliHBTParticleCut::fkgMaxCuts = 50;
+const Int_t AliHBTParticleCut::fgkMaxCuts = 50;
 /******************************************************************/
 
 AliHBTParticleCut::AliHBTParticleCut()
  {
-   fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
+   //default ctor
+   fCuts = new AliHbtBaseCut* [fgkMaxCuts];//last property in the property
                                          //property enum => defines number of properties
    fNCuts = 0;
    fPID  = 0;
@@ -16,9 +38,10 @@ AliHBTParticleCut::AliHBTParticleCut()
 /******************************************************************/
 
 AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in):
- TObject()
+ TObject(in)
 {
-  fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
+  //cpy ctor
+  fCuts = new AliHbtBaseCut* [fgkMaxCuts];//last property in the property
                                          //property enum => defines number of properties
   fNCuts = in.fNCuts;
   fPID  = in.fPID;
@@ -28,9 +51,27 @@ AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in):
    }
 }
 /******************************************************************/
+const AliHBTParticleCut& AliHBTParticleCut::operator = (const AliHBTParticleCut& in)
+{
+  //assigment operator
+  for (Int_t i = 0;i<fNCuts;i++)
+   {
+     delete fCuts[i];
+   }
 
+  fNCuts = in.fNCuts;
+  fPID  = in.fPID;
+  for (Int_t i = 0;i<fNCuts;i++)
+   {
+     fCuts[i] = (AliHbtBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+   }
+  return *this;
+}    
+
+/******************************************************************/
 AliHBTParticleCut::~AliHBTParticleCut()
 {
+  //dtor
   for (Int_t i = 0;i<fNCuts;i++)
    {
      delete fCuts[i];
@@ -63,7 +104,7 @@ void AliHBTParticleCut::AddBasePartCut(AliHbtBaseCut* basecut)
   //adds the base pair cut (cut on one value)
  
    if (!basecut) return;
-   if( fNCuts == (fkgMaxCuts-1) )
+   if( fNCuts == (fgkMaxCuts-1) )
     {
       Warning("AddBasePartCut","Not enough place for another cut");
       return;
@@ -75,7 +116,7 @@ void AliHBTParticleCut::AddBasePartCut(AliHbtBaseCut* basecut)
 /******************************************************************/
 AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty property)
 {
+ //returns pointer to the cut checking the given property
  for (Int_t i = 0;i<fNCuts;i++)
   {
     if (fCuts[i]->GetProperty() == property) 
@@ -89,6 +130,7 @@ AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty property)
 
 void AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max)
 {
+  //Sets momentum range
   AliHBTMomentumCut* cut= (AliHBTMomentumCut*)FindCut(kHbtP);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTMomentumCut(min,max);
@@ -98,6 +140,7 @@ void AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHBTPtCut* cut= (AliHBTPtCut*)FindCut(kHbtPt);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTPtCut(min,max);
@@ -107,6 +150,7 @@ void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHBTEnergyCut* cut= (AliHBTEnergyCut*)FindCut(kHbtE);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTEnergyCut(min,max);
@@ -116,6 +160,7 @@ void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtRapidity);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTRapidityCut(min,max);
@@ -125,6 +170,7 @@ void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtPseudoRapidity);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTPseudoRapidityCut(min,max);
@@ -134,6 +180,7 @@ void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtPx);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTPxCut(min,max);
@@ -142,6 +189,7 @@ void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max)
 {  
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtPy);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTPyCut(min,max);
@@ -150,6 +198,7 @@ void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtPz);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTPzCut(min,max);
@@ -158,6 +207,7 @@ void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtPhi);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTPhiCut(min,max);
@@ -166,6 +216,7 @@ void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtTheta);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTThetaCut(min,max);
@@ -174,6 +225,7 @@ void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtVx);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTVxCut(min,max);
@@ -182,6 +234,7 @@ void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtVy);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTVyCut(min,max);
@@ -190,6 +243,7 @@ void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max)
 
 void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max)
 {
+  //name self descriptive
   AliHbtBaseCut* cut = FindCut(kHbtVz);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliHBTVzCut(min,max);
@@ -198,7 +252,7 @@ void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max)
 /******************************************************************/
 void AliHBTParticleCut::Streamer(TBuffer &b)
 {
-     // Stream all objects in the array to or from the I/O buffer.
+  // Stream all objects in the array to or from the I/O buffer.
 
    UInt_t R__s, R__c;
    if (b.IsReading()) 
@@ -228,9 +282,11 @@ void AliHBTParticleCut::Streamer(TBuffer &b)
      b.SetByteCount(R__c, kTRUE);
    }
 }
+/******************************************************************/
 
-void AliHBTParticleCut::Print(void)
+void AliHBTParticleCut::Print(void) const
 {
+  //prints all information about the cut to stdout
   cout<<"Printing AliHBTParticleCut, this = "<<this<<endl;
   cout<<"fPID  "<<fPID<<endl;
   cout<<"fNCuts  "<<fNCuts <<endl;
@@ -247,6 +303,7 @@ void AliHBTParticleCut::Print(void)
 ClassImp(AliHBTEmptyParticleCut)
 void AliHBTEmptyParticleCut::Streamer(TBuffer &b)
  {
+  //stramer
   AliHBTParticleCut::Streamer(b);
  }
 /******************************************************************/
@@ -258,13 +315,17 @@ void AliHBTEmptyParticleCut::Streamer(TBuffer &b)
 /******************************************************************/
 
 ClassImp(AliHbtBaseCut)
-void AliHbtBaseCut::Print(void)
+void AliHbtBaseCut::Print(void) const
 {
+  // prints the information anout the base cut to stdout
   cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
   PrintProperty();
 }
-void AliHbtBaseCut::PrintProperty(void)
+/******************************************************************/
+
+void AliHbtBaseCut::PrintProperty(void) const
 {
+ //prints the property name 
  switch (fProperty)
   {
    case  kHbtP: 
@@ -324,7 +385,7 @@ AliHBTLogicalOperCut::AliHBTLogicalOperCut():
  fFirst(new AliHBTDummyBaseCut),
  fSecond(new AliHBTDummyBaseCut)
 {
-
+ //ctor
 }
 /******************************************************************/
 
@@ -333,6 +394,7 @@ AliHBTLogicalOperCut::AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut*
  fFirst((first)?(AliHbtBaseCut*)first->Clone():0x0),
  fSecond((second)?(AliHbtBaseCut*)second->Clone():0x0)
 {
+  //ctor
   if ( (fFirst && fSecond) == kFALSE) 
    {
      Fatal("AliHBTLogicalOperCut","One of parameters is NULL!");
@@ -342,7 +404,7 @@ AliHBTLogicalOperCut::AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut*
 
 AliHBTLogicalOperCut::~AliHBTLogicalOperCut()
 {
-//destructor
+  //destructor
   delete fFirst;
   delete fSecond;
 }
@@ -350,6 +412,7 @@ AliHBTLogicalOperCut::~AliHBTLogicalOperCut()
 
 Bool_t AliHBTLogicalOperCut::AliHBTDummyBaseCut::Pass(AliHBTParticle* /*part*/)
 {
+  //checks if particles passes properties defined by this cut
   Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
   return kFALSE;//accept
 }
index 44ca8dd..8fd1335 100644 (file)
@@ -1,15 +1,24 @@
-//Piotr Skowronski@cern.ch
-//Classes fAnd single particle cuts
-//User should use only AliHBTParticleCut, eventually EmptyCut which passes all particles
-//There is all interface fAnd setting cuts on all particle properties
-//The main method is Pass - which returns 
-//        True in Andder to reject particle
-//        False in case it meets all the criteria of the given cut
-//
-//User should create (and also destroy) cuts himself 
-//and then pass them to the Analysis And Function by a proper method
-//
-//mAnde info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
+//__________________________________________________________________________
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+// class AliHBTParticleCut                                                //
+//                                                                        //
+// Classes for single particle cuts                                       //
+// User should use only AliHBTParticleCut, eventually                     //
+// EmptyCut which passes all particles                                    //
+// There is all interface for setting cuts on all particle properties     //
+// The main method is Pass - which returns                                //
+//         True to reject particle                                        //
+//         False in case it meets all the criteria of the given cut       //
+//                                                                        //
+// User should create (and also destroy) cuts himself                     // 
+// and then pass them to the Analysis And Function by a proper method     //
+//                                                                        //
+//                                                                        //
+// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html   //
+// resonsible: Piotr Skowronski@cern.ch                                   //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
 
 
 #ifndef ALIHBTPARTICLECUT_H
@@ -60,13 +69,14 @@ class AliHBTParticleCut: public TObject
 //Class describing cut on pairs of particles
   public:
     AliHBTParticleCut();
-    AliHBTParticleCut(const AliHBTParticleCut&);
+    AliHBTParticleCut(const AliHBTParticleCut& in);
     virtual ~AliHBTParticleCut();
-
-    virtual Bool_t Pass(AliHBTParticle*);
-    Bool_t IsEmpty() {return kFALSE;}
+    const AliHBTParticleCut& operator = (const AliHBTParticleCut& in);
+    
+    virtual Bool_t Pass(AliHBTParticle* p);
+    Bool_t IsEmpty() const {return kFALSE;}
     
-    void AddBasePartCut(AliHbtBaseCut*);
+    void AddBasePartCut(AliHbtBaseCut* basecut);
     
     Int_t GetPID() const { return fPID;}
     void SetPID(Int_t pid){fPID=pid;}
@@ -86,21 +96,20 @@ class AliHBTParticleCut: public TObject
     void SetVyRange(Double_t min, Double_t max);
     void SetVzRange(Double_t min, Double_t max);
     
-    void Print(void);
+    void Print(void) const;
   protected:
      
-     AliHbtBaseCut* FindCut(AliHBTCutProperty);
-     
-     AliHbtBaseCut ** fCuts;//! Array with cuts
-     Int_t fNCuts;
+    AliHbtBaseCut* FindCut(AliHBTCutProperty property);
 
-     Int_t fPID; //particle PID  - if=0 (rootino) all pids are accepted
+    AliHbtBaseCut ** fCuts;//! Array with cuts
+    Int_t fNCuts; //number of base cuts stored in fCuts
+
+    Int_t fPID; //particle PID  - if=0 (rootino) all pids are accepted
           
   private:
-     static const Int_t fkgMaxCuts;
-  public:
+    static const Int_t fgkMaxCuts; //Size of the fCuts array
+
     ClassDef(AliHBTParticleCut,1)
 };
 /******************************************************************/
 /******************************************************************/
@@ -114,8 +123,8 @@ class AliHBTEmptyParticleCut:  public AliHBTParticleCut
     AliHBTEmptyParticleCut(){};
     virtual ~AliHBTEmptyParticleCut(){};
     
-    Bool_t Pass(AliHBTParticle*){return kFALSE;} //accpept everything
-    Bool_t IsEmpty() {return kTRUE;}
+    Bool_t Pass(AliHBTParticle*){return kFALSE;} //accept everything <<CAN NOT BE const!!!!>>
+    Bool_t IsEmpty() const {return kTRUE;}
 
     ClassDef(AliHBTEmptyParticleCut,1)
  
@@ -148,27 +157,28 @@ class AliHbtBaseCut: public TObject
      Double_t          GetMaximum() const {return fMax;}
      
      AliHBTCutProperty GetProperty() const {return fProperty;}
-     virtual void Print(void);
+     virtual void Print(void) const;
      
    protected:
-     virtual Double_t  GetValue(AliHBTParticle *) = 0;
+     virtual Double_t  GetValue(AliHBTParticle *) const = 0;
 
-     AliHBTCutProperty fProperty;
-     Double_t fMin;
-     Double_t fMax;
+     AliHBTCutProperty fProperty; //property that this cut describes
+     Double_t fMin;//minimum value
+     Double_t fMax;//maximum value
      
    private:
-     void PrintProperty(void);
+     void PrintProperty(void) const;
      ClassDef(AliHbtBaseCut,1)
    
  };
 
 inline Bool_t
 AliHbtBaseCut::Pass(AliHBTParticle *p)
- {
-   if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
-   else return kFALSE; //accepted
- }
+{
+  //cjecks if particle property fits in range
+  if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
+  else return kFALSE; //accepted
+}
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
@@ -180,7 +190,7 @@ class AliHBTMomentumCut: public AliHbtBaseCut
     AliHBTMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtP){}
     virtual ~AliHBTMomentumCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->P();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->P();}
     ClassDef(AliHBTMomentumCut,1)
  };
 
@@ -190,7 +200,7 @@ class AliHBTPtCut: public AliHbtBaseCut
     AliHBTPtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPt){}
     virtual ~AliHBTPtCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Pt();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Pt();}
     ClassDef(AliHBTPtCut,1)
  };
 
@@ -201,7 +211,7 @@ class AliHBTEnergyCut: public AliHbtBaseCut
     AliHBTEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtE){}
     virtual ~AliHBTEnergyCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Energy();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Energy();}
     ClassDef(AliHBTEnergyCut,1)
  };
 
@@ -211,7 +221,7 @@ class AliHBTRapidityCut: public AliHbtBaseCut
     AliHBTRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtRapidity){}
     virtual ~AliHBTRapidityCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Y();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Y();}
     ClassDef(AliHBTRapidityCut,1)
  };
 
@@ -221,7 +231,7 @@ class AliHBTPseudoRapidityCut: public AliHbtBaseCut
     AliHBTPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPseudoRapidity){}
     virtual ~AliHBTPseudoRapidityCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Eta();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Eta();}
     ClassDef(AliHBTPseudoRapidityCut,1)
  };
 
@@ -231,7 +241,7 @@ class AliHBTPxCut: public AliHbtBaseCut
     AliHBTPxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPx){}
     virtual ~AliHBTPxCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Px();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Px();}
     ClassDef(AliHBTPxCut,1)
  };
 
@@ -241,7 +251,7 @@ class AliHBTPyCut: public AliHbtBaseCut
     AliHBTPyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPy){}
     virtual ~AliHBTPyCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Py();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Py();}
     ClassDef(AliHBTPyCut,1)
  };
 
@@ -252,7 +262,7 @@ class AliHBTPzCut: public AliHbtBaseCut
     AliHBTPzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPz){}
     virtual ~AliHBTPzCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Pz();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Pz();}
     ClassDef(AliHBTPzCut,1)
  };
 
@@ -262,7 +272,7 @@ class AliHBTPhiCut: public AliHbtBaseCut
     AliHBTPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPhi){}
     virtual ~AliHBTPhiCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Phi();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Phi();}
     ClassDef(AliHBTPhiCut,1)
   
  };
@@ -273,7 +283,7 @@ class AliHBTThetaCut: public AliHbtBaseCut
     AliHBTThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtTheta){}
     virtual ~AliHBTThetaCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Theta();}
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Theta();}
     ClassDef(AliHBTThetaCut,1)
   
  };
@@ -285,7 +295,7 @@ class AliHBTVxCut: public AliHbtBaseCut
     AliHBTVxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVx){}
     virtual ~AliHBTVxCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Vx();} //retruns value of the vertex
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Vx();} //retruns value of the vertex
     ClassDef(AliHBTVxCut,1)
   
  };
@@ -298,7 +308,7 @@ class AliHBTVyCut: public AliHbtBaseCut
     AliHBTVyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVy){}
     virtual ~AliHBTVyCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Vy();} //retruns value of the vertex
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Vy();} //retruns value of the vertex
     ClassDef(AliHBTVyCut,1)
   
  };
@@ -310,7 +320,7 @@ class AliHBTVzCut: public AliHbtBaseCut
     AliHBTVzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVz){}
     virtual ~AliHBTVzCut(){}
   protected:
-    Double_t  GetValue(AliHBTParticle * p){return p->Vz();} //retruns value of the vertex
+    Double_t  GetValue(AliHBTParticle * p)const{return p->Vz();} //retruns value of the vertex
     
     ClassDef(AliHBTVzCut,1)
   
@@ -323,7 +333,7 @@ class AliHBTPIDCut:  public AliHbtBaseCut
      AliHBTPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliHbtBaseCut(min,max,kHbtPid),fPID(pid){}
      virtual ~AliHBTPIDCut(){}
    protected:
-     Double_t  GetValue(AliHBTParticle * p){return p->GetPIDprobability(fPID);}
+     Double_t  GetValue(AliHBTParticle * p)const{return p->GetPIDprobability(fPID);}
      Int_t     fPID; //pid of particle that the pid is set 
      ClassDef(AliHBTPIDCut,1)
  };
@@ -343,14 +353,14 @@ class AliHBTLogicalOperCut:  public AliHbtBaseCut
      AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second);
      virtual   ~AliHBTLogicalOperCut();
    protected:
-     Double_t  GetValue(AliHBTParticle * /*part*/){MayNotUse("GetValue");return 0.0;}
+     Double_t  GetValue(AliHBTParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
      
      AliHbtBaseCut* fFirst;   //second cut
      AliHbtBaseCut* fSecond;  //first cut
    private:  
     class  AliHBTDummyBaseCut: public AliHbtBaseCut 
      {
-       Double_t  GetValue(AliHBTParticle * /*part*/){return 0.0;}
+       Double_t  GetValue(AliHBTParticle * /*part*/) const {return 0.0;}
        Bool_t    Pass(AliHBTParticle* /*part*/);
      };