Standarized naming schema for cuts
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 5 Jul 2004 13:49:59 +0000 (13:49 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 5 Jul 2004 13:49:59 +0000 (13:49 +0000)
13 files changed:
ANALYSIS/ANALYSISLinkDef.h
ANALYSIS/AliAODPairCut.cxx
ANALYSIS/AliAODPairCut.h
ANALYSIS/AliAODParticleCut.cxx
ANALYSIS/AliAODParticleCut.h
ANALYSIS/AliAnalysis.cxx
ANALYSIS/AliEventBaseCut.cxx [moved from ANALYSIS/AliBaseEventCut.cxx with 90% similarity]
ANALYSIS/AliEventBaseCut.h [moved from ANALYSIS/AliBaseEventCut.h with 72% similarity]
ANALYSIS/AliEventCut.cxx
ANALYSIS/AliEventCut.h
ANALYSIS/libANALYSIS.pkg
HBTAN/AliHBTFunction.cxx
HBTAN/AliHBTMonitorFunction.cxx

index 1cf46dfe21e61898947cd4c98abef43516ad509e..e227f285583a44862c8d9ee34b33d8a3b2f4be31 100644 (file)
@@ -27,8 +27,8 @@
 #pragma link C++ class AliFlowAnalysis+;
 
 #pragma link C++ class AliEventCut+;
 #pragma link C++ class AliFlowAnalysis+;
 
 #pragma link C++ class AliEventCut+;
-#pragma link C++ class AliEmptyEventCut+;
-#pragma link C++ class AliBaseEventCut+;
+#pragma link C++ class AliEventEmptyCut+;
+#pragma link C++ class AliEventBaseCut+;
 
 #pragma link C++ class AliPrimVertexXCut+;
 #pragma link C++ class AliPrimVertexYCut+;
 
 #pragma link C++ class AliPrimVertexXCut+;
 #pragma link C++ class AliPrimVertexYCut+;
@@ -36,8 +36,8 @@
 #pragma link C++ class AliNChargedCut+;
 
 #pragma link C++ class AliAODParticleCut-;
 #pragma link C++ class AliNChargedCut+;
 
 #pragma link C++ class AliAODParticleCut-;
-#pragma link C++ class AliAODEmptyParticleCut-;
-#pragma link C++ class AliAODBaseCut+;
+#pragma link C++ class AliAODParticleEmptyCut-;
+#pragma link C++ class AliAODParticleBaseCut+;
 
 #pragma link C++ class AliAODMomentumCut+;
 #pragma link C++ class AliAODPtCut+;
 
 #pragma link C++ class AliAODMomentumCut+;
 #pragma link C++ class AliAODPtCut+;
@@ -59,8 +59,8 @@
 
 
 #pragma link C++ class AliAODPairCut-;
 
 
 #pragma link C++ class AliAODPairCut-;
-#pragma link C++ class AliAODEmptyPairCut-;
-#pragma link C++ class AliAODBasePairCut+;
+#pragma link C++ class AliAODPairEmptyCut-;
+#pragma link C++ class AliAODPairBaseCut+;
 
 #pragma link C++ class AliAODQInvCut+;
 #pragma link C++ class AliAODKtCut+;
 
 #pragma link C++ class AliAODQInvCut+;
 #pragma link C++ class AliAODKtCut+;
index 3f7f2b06e8115690b88a4296a773d75c46ca2141..44b63629ef31f930c38a1439733561f859792c31 100644 (file)
@@ -23,10 +23,10 @@ AliAODPairCut::AliAODPairCut():
   fNCuts(0)
 {
   //constructor
   fNCuts(0)
 {
   //constructor
-  fFirstPartCut = new AliAODEmptyParticleCut(); //empty cuts
-  fSecondPartCut= new AliAODEmptyParticleCut(); //empty cuts
+  fFirstPartCut = new AliAODParticleEmptyCut(); //empty cuts
+  fSecondPartCut= new AliAODParticleEmptyCut(); //empty cuts
     
     
-  fCuts = new AliAODBasePairCut*[fgkMaxCuts];
+  fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
   for (Int_t i = 0;i<fNCuts;i++)
    {
      fCuts[i] = 0x0;
   for (Int_t i = 0;i<fNCuts;i++)
    {
      fCuts[i] = 0x0;
@@ -38,7 +38,7 @@ AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
  TNamed(in)
 {
   //copy constructor
  TNamed(in)
 {
   //copy constructor
-  fCuts = new AliAODBasePairCut*[fgkMaxCuts];
+  fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
   fNCuts = in.fNCuts;
 
   fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
   fNCuts = in.fNCuts;
 
   fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
@@ -46,7 +46,7 @@ AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
  
   for (Int_t i = 0;i<fNCuts;i++)
     {
  
   for (Int_t i = 0;i<fNCuts;i++)
     {
-      fCuts[i] = (AliAODBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+      fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
     }
 }
 /**********************************************************/
     }
 }
 /**********************************************************/
@@ -54,7 +54,7 @@ AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
 AliAODPairCut&  AliAODPairCut::operator=(const AliAODPairCut& in)
 {
   //assignment operator
 AliAODPairCut&  AliAODPairCut::operator=(const AliAODPairCut& in)
 {
   //assignment operator
-  fCuts = new AliAODBasePairCut*[fgkMaxCuts];
+  fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
   fNCuts = in.fNCuts;
 
   fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
   fNCuts = in.fNCuts;
 
   fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
@@ -62,7 +62,7 @@ AliAODPairCut&  AliAODPairCut::operator=(const AliAODPairCut& in)
  
   for (Int_t i = 0;i<fNCuts;i++)
     {
  
   for (Int_t i = 0;i<fNCuts;i++)
     {
-      fCuts[i] = (AliAODBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+      fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
     }
   return * this;
 }
     }
   return * this;
 }
@@ -86,7 +86,7 @@ AliAODPairCut::~AliAODPairCut()
 
 /**********************************************************/
 
 
 /**********************************************************/
 
-void AliAODPairCut::AddBasePairCut(AliAODBasePairCut* basecut)
+void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
 {
   //adds the base pair cut (cut on one value)
   
 {
   //adds the base pair cut (cut on one value)
   
@@ -247,7 +247,7 @@ void AliAODPairCut::SetKStarRange(Double_t min, Double_t max)
 void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
 {
   //sets avarage separation cut ->Anti-Merging cut
 void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
 {
   //sets avarage separation cut ->Anti-Merging cut
-  AliAODBasePairCut* cut= FindCut(kHbtPairCutPropAvSepar);
+  AliAODPairBaseCut* cut= FindCut(kHbtPairCutPropAvSepar);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
 }
@@ -280,13 +280,13 @@ void AliAODPairCut::SetClusterOverlapRange(Double_t min,Double_t max)
   // splitted track: one particle that is recontructed twise
   // STAR uses range from -0.5 to 0.6 
   
   // splitted track: one particle that is recontructed twise
   // STAR uses range from -0.5 to 0.6 
   
-  AliAODBasePairCut* cut= FindCut(kHbtPairCutPropClOverlap);
+  AliAODPairBaseCut* cut= FindCut(kHbtPairCutPropClOverlap);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
 }
 /**********************************************************/
 
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
 }
 /**********************************************************/
 
-AliAODBasePairCut* AliAODPairCut::FindCut(AliAODPairCutProperty property)
+AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairCutProperty property)
 {
   // Find the cut corresponding to "property"
   for (Int_t i = 0;i<fNCuts;i++)
 {
   // Find the cut corresponding to "property"
   for (Int_t i = 0;i<fNCuts;i++)
@@ -346,16 +346,16 @@ void AliAODPairCut::Streamer(TBuffer &b)
 }
 /******************************************************************/
 
 }
 /******************************************************************/
 
-ClassImp(AliAODEmptyPairCut)
+ClassImp(AliAODPairEmptyCut)
   
   
-void AliAODEmptyPairCut::Streamer(TBuffer &b)
+void AliAODPairEmptyCut::Streamer(TBuffer &b)
 {
 //streamer for empty pair cut
   AliAODPairCut::Streamer(b);
 }
 /******************************************************************/
 
 {
 //streamer for empty pair cut
   AliAODPairCut::Streamer(b);
 }
 /******************************************************************/
 
-ClassImp(AliAODBasePairCut)
+ClassImp(AliAODPairBaseCut)
 ClassImp(AliAODQInvCut)
 ClassImp(AliAODKtCut)
 ClassImp(AliAODQSideLCMSCut)
 ClassImp(AliAODQInvCut)
 ClassImp(AliAODKtCut)
 ClassImp(AliAODQSideLCMSCut)
@@ -520,7 +520,7 @@ Bool_t AliAODOutSideDiffSignCut::Pass(AliAODPair *p) const
 ClassImp( AliAODLogicalOperPairCut )
 
 AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
 ClassImp( AliAODLogicalOperPairCut )
 
 AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
- AliAODBasePairCut(-10e10,10e10,kHbtPairCutPropNone),
+ AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
  fFirst(new AliAODDummyBasePairCut),
  fSecond(new AliAODDummyBasePairCut)
 {
  fFirst(new AliAODDummyBasePairCut),
  fSecond(new AliAODDummyBasePairCut)
 {
@@ -528,10 +528,10 @@ AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
 }
 /******************************************************************/
 
 }
 /******************************************************************/
 
-AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):
- AliAODBasePairCut(-10e10,10e10,kHbtPairCutPropNone),
- fFirst((first)?(AliAODBasePairCut*)first->Clone():0x0),
- fSecond((second)?(AliAODBasePairCut*)second->Clone():0x0)
+AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):
+ AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
+ fFirst((first)?(AliAODPairBaseCut*)first->Clone():0x0),
+ fSecond((second)?(AliAODPairBaseCut*)second->Clone():0x0)
 {
   //ctor
   //note that base cuts are copied, not just pointers assigned
 {
   //ctor
   //note that base cuts are copied, not just pointers assigned
index cb7a824f01899015b3a58f0f47aade349852d321..0a83057840bfef379c00b903c08af1ef4e79b19b 100644 (file)
@@ -12,7 +12,7 @@
 #include "AliAODPair.h"
 
 class AliAODParticleCut;
 #include "AliAODPair.h"
 
 class AliAODParticleCut;
-class AliAODBasePairCut;
+class AliAODPairBaseCut;
 
 enum AliAODPairCutProperty
 {
 
 enum AliAODPairCutProperty
 {
@@ -51,7 +51,7 @@ class AliAODPairCut: public TNamed
   
   void SetPartCut(AliAODParticleCut* cut);//sets the the same cut on both particles
   
   
   void SetPartCut(AliAODParticleCut* cut);//sets the the same cut on both particles
   
-  virtual void AddBasePairCut(AliAODBasePairCut* cut);
+  virtual void AddBasePairCut(AliAODPairBaseCut* cut);
   
   virtual void Print();
   
   
   virtual void Print();
   
@@ -72,11 +72,11 @@ class AliAODPairCut: public TNamed
   AliAODParticleCut*      fFirstPartCut;//cut on first particle in pair
   AliAODParticleCut*      fSecondPartCut;//cut on second particle in pair
   
   AliAODParticleCut*      fFirstPartCut;//cut on first particle in pair
   AliAODParticleCut*      fSecondPartCut;//cut on second particle in pair
   
-  AliAODBasePairCut** fCuts; //! array of poiters to base cuts
+  AliAODPairBaseCut** fCuts; //! array of poiters to base cuts
   Int_t fNCuts;//Number of cuts in fCuts array
   
   
   Int_t fNCuts;//Number of cuts in fCuts array
   
   
-  AliAODBasePairCut* FindCut(AliAODPairCutProperty cut);
+  AliAODPairBaseCut* FindCut(AliAODPairCutProperty cut);
  private:
   static const Int_t fgkMaxCuts; // Max number of cuts
   ClassDef(AliAODPairCut,2)
  private:
   static const Int_t fgkMaxCuts; // Max number of cuts
   ClassDef(AliAODPairCut,2)
@@ -85,19 +85,19 @@ class AliAODPairCut: public TNamed
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-class AliAODEmptyPairCut:  public AliAODPairCut
+class AliAODPairEmptyCut:  public AliAODPairCut
 {
   //Empty - it passes possitively all particles - it means returns always False
   //Class describing cut on pairs of particles
  public:
 {
   //Empty - it passes possitively all particles - it means returns always False
   //Class describing cut on pairs of particles
  public:
-  AliAODEmptyPairCut(){};
-  AliAODEmptyPairCut(const AliAODEmptyPairCut& in):AliAODPairCut(in){};
-  virtual ~AliAODEmptyPairCut(){};
+  AliAODPairEmptyCut(){};
+  AliAODPairEmptyCut(const AliAODPairEmptyCut& in):AliAODPairCut(in){};
+  virtual ~AliAODPairEmptyCut(){};
   
   Bool_t Pass(AliAODPair*) const {return kFALSE;} //accpept everything
   Bool_t IsEmpty() const {return kTRUE;}
   
   
   Bool_t Pass(AliAODPair*) const {return kFALSE;} //accpept everything
   Bool_t IsEmpty() const {return kTRUE;}
   
-  ClassDef(AliAODEmptyPairCut,1)
+  ClassDef(AliAODPairEmptyCut,1)
 };
 
 
 };
 
 
@@ -106,17 +106,17 @@ class AliAODEmptyPairCut:  public AliAODPairCut
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-class AliAODBasePairCut: public TObject
+class AliAODPairBaseCut: public TObject
 {
   //This class defines the range of some property - pure virtual
   //Property is coded by AliAODCutTypes type
    
  public:
      
 {
   //This class defines the range of some property - pure virtual
   //Property is coded by AliAODCutTypes type
    
  public:
      
-  AliAODBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliAODPairCutProperty prop= kHbtPairCutPropNone):
+  AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, AliAODPairCutProperty prop= kHbtPairCutPropNone):
     fMin(min),fMax(max),fProperty(prop){}
   
     fMin(min),fMax(max),fProperty(prop){}
   
-  virtual   ~AliAODBasePairCut(){}
+  virtual   ~AliAODPairBaseCut(){}
      
   virtual Bool_t    Pass(AliAODPair* pair) const;
   
      
   virtual Bool_t    Pass(AliAODPair* pair) const;
   
@@ -138,12 +138,12 @@ class AliAODBasePairCut: public TObject
   
   AliAODPairCutProperty fProperty; // The property itself
   
   
   AliAODPairCutProperty fProperty; // The property itself
   
-  ClassDef(AliAODBasePairCut,1)
+  ClassDef(AliAODPairBaseCut,1)
  
  };
 /******************************************************************/
 
  
  };
 /******************************************************************/
 
-inline Bool_t AliAODBasePairCut::Pass(AliAODPair* pair) const
+inline Bool_t AliAODPairBaseCut::Pass(AliAODPair* pair) const
 {
   //checks if pair proprty is in range
   //null pointer check is made by AliAODPairCut, so here is unnecesary
 {
   //checks if pair proprty is in range
   //null pointer check is made by AliAODPairCut, so here is unnecesary
@@ -156,10 +156,10 @@ inline Bool_t AliAODBasePairCut::Pass(AliAODPair* pair) const
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-class AliAODQInvCut: public AliAODBasePairCut
+class AliAODQInvCut: public AliAODPairBaseCut
 {
  public:
 {
  public:
-  AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropQInv){}
+  AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropQInv){}
   virtual ~AliAODQInvCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetQInv();}
   virtual ~AliAODQInvCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetQInv();}
@@ -168,9 +168,9 @@ class AliAODQInvCut: public AliAODBasePairCut
  };
 /******************************************************************/
 
  };
 /******************************************************************/
 
-class AliAODKtCut: public AliAODBasePairCut {
+class AliAODKtCut: public AliAODPairBaseCut {
  public:
  public:
-  AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropKt){}
+  AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKt){}
   virtual ~AliAODKtCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKt();}
   virtual ~AliAODKtCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKt();}
@@ -179,10 +179,10 @@ class AliAODKtCut: public AliAODBasePairCut {
  };
 /******************************************************************/
 
  };
 /******************************************************************/
 
-class AliAODKStarCut: public AliAODBasePairCut
+class AliAODKStarCut: public AliAODPairBaseCut
 {
  public:
 {
  public:
-  AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropKStar){}
+  AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStar){}
   virtual ~AliAODKStarCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStar();}
   virtual ~AliAODKStarCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStar();}
@@ -191,11 +191,11 @@ class AliAODKStarCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODQSideLCMSCut: public AliAODBasePairCut
+class AliAODQSideLCMSCut: public AliAODPairBaseCut
 {
  public:
   AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
 {
  public:
   AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODBasePairCut(min,max,kHbtPairCutPropQSideLCMS){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
   virtual ~AliAODQSideLCMSCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
   virtual ~AliAODQSideLCMSCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
@@ -206,11 +206,11 @@ class AliAODQSideLCMSCut: public AliAODBasePairCut
 /******************************************************************/
 
 
 /******************************************************************/
 
 
-class AliAODQOutLCMSCut: public AliAODBasePairCut
+class AliAODQOutLCMSCut: public AliAODPairBaseCut
 {
  public:
   AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
 {
  public:
   AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODBasePairCut(min,max,kHbtPairCutPropQOutLCMS){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
   virtual ~AliAODQOutLCMSCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
   virtual ~AliAODQOutLCMSCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
@@ -220,11 +220,11 @@ class AliAODQOutLCMSCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODQLongLCMSCut: public AliAODBasePairCut
+class AliAODQLongLCMSCut: public AliAODPairBaseCut
 {
  public:
   AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
 {
  public:
   AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODBasePairCut(min,max,kHbtPairCutPropQLongLCMS){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
   virtual ~AliAODQLongLCMSCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
   virtual ~AliAODQLongLCMSCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
@@ -234,11 +234,11 @@ class AliAODQLongLCMSCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODDeltaPhiCut: public AliAODBasePairCut
+class AliAODDeltaPhiCut: public AliAODPairBaseCut
 {
  public:
   AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
 {
  public:
   AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODBasePairCut(min,max,kHbtPairCutPropDeltaPhi){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
   virtual ~AliAODDeltaPhiCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
   virtual ~AliAODDeltaPhiCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
@@ -248,11 +248,11 @@ class AliAODDeltaPhiCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODDeltaThetaCut: public AliAODBasePairCut
+class AliAODDeltaThetaCut: public AliAODPairBaseCut
 {
  public:
   AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
 {
  public:
   AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODBasePairCut(min,max,kHbtPairCutPropDeltaTheta){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
   virtual ~AliAODDeltaThetaCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
   virtual ~AliAODDeltaThetaCut(){}
  protected:
   virtual Double_t  GetValue(AliAODPair* pair) const 
@@ -262,11 +262,11 @@ class AliAODDeltaThetaCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODCluterOverlapCut: public AliAODBasePairCut
+class AliAODCluterOverlapCut: public AliAODPairBaseCut
 {
  public:
   AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
 {
  public:
   AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
-    AliAODBasePairCut(min,max,kHbtPairCutPropClOverlap){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
   virtual ~AliAODCluterOverlapCut(){}
 
  protected:
   virtual ~AliAODCluterOverlapCut(){}
 
  protected:
@@ -275,11 +275,11 @@ class AliAODCluterOverlapCut: public AliAODBasePairCut
 };
 /******************************************************************/
   
 };
 /******************************************************************/
   
-class AliAODAvSeparationCut: public AliAODBasePairCut
+class AliAODAvSeparationCut: public AliAODPairBaseCut
 {
  public:
   AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
 {
  public:
   AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
-    AliAODBasePairCut(min,max,kHbtPairCutPropAvSepar){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
   virtual ~AliAODAvSeparationCut(){}
   
  protected:
   virtual ~AliAODAvSeparationCut(){}
   
  protected:
@@ -288,11 +288,11 @@ class AliAODAvSeparationCut: public AliAODBasePairCut
 };
 /******************************************************************/
   
 };
 /******************************************************************/
   
-class AliAODSeparationCut: public AliAODBasePairCut
+class AliAODSeparationCut: public AliAODPairBaseCut
 {
  public:
   AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
 {
  public:
   AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
-    AliAODBasePairCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
+    AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
   virtual ~AliAODSeparationCut(){}
   
  protected:
   virtual ~AliAODSeparationCut(){}
   
  protected:
@@ -302,12 +302,12 @@ class AliAODSeparationCut: public AliAODBasePairCut
 };
 /******************************************************************/
   
 };
 /******************************************************************/
   
-class AliAODITSSeparationCut: public AliAODBasePairCut
+class AliAODITSSeparationCut: public AliAODPairBaseCut
 {
 //Anti merging cut for the first layer of pixels
  public:
   AliAODITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
 {
 //Anti merging cut for the first layer of pixels
  public:
   AliAODITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
-    AliAODBasePairCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
+    AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
   virtual ~AliAODITSSeparationCut(){}
   Bool_t   Pass(AliAODPair* pair) const;
   Int_t    GetLayer() const {return fLayer;}
   virtual ~AliAODITSSeparationCut(){}
   Bool_t   Pass(AliAODPair* pair) const;
   Int_t    GetLayer() const {return fLayer;}
@@ -318,7 +318,7 @@ class AliAODITSSeparationCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODOutSideSameSignCut: public AliAODBasePairCut
+class AliAODOutSideSameSignCut: public AliAODPairBaseCut
 {
  public:
   AliAODOutSideSameSignCut(){}
 {
  public:
   AliAODOutSideSameSignCut(){}
@@ -330,7 +330,7 @@ class AliAODOutSideSameSignCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODOutSideDiffSignCut: public AliAODBasePairCut
+class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
 {
  public:
   AliAODOutSideDiffSignCut(){}
 {
  public:
   AliAODOutSideDiffSignCut(){}
@@ -342,19 +342,19 @@ class AliAODOutSideDiffSignCut: public AliAODBasePairCut
 };
 /******************************************************************/
 
 };
 /******************************************************************/
 
-class AliAODLogicalOperPairCut:  public AliAODBasePairCut
+class AliAODLogicalOperPairCut:  public AliAODPairBaseCut
  {
    public:
      AliAODLogicalOperPairCut();
  {
    public:
      AliAODLogicalOperPairCut();
-     AliAODLogicalOperPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second);
+     AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
      virtual   ~AliAODLogicalOperPairCut();
    protected:
      Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
 
      virtual   ~AliAODLogicalOperPairCut();
    protected:
      Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
 
-     AliAODBasePairCut* fFirst;   //second cut
-     AliAODBasePairCut* fSecond;  //first cut
+     AliAODPairBaseCut* fFirst;   //second cut
+     AliAODPairBaseCut* fSecond;  //first cut
    private:
    private:
-    class  AliAODDummyBasePairCut: public AliAODBasePairCut
+    class  AliAODDummyBasePairCut: public AliAODPairBaseCut
      {
        Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
        Bool_t    Pass(AliAODPair* /*pair*/) const;
      {
        Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
        Bool_t    Pass(AliAODPair* /*pair*/) const;
@@ -368,7 +368,7 @@ class AliAODOrPairCut: public AliAODLogicalOperPairCut
 {
    public:
      AliAODOrPairCut(){}
 {
    public:
      AliAODOrPairCut(){}
-     AliAODOrPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):AliAODLogicalOperPairCut(first,second){}
+     AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
      virtual   ~AliAODOrPairCut(){}
      Bool_t    Pass(AliAODPair *p) const;
      ClassDef(AliAODOrPairCut,1)
      virtual   ~AliAODOrPairCut(){}
      Bool_t    Pass(AliAODPair *p) const;
      ClassDef(AliAODOrPairCut,1)
@@ -379,7 +379,7 @@ class AliAODAndPairCut: public AliAODLogicalOperPairCut
 {
    public:
      AliAODAndPairCut(){}
 {
    public:
      AliAODAndPairCut(){}
-     AliAODAndPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):AliAODLogicalOperPairCut(first,second){}
+     AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
      virtual   ~AliAODAndPairCut(){}
      Bool_t    Pass(AliAODPair *p) const;
      ClassDef(AliAODAndPairCut,1)
      virtual   ~AliAODAndPairCut(){}
      Bool_t    Pass(AliAODPair *p) const;
      ClassDef(AliAODAndPairCut,1)
index 490058909a93b76aad1a52c47b2c7b038c00f5d4..24c3fa14ddb2e2e28fa6a56ce7b90b56ac670c38 100644 (file)
@@ -29,7 +29,7 @@ const Int_t AliAODParticleCut::fgkMaxCuts = 50;
 /******************************************************************/
 
 AliAODParticleCut::AliAODParticleCut():
 /******************************************************************/
 
 AliAODParticleCut::AliAODParticleCut():
- fCuts(new AliAODBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
+ fCuts(new AliAODParticleBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
  fNCuts(0),
  fPID(0)
 {
  fNCuts(0),
  fPID(0)
 {
@@ -41,13 +41,13 @@ AliAODParticleCut::AliAODParticleCut(const AliAODParticleCut& in):
  TObject(in)
 {
   //cpy ctor
  TObject(in)
 {
   //cpy ctor
-  fCuts = new AliAODBaseCut* [fgkMaxCuts];//last property in the property
+  fCuts = new AliAODParticleBaseCut* [fgkMaxCuts];//last property in the property
                                          //property enum => defines number of properties
   fNCuts = in.fNCuts;
   fPID  = in.fPID;
   for (Int_t i = 0;i<fNCuts;i++)
    {
                                          //property enum => defines number of properties
   fNCuts = in.fNCuts;
   fPID  = in.fPID;
   for (Int_t i = 0;i<fNCuts;i++)
    {
-     fCuts[i] = (AliAODBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+     fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
    }
 }
 /******************************************************************/
    }
 }
 /******************************************************************/
@@ -64,7 +64,7 @@ AliAODParticleCut& AliAODParticleCut::operator=(const AliAODParticleCut& in)
   fPID  = in.fPID;
   for (Int_t i = 0;i<fNCuts;i++)
    {
   fPID  = in.fPID;
   for (Int_t i = 0;i<fNCuts;i++)
    {
-     fCuts[i] = (AliAODBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+     fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
    }
   return *this;
 }    
    }
   return *this;
 }    
@@ -105,7 +105,7 @@ Bool_t AliAODParticleCut::Pass(AliVAODParticle* p) const
 }
 /******************************************************************/
 
 }
 /******************************************************************/
 
-void AliAODParticleCut::AddBasePartCut(AliAODBaseCut* basecut)
+void AliAODParticleCut::AddBasePartCut(AliAODParticleBaseCut* basecut)
 {
   //adds the base pair cut (cut on one value)
  
 {
   //adds the base pair cut (cut on one value)
  
@@ -120,7 +120,7 @@ void AliAODParticleCut::AddBasePartCut(AliAODBaseCut* basecut)
 }
 
 /******************************************************************/
 }
 
 /******************************************************************/
-AliAODBaseCut* AliAODParticleCut::FindCut(AliAODCutProperty property)
+AliAODParticleBaseCut* AliAODParticleCut::FindCut(AliAODCutProperty property)
 {
  //returns pointer to the cut checking the given property
  for (Int_t i = 0;i<fNCuts;i++)
 {
  //returns pointer to the cut checking the given property
  for (Int_t i = 0;i<fNCuts;i++)
@@ -167,7 +167,7 @@ void AliAODParticleCut::SetEnergyRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODRapidity);
+  AliAODParticleBaseCut* cut = FindCut(kAODRapidity);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODRapidityCut(min,max);
 
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODRapidityCut(min,max);
 
@@ -177,7 +177,7 @@ void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODPseudoRapidity);
+  AliAODParticleBaseCut* cut = FindCut(kAODPseudoRapidity);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPseudoRapidityCut(min,max);
  
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPseudoRapidityCut(min,max);
  
@@ -187,7 +187,7 @@ void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODPx);
+  AliAODParticleBaseCut* cut = FindCut(kAODPx);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPxCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPxCut(min,max);
 }
@@ -196,7 +196,7 @@ void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
 {  
   //name self descriptive
 void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
 {  
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODPy);
+  AliAODParticleBaseCut* cut = FindCut(kAODPy);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPyCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPyCut(min,max);
 }
@@ -205,7 +205,7 @@ void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODPz);
+  AliAODParticleBaseCut* cut = FindCut(kAODPz);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPzCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPzCut(min,max);
 }
@@ -214,7 +214,7 @@ void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODPhi);
+  AliAODParticleBaseCut* cut = FindCut(kAODPhi);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPhiCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODPhiCut(min,max);
 }
@@ -223,7 +223,7 @@ void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODTheta);
+  AliAODParticleBaseCut* cut = FindCut(kAODTheta);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODThetaCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODThetaCut(min,max);
 }
@@ -232,7 +232,7 @@ void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODVx);
+  AliAODParticleBaseCut* cut = FindCut(kAODVx);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODVxCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODVxCut(min,max);
 }
@@ -241,7 +241,7 @@ void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODVy);
+  AliAODParticleBaseCut* cut = FindCut(kAODVy);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODVyCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODVyCut(min,max);
 }
@@ -250,7 +250,7 @@ void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
 void AliAODParticleCut::SetVzRange(Double_t min, Double_t max)
 {
   //name self descriptive
 void AliAODParticleCut::SetVzRange(Double_t min, Double_t max)
 {
   //name self descriptive
-  AliAODBaseCut* cut = FindCut(kAODVz);
+  AliAODParticleBaseCut* cut = FindCut(kAODVz);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODVzCut(min,max);
 }
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODVzCut(min,max);
 }
@@ -306,8 +306,8 @@ void AliAODParticleCut::Print(void) const
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-ClassImp(AliAODEmptyParticleCut)
-void AliAODEmptyParticleCut::Streamer(TBuffer &b)
+ClassImp(AliAODParticleEmptyCut)
+void AliAODParticleEmptyCut::Streamer(TBuffer &b)
  {
   //stramer
   AliAODParticleCut::Streamer(b);
  {
   //stramer
   AliAODParticleCut::Streamer(b);
@@ -320,8 +320,8 @@ void AliAODEmptyParticleCut::Streamer(TBuffer &b)
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-ClassImp(AliAODBaseCut)
-void AliAODBaseCut::Print(void) const
+ClassImp(AliAODParticleBaseCut)
+void AliAODParticleBaseCut::Print(void) const
 {
   // prints the information anout the base cut to stdout
   cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
 {
   // prints the information anout the base cut to stdout
   cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
@@ -329,7 +329,7 @@ void AliAODBaseCut::Print(void) const
 }
 /******************************************************************/
 
 }
 /******************************************************************/
 
-void AliAODBaseCut::PrintProperty(void) const
+void AliAODParticleBaseCut::PrintProperty(void) const
 {
  //prints the property name 
  switch (fProperty)
 {
  //prints the property name 
  switch (fProperty)
@@ -389,13 +389,13 @@ ClassImp( AliAODPIDCut )
 void AliAODPIDCut::Print(void) const
 {
   cout<<"PID "<<fPID<<" ";
 void AliAODPIDCut::Print(void) const
 {
   cout<<"PID "<<fPID<<" ";
-  AliAODBaseCut::Print();
+  AliAODParticleBaseCut::Print();
 }
 
 ClassImp( AliAODLogicalOperCut )
 
 AliAODLogicalOperCut::AliAODLogicalOperCut():
 }
 
 ClassImp( AliAODLogicalOperCut )
 
 AliAODLogicalOperCut::AliAODLogicalOperCut():
- AliAODBaseCut(-10e10,10e10,kAODNone),
+ AliAODParticleBaseCut(-10e10,10e10,kAODNone),
  fFirst(new AliAODDummyBaseCut),
  fSecond(new AliAODDummyBaseCut)
 {
  fFirst(new AliAODDummyBaseCut),
  fSecond(new AliAODDummyBaseCut)
 {
@@ -403,10 +403,10 @@ AliAODLogicalOperCut::AliAODLogicalOperCut():
 }
 /******************************************************************/
 
 }
 /******************************************************************/
 
-AliAODLogicalOperCut::AliAODLogicalOperCut(AliAODBaseCut* first, AliAODBaseCut* second):
- AliAODBaseCut(-10e10,10e10,kAODNone),
- fFirst((first)?(AliAODBaseCut*)first->Clone():0x0),
- fSecond((second)?(AliAODBaseCut*)second->Clone():0x0)
+AliAODLogicalOperCut::AliAODLogicalOperCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):
+ AliAODParticleBaseCut(-10e10,10e10,kAODNone),
+ fFirst((first)?(AliAODParticleBaseCut*)first->Clone():0x0),
+ fSecond((second)?(AliAODParticleBaseCut*)second->Clone():0x0)
 {
   //ctor
   if ( (fFirst && fSecond) == kFALSE) 
 {
   //ctor
   if ( (fFirst && fSecond) == kFALSE) 
index 8011d056d75f7cc67476961c7ac99857b5ab89d7..615293bdd351c96ee2bf6c6be7633051135f7c71 100644 (file)
@@ -27,9 +27,9 @@
 #include "AliVAODParticle.h"
 
 
 #include "AliVAODParticle.h"
 
 
-class AliAODEmptyParticleCut;
+class AliAODParticleEmptyCut;
 class AliAODParticleCut;
 class AliAODParticleCut;
-class AliAODBaseCut;
+class AliAODParticleBaseCut;
 
 
 /******************************************************************/
 
 
 /******************************************************************/
@@ -73,7 +73,7 @@ class AliAODParticleCut: public TObject
     virtual Bool_t Pass(AliVAODParticle* p) const;
     Bool_t IsEmpty() const {return kFALSE;}
     
     virtual Bool_t Pass(AliVAODParticle* p) const;
     Bool_t IsEmpty() const {return kFALSE;}
     
-    void AddBasePartCut(AliAODBaseCut* basecut);
+    void AddBasePartCut(AliAODParticleBaseCut* basecut);
     
     Int_t GetPID() const { return fPID;}
     void SetPID(Int_t pid){fPID=pid;}
     
     Int_t GetPID() const { return fPID;}
     void SetPID(Int_t pid){fPID=pid;}
@@ -96,9 +96,9 @@ class AliAODParticleCut: public TObject
     void Print(void) const;
   protected:
      
     void Print(void) const;
   protected:
      
-    AliAODBaseCut* FindCut(AliAODCutProperty property);
+    AliAODParticleBaseCut* FindCut(AliAODCutProperty property);
 
 
-    AliAODBaseCut ** fCuts;//! Array with cuts
+    AliAODParticleBaseCut ** 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
     Int_t fNCuts; //number of base cuts stored in fCuts
 
     Int_t fPID; //particle PID  - if=0 (rootino) all pids are accepted
@@ -112,18 +112,18 @@ class AliAODParticleCut: public TObject
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-class AliAODEmptyParticleCut:  public AliAODParticleCut
+class AliAODParticleEmptyCut:  public AliAODParticleCut
 {
 //Empty - it passes possitively all particles - it means returns always False
 //Class describing cut on particles
   public:
 {
 //Empty - it passes possitively all particles - it means returns always False
 //Class describing cut on particles
   public:
-    AliAODEmptyParticleCut(){};
-    virtual ~AliAODEmptyParticleCut(){};
+    AliAODParticleEmptyCut(){};
+    virtual ~AliAODParticleEmptyCut(){};
     
     Bool_t Pass(AliVAODParticle*) const {return kFALSE;} //accept everything
     Bool_t IsEmpty() const {return kTRUE;}
 
     
     Bool_t Pass(AliVAODParticle*) const {return kFALSE;} //accept everything
     Bool_t IsEmpty() const {return kTRUE;}
 
-    ClassDef(AliAODEmptyParticleCut,1)
+    ClassDef(AliAODParticleEmptyCut,1)
  
 };
 
  
 };
 
@@ -131,17 +131,17 @@ class AliAODEmptyParticleCut:  public AliAODParticleCut
 /******************************************************************/
 /******************************************************************/
 
 /******************************************************************/
 /******************************************************************/
 
-class AliAODBaseCut: public TObject
+class AliAODParticleBaseCut: public TObject
  {
    //This class defines the range of some property - pure virtual
    //Property is coded by AliAODCutTypes type
    
    public:
      
  {
    //This class defines the range of some property - pure virtual
    //Property is coded by AliAODCutTypes type
    
    public:
      
-     AliAODBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliAODCutProperty prop = kAODNone):
+     AliAODParticleBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliAODCutProperty prop = kAODNone):
                    fProperty(prop),fMin(min),fMax(max){}
 
                    fProperty(prop),fMin(min),fMax(max){}
 
-     virtual           ~AliAODBaseCut(){}
+     virtual           ~AliAODParticleBaseCut(){}
      
      virtual Bool_t    Pass(AliVAODParticle *p) const;
      
      
      virtual Bool_t    Pass(AliVAODParticle *p) const;
      
@@ -165,12 +165,12 @@ class AliAODBaseCut: public TObject
      
    private:
      void PrintProperty(void) const;
      
    private:
      void PrintProperty(void) const;
-     ClassDef(AliAODBaseCut,1)
+     ClassDef(AliAODParticleBaseCut,1)
    
  };
 
 inline Bool_t
    
  };
 
 inline Bool_t
-AliAODBaseCut::Pass(AliVAODParticle *p) const
+AliAODParticleBaseCut::Pass(AliVAODParticle *p) const
 {
   //cjecks if particle property fits in range
   if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
 {
   //cjecks if particle property fits in range
   if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
@@ -181,20 +181,20 @@ AliAODBaseCut::Pass(AliVAODParticle *p) const
 /******************************************************************/
 
  
 /******************************************************************/
 
  
-class AliAODMomentumCut: public AliAODBaseCut
+class AliAODMomentumCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODP){}
+    AliAODMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODP){}
     virtual ~AliAODMomentumCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->P();}
     ClassDef(AliAODMomentumCut,1)
  };
 
     virtual ~AliAODMomentumCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->P();}
     ClassDef(AliAODMomentumCut,1)
  };
 
-class AliAODPtCut: public AliAODBaseCut
+class AliAODPtCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODPtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPt){}
+    AliAODPtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPt){}
     virtual ~AliAODPtCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Pt();}
     virtual ~AliAODPtCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Pt();}
@@ -202,50 +202,50 @@ class AliAODPtCut: public AliAODBaseCut
  };
 
 
  };
 
 
-class AliAODEnergyCut: public AliAODBaseCut
+class AliAODEnergyCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODE){}
+    AliAODEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODE){}
     virtual ~AliAODEnergyCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const {return p->E();}
     ClassDef(AliAODEnergyCut,1)
  };
 
     virtual ~AliAODEnergyCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const {return p->E();}
     ClassDef(AliAODEnergyCut,1)
  };
 
-class AliAODRapidityCut: public AliAODBaseCut
+class AliAODRapidityCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODRapidity){}
+    AliAODRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODRapidity){}
     virtual ~AliAODRapidityCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Y();}
     ClassDef(AliAODRapidityCut,1)
  };
 
     virtual ~AliAODRapidityCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Y();}
     ClassDef(AliAODRapidityCut,1)
  };
 
-class AliAODPseudoRapidityCut: public AliAODBaseCut
+class AliAODPseudoRapidityCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPseudoRapidity){}
+    AliAODPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPseudoRapidity){}
     virtual ~AliAODPseudoRapidityCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Eta();}
     ClassDef(AliAODPseudoRapidityCut,1)
  };
 
     virtual ~AliAODPseudoRapidityCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Eta();}
     ClassDef(AliAODPseudoRapidityCut,1)
  };
 
-class AliAODPxCut: public AliAODBaseCut
+class AliAODPxCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODPxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPx){}
+    AliAODPxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPx){}
     virtual ~AliAODPxCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Px();}
     ClassDef(AliAODPxCut,1)
  };
 
     virtual ~AliAODPxCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Px();}
     ClassDef(AliAODPxCut,1)
  };
 
-class AliAODPyCut: public AliAODBaseCut
+class AliAODPyCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODPyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPy){}
+    AliAODPyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPy){}
     virtual ~AliAODPyCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Py();}
     virtual ~AliAODPyCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Py();}
@@ -253,20 +253,20 @@ class AliAODPyCut: public AliAODBaseCut
  };
 
 
  };
 
 
-class AliAODPzCut: public AliAODBaseCut
+class AliAODPzCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODPzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPz){}
+    AliAODPzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPz){}
     virtual ~AliAODPzCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Pz();}
     ClassDef(AliAODPzCut,1)
  };
 
     virtual ~AliAODPzCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Pz();}
     ClassDef(AliAODPzCut,1)
  };
 
-class AliAODPhiCut: public AliAODBaseCut
+class AliAODPhiCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPhi){}
+    AliAODPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPhi){}
     virtual ~AliAODPhiCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Phi();}
     virtual ~AliAODPhiCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Phi();}
@@ -274,10 +274,10 @@ class AliAODPhiCut: public AliAODBaseCut
   
  };
 
   
  };
 
-class AliAODThetaCut: public AliAODBaseCut
+class AliAODThetaCut: public AliAODParticleBaseCut
  {
   public: 
  {
   public: 
-    AliAODThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODTheta){}
+    AliAODThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODTheta){}
     virtual ~AliAODThetaCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Theta();}
     virtual ~AliAODThetaCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Theta();}
@@ -285,11 +285,11 @@ class AliAODThetaCut: public AliAODBaseCut
   
  };
 
   
  };
 
-class AliAODVxCut: public AliAODBaseCut
+class AliAODVxCut: public AliAODParticleBaseCut
  {
  //Cut of the X coAnddinate of the vertex position
   public: 
  {
  //Cut of the X coAnddinate of the vertex position
   public: 
-    AliAODVxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVx){}
+    AliAODVxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVx){}
     virtual ~AliAODVxCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Vx();} //retruns value of the vertex
     virtual ~AliAODVxCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Vx();} //retruns value of the vertex
@@ -298,11 +298,11 @@ class AliAODVxCut: public AliAODBaseCut
  };
 
 
  };
 
 
-class AliAODVyCut: public AliAODBaseCut
+class AliAODVyCut: public AliAODParticleBaseCut
  {
  //Cut of the X coAnddinate of the vertex position
   public: 
  {
  //Cut of the X coAnddinate of the vertex position
   public: 
-    AliAODVyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVy){}
+    AliAODVyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVy){}
     virtual ~AliAODVyCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Vy();} //retruns value of the vertex
     virtual ~AliAODVyCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Vy();} //retruns value of the vertex
@@ -310,11 +310,11 @@ class AliAODVyCut: public AliAODBaseCut
   
  };
 
   
  };
 
-class AliAODVzCut: public AliAODBaseCut
+class AliAODVzCut: public AliAODParticleBaseCut
  {
  //Cut of the X coAnddinate of the vertex position
   public: 
  {
  //Cut of the X coAnddinate of the vertex position
   public: 
-    AliAODVzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVz){}
+    AliAODVzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVz){}
     virtual ~AliAODVzCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Vz();} //retruns value of the vertex
     virtual ~AliAODVzCut(){}
   protected:
     Double_t  GetValue(AliVAODParticle * p)const{return p->Vz();} //retruns value of the vertex
@@ -323,11 +323,11 @@ class AliAODVzCut: public AliAODBaseCut
   
  };
 
   
  };
 
-class AliAODPIDCut:  public AliAODBaseCut
+class AliAODPIDCut:  public AliAODParticleBaseCut
  {
    public:
  {
    public:
-     AliAODPIDCut():AliAODBaseCut(0.0,0.0,kAODPid),fPID(0){}
-     AliAODPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliAODBaseCut(min,max,kAODPid),fPID(pid){}
+     AliAODPIDCut():AliAODParticleBaseCut(0.0,0.0,kAODPid),fPID(0){}
+     AliAODPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliAODParticleBaseCut(min,max,kAODPid),fPID(pid){}
      virtual ~AliAODPIDCut(){}
      
      void SetPID(Int_t pid){fPID = pid;}
      virtual ~AliAODPIDCut(){}
      
      void SetPID(Int_t pid){fPID = pid;}
@@ -346,19 +346,19 @@ class AliAODPIDCut:  public AliAODBaseCut
 // logical operations on cuts                      //
 //                                                 //
 /////////////////////////////////////////////////////
 // logical operations on cuts                      //
 //                                                 //
 /////////////////////////////////////////////////////
-class AliAODLogicalOperCut:  public AliAODBaseCut
+class AliAODLogicalOperCut:  public AliAODParticleBaseCut
  {
    public:
      AliAODLogicalOperCut();
  {
    public:
      AliAODLogicalOperCut();
-     AliAODLogicalOperCut(AliAODBaseCut* first, AliAODBaseCut* second);
+     AliAODLogicalOperCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second);
      virtual   ~AliAODLogicalOperCut();
    protected:
      Double_t  GetValue(AliVAODParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
      
      virtual   ~AliAODLogicalOperCut();
    protected:
      Double_t  GetValue(AliVAODParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
      
-     AliAODBaseCut* fFirst;   //second cut
-     AliAODBaseCut* fSecond;  //first cut
+     AliAODParticleBaseCut* fFirst;   //second cut
+     AliAODParticleBaseCut* fSecond;  //first cut
    private:  
    private:  
-    class  AliAODDummyBaseCut: public AliAODBaseCut 
+    class  AliAODDummyBaseCut: public AliAODParticleBaseCut 
      {
        Double_t  GetValue(AliVAODParticle * /*part*/) const {return 0.0;}
        Bool_t    Pass(AliVAODParticle* /*part*/) const;
      {
        Double_t  GetValue(AliVAODParticle * /*part*/) const {return 0.0;}
        Bool_t    Pass(AliVAODParticle* /*part*/) const;
@@ -371,7 +371,7 @@ class AliAODOrCut: public AliAODLogicalOperCut
 {
    public:
      AliAODOrCut(){}
 {
    public:
      AliAODOrCut(){}
-     AliAODOrCut(AliAODBaseCut* first, AliAODBaseCut* second):AliAODLogicalOperCut(first,second){}
+     AliAODOrCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
      virtual   ~AliAODOrCut(){}
      Bool_t    Pass(AliVAODParticle *p) const;
      ClassDef(AliAODOrCut,1)
      virtual   ~AliAODOrCut(){}
      Bool_t    Pass(AliVAODParticle *p) const;
      ClassDef(AliAODOrCut,1)
@@ -381,7 +381,7 @@ class AliAODAndCut: public AliAODLogicalOperCut
 {
    public:
      AliAODAndCut(){}
 {
    public:
      AliAODAndCut(){}
-     AliAODAndCut(AliAODBaseCut* first, AliAODBaseCut* second):AliAODLogicalOperCut(first,second){}
+     AliAODAndCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
      virtual   ~AliAODAndCut(){}
      Bool_t    Pass(AliVAODParticle *p) const;
      ClassDef(AliAODAndCut,1)
      virtual   ~AliAODAndCut(){}
      Bool_t    Pass(AliVAODParticle *p) const;
      ClassDef(AliAODAndCut,1)
index 6eaaf9e22fe9591204472415a1a4c66b4043a174..a9956b836af1e2369f9f6df0606c93558cccabba 100644 (file)
@@ -22,7 +22,7 @@ AliAnalysis::AliAnalysis():
  fEventCut(0x0),
  fCutOnSim(kTRUE),
  fCutOnRec(kTRUE),
  fEventCut(0x0),
  fCutOnSim(kTRUE),
  fCutOnRec(kTRUE),
- fPairCut(new AliAODEmptyPairCut()),//empty cut - accepts all particles
+ fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
  fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
  fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
  fkPass2(&AliAnalysis::PassPartAndTrack2),
  fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
  fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
  fkPass2(&AliAnalysis::PassPartAndTrack2),
@@ -37,7 +37,7 @@ AliAnalysis::AliAnalysis(const char* name,const char* title):
  fEventCut(0x0),
  fCutOnSim(kTRUE),
  fCutOnRec(kTRUE),
  fEventCut(0x0),
  fCutOnSim(kTRUE),
  fCutOnRec(kTRUE),
- fPairCut(new AliAODEmptyPairCut()),//empty cut - accepts all particles
+ fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
  fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
  fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
  fkPass2(&AliAnalysis::PassPartAndTrack2),
  fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
  fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
  fkPass2(&AliAnalysis::PassPartAndTrack2),
similarity index 90%
rename from ANALYSIS/AliBaseEventCut.cxx
rename to ANALYSIS/AliEventBaseCut.cxx
index e013b43750edf8f33fb24640abc15a1800b5bd86..07d0caa4a7d74e485f1dda3e754c03aeffdba69d 100644 (file)
@@ -1,8 +1,8 @@
-#include "AliBaseEventCut.h"
+#include "AliEventBaseCut.h"
 //________________________________
 ///////////////////////////////////////////////////////////
 //
 //________________________________
 ///////////////////////////////////////////////////////////
 //
-// class AliBaseEventCut
+// class AliEventBaseCut
 //
 //
 //
 //
 //
 //
@@ -10,9 +10,9 @@
 ///////////////////////////////////////////////////////////
 
 #include <AliAOD.h>
 ///////////////////////////////////////////////////////////
 
 #include <AliAOD.h>
-ClassImp(AliBaseEventCut)
+ClassImp(AliEventBaseCut)
 
 
-AliBaseEventCut::AliBaseEventCut():
+AliEventBaseCut::AliEventBaseCut():
  fMin(0.0),
  fMax(0.0)
 {
  fMin(0.0),
  fMax(0.0)
 {
@@ -20,7 +20,7 @@ AliBaseEventCut::AliBaseEventCut():
 }
 /**********************************************************/
 
 }
 /**********************************************************/
 
-AliBaseEventCut::AliBaseEventCut(Double_t min, Double_t max):
+AliEventBaseCut::AliEventBaseCut(Double_t min, Double_t max):
  fMin(min),
  fMax(max)
 {
  fMin(min),
  fMax(max)
 {
@@ -28,7 +28,7 @@ AliBaseEventCut::AliBaseEventCut(Double_t min, Double_t max):
 }
 /**********************************************************/
 
 }
 /**********************************************************/
 
-Bool_t AliBaseEventCut::Pass(AliAOD* aod) const
+Bool_t AliEventBaseCut::Pass(AliAOD* aod) const
 {
   if ( (GetValue(aod) < fMin) || (GetValue(aod) > fMax) ) return kTRUE;
   return kFALSE;
 {
   if ( (GetValue(aod) < fMin) || (GetValue(aod) > fMax) ) return kTRUE;
   return kFALSE;
similarity index 72%
rename from ANALYSIS/AliBaseEventCut.h
rename to ANALYSIS/AliEventBaseCut.h
index 42010074ba443419dada141651cecafff727b329..df1f9b7c53ce3f7b2feaf302283c582cb86b9cd4 100644 (file)
@@ -1,9 +1,9 @@
-#ifndef ALIBASEEVENTCUT_H
-#define ALIBASEEVENTCUT_H
+#ifndef ALIEVENTBASECUT_H
+#define ALIEVENTBASECUT_H
 //________________________________
 ///////////////////////////////////////////////////////////
 //
 //________________________________
 ///////////////////////////////////////////////////////////
 //
-// class AliBaseEventCut
+// class AliEventBaseCut
 //
 // Base class for cauts that checks only one event property
 //
 //
 // Base class for cauts that checks only one event property
 //
@@ -23,12 +23,12 @@ enum AliEventCutProperty
    kNChargedCut
  };
 
    kNChargedCut
  };
 
-class AliBaseEventCut: public TObject
+class AliEventBaseCut: public TObject
 {
   public: 
 {
   public: 
-    AliBaseEventCut();
-    AliBaseEventCut(Double_t min,Double_t max);
-    virtual ~AliBaseEventCut(){}
+    AliEventBaseCut();
+    AliEventBaseCut(Double_t min,Double_t max);
+    virtual ~AliEventBaseCut(){}
     
     virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
   protected:
     
     virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
   protected:
@@ -37,16 +37,16 @@ class AliBaseEventCut: public TObject
     Double_t fMin;//Minimum value
     Double_t fMax;//Maximum value
   private:
     Double_t fMin;//Minimum value
     Double_t fMax;//Maximum value
   private:
-    ClassDef(AliBaseEventCut,1)
+    ClassDef(AliEventBaseCut,1)
 };
 
 /************************************************************/
 
 };
 
 /************************************************************/
 
-class AliPrimVertexXCut: public AliBaseEventCut
+class AliPrimVertexXCut: public AliEventBaseCut
 {
  public: 
    AliPrimVertexXCut(){}
 {
  public: 
    AliPrimVertexXCut(){}
-   AliPrimVertexXCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
+   AliPrimVertexXCut(Double_t min,Double_t max):AliEventBaseCut(min,max){}
    virtual ~AliPrimVertexXCut(){}
  protected:
    Double_t GetValue(AliAOD* aod) const;
    virtual ~AliPrimVertexXCut(){}
  protected:
    Double_t GetValue(AliAOD* aod) const;
@@ -56,11 +56,11 @@ class AliPrimVertexXCut: public AliBaseEventCut
 };
 /************************************************************/
 
 };
 /************************************************************/
 
-class AliPrimVertexYCut: public AliBaseEventCut
+class AliPrimVertexYCut: public AliEventBaseCut
 {
  public: 
    AliPrimVertexYCut(){}
 {
  public: 
    AliPrimVertexYCut(){}
-   AliPrimVertexYCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
+   AliPrimVertexYCut(Double_t min,Double_t max):AliEventBaseCut(min,max){}
    virtual ~AliPrimVertexYCut(){}
    
  protected:
    virtual ~AliPrimVertexYCut(){}
    
  protected:
@@ -71,11 +71,11 @@ class AliPrimVertexYCut: public AliBaseEventCut
 };
 /************************************************************/
 
 };
 /************************************************************/
 
-class AliPrimVertexZCut: public AliBaseEventCut
+class AliPrimVertexZCut: public AliEventBaseCut
 {
  public: 
    AliPrimVertexZCut(){}
 {
  public: 
    AliPrimVertexZCut(){}
-   AliPrimVertexZCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
+   AliPrimVertexZCut(Double_t min,Double_t max):AliEventBaseCut(min,max){}
    virtual ~AliPrimVertexZCut(){}
  protected:
    Double_t GetValue(AliAOD* aod) const;
    virtual ~AliPrimVertexZCut(){}
  protected:
    Double_t GetValue(AliAOD* aod) const;
@@ -87,12 +87,12 @@ class AliPrimVertexZCut: public AliBaseEventCut
 
 /************************************************************/
 
 
 /************************************************************/
 
-class AliNChargedCut: public AliBaseEventCut
+class AliNChargedCut: public AliEventBaseCut
 {
  public: 
    AliNChargedCut(){}
    AliNChargedCut(Double_t min, Double_t max, Double_t etamin = -10.0, Double_t etamax = 10.0):
 {
  public: 
    AliNChargedCut(){}
    AliNChargedCut(Double_t min, Double_t max, Double_t etamin = -10.0, Double_t etamax = 10.0):
-       AliBaseEventCut(min,max),fEtaMin(etamin),fEtaMax(etamax){}
+       AliEventBaseCut(min,max),fEtaMin(etamin),fEtaMax(etamax){}
    virtual ~AliNChargedCut(){}
  protected:
    Double_t GetValue(AliAOD* aod) const;
    virtual ~AliNChargedCut(){}
  protected:
    Double_t GetValue(AliAOD* aod) const;
index dac68cf342f87208fa4684825146d29652207906..ec20b6adc10d7274d3a74771406c65b97d0a66b5 100644 (file)
@@ -12,7 +12,7 @@
 #include <TObjArray.h>
 //#include <TIter.h>
 
 #include <TObjArray.h>
 //#include <TIter.h>
 
-#include "AliBaseEventCut.h"
+#include "AliEventBaseCut.h"
 
 ClassImp(AliEventCut)
 
 
 ClassImp(AliEventCut)
 
@@ -50,8 +50,8 @@ Bool_t AliEventCut::Pass(AliAOD* aod) const
    }
    
   TIter iter(&fBaseCuts);
    }
    
   TIter iter(&fBaseCuts);
-  AliBaseEventCut* becut;
-  while (( becut = (AliBaseEventCut*)iter() ))
+  AliEventBaseCut* becut;
+  while (( becut = (AliEventBaseCut*)iter() ))
    {
      if (becut->Pass(aod)) return kTRUE;
    }
    {
      if (becut->Pass(aod)) return kTRUE;
    }
@@ -62,4 +62,4 @@ Bool_t AliEventCut::Pass(AliAOD* aod) const
 /*********************************************************/
 /*********************************************************/
 
 /*********************************************************/
 /*********************************************************/
 
-ClassImp(AliEmptyEventCut)
+ClassImp(AliEventEmptyCut)
index 7cb041d6382f75d90022a2160be69823afaf25c3..b14131499f47b59576370d58a74f07720d5905f5 100644 (file)
@@ -14,7 +14,7 @@
 
 #include <TObject.h>
 #include <TObjArray.h>
 
 #include <TObject.h>
 #include <TObjArray.h>
-#include "AliBaseEventCut.h"
+#include "AliEventBaseCut.h"
 
 class AliAOD;
 
 
 class AliAOD;
 
@@ -26,7 +26,7 @@ class AliEventCut: public TObject
     virtual ~AliEventCut();
     
     virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
     virtual ~AliEventCut();
     
     virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
-    void AddBasePartCut(AliBaseEventCut* ebcut){fBaseCuts.Add(ebcut);}
+    void AddBasePartCut(AliEventBaseCut* ebcut){fBaseCuts.Add(ebcut);}
     
   protected:
     TObjArray fBaseCuts;
     
   protected:
     TObjArray fBaseCuts;
@@ -34,17 +34,17 @@ class AliEventCut: public TObject
     ClassDef(AliEventCut,1)
 };
 
     ClassDef(AliEventCut,1)
 };
 
-class AliEmptyEventCut: public TObject
+class AliEventEmptyCut: public TObject
 {
   public: 
 {
   public: 
-    AliEmptyEventCut(){}
-    virtual ~AliEmptyEventCut(){}
+    AliEventEmptyCut(){}
+    virtual ~AliEventEmptyCut(){}
     
     Bool_t Pass(AliAOD* aod) const {return kFALSE;}//always accept
     
   protected:
   private:
     
     Bool_t Pass(AliAOD* aod) const {return kFALSE;}//always accept
     
   protected:
   private:
-    ClassDef(AliEmptyEventCut,1)
+    ClassDef(AliEventEmptyCut,1)
 };
 
 #endif
 };
 
 #endif
index ef0b2252b993ece75adc76242ae4201ac349e5d7..9f55a7aaf98d08da761159a440b9b41144e1eb09 100644 (file)
@@ -3,7 +3,7 @@ SRCS= AliAOD.cxx AliEventBuffer.cxx \
       AliAODPair.cxx        AliAODPairCut.cxx \
       AliAODParticleCut.cxx AliAODRun.cxx \
       AliRunAnalysis.cxx AliAnalysis.cxx \
       AliAODPair.cxx        AliAODPairCut.cxx \
       AliAODParticleCut.cxx AliAODRun.cxx \
       AliRunAnalysis.cxx AliAnalysis.cxx \
-      AliEventCut.cxx AliBaseEventCut.cxx \
+      AliEventCut.cxx AliEventBaseCut.cxx \
       AliReader.cxx AliReaderESD.cxx AliReaderKineTree.cxx\
       AliTrackPoints.cxx AliClusterMap.cxx \
       AliD0toKpi.cxx  AliD0toKpiAnalysis.cxx AliFlowAnalysis.cxx \
       AliReader.cxx AliReaderESD.cxx AliReaderKineTree.cxx\
       AliTrackPoints.cxx AliClusterMap.cxx \
       AliD0toKpi.cxx  AliD0toKpiAnalysis.cxx AliFlowAnalysis.cxx \
@@ -13,12 +13,13 @@ HDRS= $(SRCS:.cxx=.h)
 DHDR:=ANALYSISLinkDef.h
 
 EXPORT:=AliAOD.h AliEventBuffer.h\
 DHDR:=ANALYSISLinkDef.h
 
 EXPORT:=AliAOD.h AliEventBuffer.h\
-      AliVAODParticle.h     AliAODParticle.h \
-      AliAODPair.h          AliAODPairCut.h  \
-      AliAODParticleCut.h   AliAODRun.h      \
-      AliRunAnalysis.h      AliAnalysis.h      AliEventCut.h \
-      AliReader.h           AliReaderESD.h   \
-      AliTrackPoints.h      AliClusterMap.h  \
-      AliFlowAnalysis.h  
+      AliVAODParticle.h     AliAODParticle.h  \
+      AliAODPair.h          AliAODPairCut.h   \
+      AliAODParticleCut.h   AliAODRun.h       \
+      AliRunAnalysis.h      AliAnalysis.h     \
+      AliEventCut.h         AliEventBaseCut.h \
+      AliReader.h           AliReaderESD.h    \
+      AliTrackPoints.h      AliClusterMap.h   \
+      AliFlowAnalysis.h 
 
 EINCLUDE:= TPC CONTAINERS ITS
 
 EINCLUDE:= TPC CONTAINERS ITS
index 3b645510fea368dff1891d168e215a9bb263ffd1..a0a77470ad48a8e476ae0395a951f4b3ce8be010 100644 (file)
@@ -41,7 +41,7 @@
 ClassImp( AliHBTFunction )
 
 AliHBTFunction::AliHBTFunction():
 ClassImp( AliHBTFunction )
 
 AliHBTFunction::AliHBTFunction():
- fPairCut(new AliAODEmptyPairCut()), //dummy cut  
+ fPairCut(new AliAODPairEmptyCut()), //dummy cut  
  fWriteNumAndDen(kFALSE)
 {
 //Default constructor
  fWriteNumAndDen(kFALSE)
 {
 //Default constructor
@@ -50,7 +50,7 @@ AliHBTFunction::AliHBTFunction():
 
 AliHBTFunction::AliHBTFunction(const char* name,const char* title):
  TNamed(name,title),
 
 AliHBTFunction::AliHBTFunction(const char* name,const char* title):
  TNamed(name,title),
- fPairCut(new AliAODEmptyPairCut()), //dummy cut  
+ fPairCut(new AliAODPairEmptyCut()), //dummy cut  
  fWriteNumAndDen(kFALSE)
 {
 //Constructor  
  fWriteNumAndDen(kFALSE)
 {
 //Constructor  
index 3453b8646789f8f126c380c6dd0a65289a72e3e8..e4f8a24b0dfb2d9e5886bfae317c3ed9535013a3 100644 (file)
@@ -44,21 +44,21 @@ Zbigniew.Chajecki@cern.ch
 ClassImp( AliHBTMonitorFunction )
 
 AliHBTMonitorFunction::AliHBTMonitorFunction():
 ClassImp( AliHBTMonitorFunction )
 
 AliHBTMonitorFunction::AliHBTMonitorFunction():
- fParticleCut(new AliAODEmptyParticleCut())
+ fParticleCut(new AliAODParticleEmptyCut())
 {
   //ctor
 }
 /******************************************************************/
 AliHBTMonitorFunction::AliHBTMonitorFunction(const char* name,const char* title):
  TNamed(name,title),
 {
   //ctor
 }
 /******************************************************************/
 AliHBTMonitorFunction::AliHBTMonitorFunction(const char* name,const char* title):
  TNamed(name,title),
- fParticleCut(new AliAODEmptyParticleCut())
+ fParticleCut(new AliAODParticleEmptyCut())
 {
   //ctor
 }
 /******************************************************************/
 AliHBTMonitorFunction::AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/):
  TNamed(),
 {
   //ctor
 }
 /******************************************************************/
 AliHBTMonitorFunction::AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/):
  TNamed(),
- fParticleCut(new AliAODEmptyParticleCut())
+ fParticleCut(new AliAODParticleEmptyCut())
 {
   //cpy ctor
   // We cannot copy because it is a mess with names (histogram and functions)
 {
   //cpy ctor
   // We cannot copy because it is a mess with names (histogram and functions)