Base Pair Cuts moved to the separate file. Property eneum defined within namespace...
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Jul 2004 13:05:36 +0000 (13:05 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Jul 2004 13:05:36 +0000 (13:05 +0000)
ANALYSIS/AliAODPairBaseCut.cxx [new file with mode: 0644]
ANALYSIS/AliAODPairBaseCut.h [new file with mode: 0644]
ANALYSIS/AliAODPairCut.cxx
ANALYSIS/AliAODPairCut.h
ANALYSIS/libANALYSIS.pkg

diff --git a/ANALYSIS/AliAODPairBaseCut.cxx b/ANALYSIS/AliAODPairBaseCut.cxx
new file mode 100644 (file)
index 0000000..1a9cc03
--- /dev/null
@@ -0,0 +1,262 @@
+#include "AliAODPairBaseCut.h"
+
+#include "AliTrackPoints.h"
+#include "AliClusterMap.h"
+
+
+ClassImp(AliAODPairBaseCut)
+ClassImp(AliAODQInvCut)
+ClassImp(AliAODKtCut)
+ClassImp(AliAODQSideLCMSCut)
+ClassImp(AliAODQOutLCMSCut)
+ClassImp(AliAODQLongLCMSCut)
+
+/******************************************************************/
+ClassImp(AliAODAvSeparationCut)
+    
+Double_t AliAODAvSeparationCut::GetValue(AliAODPair* pair) const 
+{
+  //chacks if avarage distance of two tracks is in given range
+  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
+  if ( tpts1 == 0x0)
+   {//it could be simulated pair
+//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
+     return -1.0;
+   }
+
+  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
+  if ( tpts2 == 0x0)
+   {
+//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
+     return -1.0;
+   }
+   
+  return tpts1->AvarageDistance(*tpts2);
+}
+/******************************************************************/
+ClassImp(AliAODSeparationCut)
+    
+Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const 
+{
+  //chacks if avarage distance of two tracks is in given range
+  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
+  if ( tpts1 == 0x0)
+   {//it could be simulated pair
+//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
+     return -1.0;
+   }
+
+  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
+  if ( tpts2 == 0x0)
+   {
+//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
+     return -1.0;
+   }
+  Float_t x1=0,y1=0,z1=0; 
+  Float_t x2=0,y2=0,z2=0;
+  
+  tpts1->PositionAt(fPoint,x1,y1,z1);
+  tpts2->PositionAt(fPoint,x2,y2,z2);
+  Double_t dx1 = x1 - x2;
+  Double_t dy1 = y1 - y2;
+  Double_t dz1 = z1 - z2;
+  Double_t d = TMath::Sqrt(dx1*dx1 + dy1*dy1 + dz1*dz1);
+  return d;
+}
+/******************************************************************/
+
+ClassImp(AliAODITSSeparationCut)
+
+Bool_t AliAODITSSeparationCut::Rejected(AliAODPair* pair) const
+{
+ //Checks if two tracks do not cross first pixels too close to each other
+ //If two tracks use the same cluster in pixels they are given
+ //the same position what skews theta angles (both are the same)
+ //These guys create artificial correlation in non-id analyses
+ //which is positive for identical polar angles (Qlong=0) 
+ //and negative for a little bit different theta angle (Qlong=epsilon)
+ //Such tracks "attracks" each other.
+  AliTrackPoints* tpts1 = pair->Particle1()->GetITSTrackPoints();
+  if ( tpts1 == 0x0)
+   {//it could be simulated pair
+     Warning("Pass","Track 1 does not have ITS Track Points. Pair NOT Passed.");
+     return kTRUE;//reject 
+   }
+
+  AliTrackPoints* tpts2 = pair->Particle2()->GetITSTrackPoints();
+  if ( tpts2 == 0x0)
+   {
+     Warning("Pass","Track 2 does not have ITS Track Points. Pair NOT Passed.");
+     return kTRUE;//reject 
+   }
+  Float_t  x1=0.0,y1=0.0,z1=0.0,x2=0.0,y2=0.0,z2=0.0;
+  tpts1->PositionAt(fLayer,x1,y1,z1);
+  tpts2->PositionAt(fLayer,x2,y2,z2);
+  
+//  Info("Pass","rphi %f z %f",fMin,fMax);
+//  Info("Pass","P1: %f %f %f", x1,y1,z1);
+//  Info("Pass","P2: %f %f %f", x2,y2,z2);
+  
+  Double_t dz = TMath::Abs(z1-z2);
+  
+  //fMax encodes treshold valaue of distance in Z
+  if (dz > fMax) return kFALSE;//pair accepted
+  
+  Double_t drphi = TMath::Hypot(x1-x2,y1-y2);
+  
+  //fMin encodes treshold valaue of distance in r-phi
+  if (drphi > fMin) return kFALSE;
+  
+  return kTRUE;//they are too close, rejected
+}
+/******************************************************************/
+
+ClassImp(AliAODCluterOverlapCut)
+
+Double_t  AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
+{
+  //Returns Cluter Overlap Factor
+  //It ranges between -0.5 (in all padrows both tracks have cluters) 
+  // and 1 (in all padrows one track has cluter and second has not)
+  // When Overlap Factor is 1 this pair of tracks in highly probable to be
+  // splitted track: one particle that is recontructed twise
+
+  AliClusterMap* cm1 = pair->Particle1()->GetClusterMap();
+  if ( cm1 == 0x0)
+   {
+     Warning("GetValue","Track 1 does not have Cluster Map. Returning -0.5.");
+     return -.5;
+   }
+
+  AliClusterMap* cm2 = pair->Particle2()->GetClusterMap();
+  if ( cm2 == 0x0)
+   {
+     Warning("GetValue","Track 2 does not have Cluster Map. Returning -0.5.");
+     return -.5;
+   }
+  return cm1->GetOverlapFactor(*cm2);
+}
+/******************************************************************/
+ClassImp(AliAODOutSideSameSignCut)
+
+Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
+{
+  //returns kTRUE if pair DO NOT meet cut criteria
+  
+  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
+   {
+     return kFALSE;//accpeted
+   }
+
+  return kTRUE ;//rejected
+}
+/******************************************************************/
+ClassImp(AliAODOutSideDiffSignCut)
+
+Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
+{
+  //returns kTRUE if pair DO NOT meet cut criteria
+  
+  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
+   {
+     return kTRUE;//rejected
+   }
+  
+  return kFALSE;//accepted
+}
+/******************************************************************/
+ClassImp( AliAODLogicalOperPairCut )
+
+AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
+ AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
+ fFirst(new AliAODDummyBasePairCut),
+ fSecond(new AliAODDummyBasePairCut)
+{
+ //ctor
+}
+/******************************************************************/
+
+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
+  if ( (fFirst && fSecond) == kFALSE) 
+   {
+     Fatal("AliAODLogicalOperPairCut","One of parameters is NULL!");
+   }
+}
+/******************************************************************/
+
+AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
+{
+  //destructor
+  delete fFirst;
+  delete fSecond;
+}
+/******************************************************************/
+
+Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Rejected(AliAODPair* /*pair*/)  const
+{
+  //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
+}
+/******************************************************************/
+
+void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
+{
+  // Stream all objects in the array to or from the I/O buffer.
+  UInt_t R__s, R__c;
+  if (b.IsReading()) 
+   {
+     delete fFirst;
+     delete fSecond;
+     fFirst  = 0x0;
+     fSecond = 0x0;
+
+     b.ReadVersion(&R__s, &R__c);
+     TObject::Streamer(b);
+     b >> fFirst;
+     b >> fSecond;
+     b.CheckByteCount(R__s, R__c,AliAODLogicalOperPairCut::IsA());
+   } 
+  else 
+   {
+     R__c = b.WriteVersion(AliAODLogicalOperPairCut::IsA(), kTRUE);
+     TObject::Streamer(b);
+     b << fFirst;
+     b << fSecond;
+     b.SetByteCount(R__c, kTRUE);
+  }
+}
+
+/******************************************************************/
+ClassImp(AliAODOrPairCut)
+
+Bool_t AliAODOrPairCut::Rejected(AliAODPair * p) const
+{
+  //returns true when rejected 
+  //AND operation is a little bit misleading but is correct
+  //User wants to build logical cuts with natural (positive) logic
+  //while ALIAN use inernally reverse (returns true when rejected)
+  if (fFirst->Rejected(p) && fSecond->Rejected(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
+  return kFALSE;//accepted, at least one accepted (returned kFALSE)
+}
+/******************************************************************/
+
+ClassImp(AliAODAndPairCut)
+
+Bool_t AliAODAndPairCut::Rejected(AliAODPair * p)  const
+{
+  //returns true when rejected 
+  //OR operation is a little bit misleading but is correct
+  //User wants to build logical cuts with natural (positive) logic
+  //while ALIAN use inernally reverse (returns true when rejected)
+  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
+  return kFALSE;//accepted (both accepted (returned kFALSE))
+}
+/******************************************************************/
diff --git a/ANALYSIS/AliAODPairBaseCut.h b/ANALYSIS/AliAODPairBaseCut.h
new file mode 100644 (file)
index 0000000..2b1f404
--- /dev/null
@@ -0,0 +1,306 @@
+#ifndef ALIAODPAIRBASECUT_H
+#define ALIAODPAIRBASECUT_H
+
+#include <TNamed.h> 
+#include "AliAODPair.h"
+
+
+class AliAODPairBaseCut: public TObject
+{
+  //This class defines the range of some property - pure virtual
+  //Property is coded by AliAODCutTypes type
+   
+ public:
+
+  enum EAODPairCutProperty
+    {
+      kHbtPairCutPropQInv, //Q invariant
+      kHbtPairCutPropKt,
+      kHbtPairCutPropKStar,
+      kHbtPairCutPropQSideLCMS,
+      kHbtPairCutPropQOutLCMS,
+      kHbtPairCutPropQLongLCMS,
+      kHbtPairCutPropDeltaPhi,
+      kHbtPairCutPropDeltaTheta,
+      kHbtPairCutPropDeltaP,
+      kHbtPairCutPropDeltaPt,
+      kHbtPairCutPropAvSepar,
+      kHbtPairCutPropSepar,
+      kHbtPairCutPropClOverlap,
+      kHbtPairCutPropPixelSepar,
+      kHbtPairCutPropNone
+    };
+
+  AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, EAODPairCutProperty prop= kHbtPairCutPropNone):
+    fMin(min),fMax(max),fProperty(prop){}
+  
+  virtual   ~AliAODPairBaseCut(){}
+     
+  virtual Bool_t    Rejected(AliAODPair* pair) const;
+  
+  void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
+  
+  void      SetMinimum(Double_t min){fMin = min;}
+  void      SetMaximum(Double_t max){fMax = max;}
+  
+  Double_t  GetMinimum() const {return fMin;}
+  Double_t  GetMaximum() const {return fMax;}
+  
+  EAODPairCutProperty GetProperty() const {return fProperty;}
+  
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const = 0;
+  
+  Double_t fMin; // Lower boundary of the range
+  Double_t fMax; // Upper boundary of the range
+  
+  EAODPairCutProperty fProperty; // The property itself
+  
+  ClassDef(AliAODPairBaseCut,1)
+ };
+/******************************************************************/
+
+inline Bool_t AliAODPairBaseCut::Rejected(AliAODPair* pair) const
+{
+  //checks if pair proprty is in range
+  //null pointer check is made by AliAODPairCut, so here is unnecesary
+  
+  Double_t value = GetValue(pair);
+  if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
+  else return kTRUE; //rejected
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+class AliAODQInvCut: public AliAODPairBaseCut
+{
+ public:
+  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();}
+  
+  ClassDef(AliAODQInvCut,1)
+ };
+/******************************************************************/
+
+class AliAODKtCut: public AliAODPairBaseCut {
+ public:
+  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();}
+
+  ClassDef(AliAODKtCut,1)
+ };
+/******************************************************************/
+
+class AliAODKStarCut: public AliAODPairBaseCut
+{
+ public:
+  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();}
+
+  ClassDef(AliAODKStarCut,1)
+};
+/******************************************************************/
+
+class AliAODQSideLCMSCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
+  virtual ~AliAODQSideLCMSCut(){}
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const 
+    {return pair->GetQSideLCMS();}
+
+  ClassDef(AliAODQSideLCMSCut,1)
+};
+/******************************************************************/
+
+
+class AliAODQOutLCMSCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
+  virtual ~AliAODQOutLCMSCut(){}
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const 
+    {return pair->GetQOutLCMS();}
+  
+  ClassDef(AliAODQOutLCMSCut,1)
+};
+/******************************************************************/
+
+class AliAODQLongLCMSCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
+  virtual ~AliAODQLongLCMSCut(){}
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const 
+    {return pair->GetQLongLCMS();}
+
+  ClassDef(AliAODQLongLCMSCut,1)
+};
+/******************************************************************/
+
+class AliAODDeltaPhiCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
+  virtual ~AliAODDeltaPhiCut(){}
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const 
+    {return TMath::Abs(pair->GetDeltaPhi());}
+
+  ClassDef(AliAODDeltaPhiCut,1)
+};
+/******************************************************************/
+
+class AliAODDeltaThetaCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
+  virtual ~AliAODDeltaThetaCut(){}
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const 
+    {return TMath::Abs(pair->GetDeltaTheta());}
+
+  ClassDef(AliAODDeltaThetaCut,1)
+};
+/******************************************************************/
+
+class AliAODCluterOverlapCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
+  virtual ~AliAODCluterOverlapCut(){}
+
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const;
+  ClassDef(AliAODCluterOverlapCut,1)
+};
+/******************************************************************/
+  
+class AliAODAvSeparationCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
+  virtual ~AliAODAvSeparationCut(){}
+  
+ protected:
+  virtual Double_t  GetValue(AliAODPair* pair) const;
+  ClassDef(AliAODAvSeparationCut,1)
+};
+/******************************************************************/
+  
+class AliAODSeparationCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
+    AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
+  virtual ~AliAODSeparationCut(){}
+  
+ protected:
+  Int_t fPoint;//index of the point that distance should be measured
+  virtual Double_t  GetValue(AliAODPair* pair) const;
+  ClassDef(AliAODSeparationCut,1)
+};
+/******************************************************************/
+  
+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):
+    AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
+  virtual ~AliAODITSSeparationCut(){}
+  Bool_t   Rejected(AliAODPair* pair) const;
+  Int_t    GetLayer() const {return fLayer;}
+ protected:
+  Int_t fLayer;//index of the layer that distance should be measured 0: 1st pixels
+  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}//not used
+  ClassDef(AliAODITSSeparationCut,1)
+};
+/******************************************************************/
+
+class AliAODOutSideSameSignCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODOutSideSameSignCut(){}
+  virtual ~AliAODOutSideSameSignCut(){}
+  virtual Bool_t Rejected(AliAODPair *p) const;
+ protected:
+  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
+  ClassDef(AliAODOutSideSameSignCut,1)
+};
+/******************************************************************/
+
+class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
+{
+ public:
+  AliAODOutSideDiffSignCut(){}
+  virtual ~AliAODOutSideDiffSignCut(){}
+  virtual Bool_t Rejected(AliAODPair *p) const;
+ protected:
+  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
+  ClassDef(AliAODOutSideDiffSignCut,1)
+};
+/******************************************************************/
+
+class AliAODLogicalOperPairCut:  public AliAODPairBaseCut
+ {
+   public:
+     AliAODLogicalOperPairCut();
+     AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
+     virtual   ~AliAODLogicalOperPairCut();
+   protected:
+     Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
+
+     AliAODPairBaseCut* fFirst;   //second cut
+     AliAODPairBaseCut* fSecond;  //first cut
+   private:
+    class  AliAODDummyBasePairCut: public AliAODPairBaseCut
+     {
+       Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
+       Bool_t    Rejected(AliAODPair* /*pair*/) const;
+     };
+
+    ClassDef(AliAODLogicalOperPairCut,1)
+ };
+/******************************************************************/
+
+class AliAODOrPairCut: public AliAODLogicalOperPairCut
+{
+   public:
+     AliAODOrPairCut(){}
+     AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
+     virtual   ~AliAODOrPairCut(){}
+     Bool_t    Rejected(AliAODPair *p) const;
+     ClassDef(AliAODOrPairCut,1)
+};
+/******************************************************************/
+
+class AliAODAndPairCut: public AliAODLogicalOperPairCut
+{
+   public:
+     AliAODAndPairCut(){}
+     AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
+     virtual   ~AliAODAndPairCut(){}
+     Bool_t    Rejected(AliAODPair *p) const;
+     ClassDef(AliAODAndPairCut,1)
+};
+
+#endif
index 5c2a529..f0bb370 100644 (file)
@@ -1,3 +1,4 @@
+#include "AliAODPairCut.h"
 /* $Id$ */
 //____________________________________
 /////////////////////////////////////////////////////////////////////////
@@ -8,8 +9,6 @@
 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
 // Author: Piotr.Skowronski@cern.ch
 //-------------------------------------------------------------------
-
-#include "AliAODPairCut.h"
 #include "AliAODPair.h"
 #include "AliAODParticleCut.h"
 #include "AliTrackPoints.h"
@@ -193,7 +192,7 @@ void AliAODPairCut::SetPartCut(AliAODParticleCut* cut)
 void AliAODPairCut::SetQInvRange(Double_t min, Double_t max)
 {
   // set range of accepted invariant masses
-  AliAODQInvCut* cut= (AliAODQInvCut*)FindCut(kHbtPairCutPropQInv);
+  AliAODQInvCut* cut= (AliAODQInvCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQInv);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODQInvCut(min,max);
 }
@@ -201,7 +200,7 @@ void AliAODPairCut::SetQInvRange(Double_t min, Double_t max)
 void AliAODPairCut::SetQOutCMSLRange(Double_t min, Double_t max)
 {
   // set range of accepted QOut in CMS
-  AliAODQOutLCMSCut* cut= (AliAODQOutLCMSCut*)FindCut(kHbtPairCutPropQOutLCMS);
+  AliAODQOutLCMSCut* cut= (AliAODQOutLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQOutLCMS);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODQOutLCMSCut(min,max);
 }
@@ -210,7 +209,7 @@ void AliAODPairCut::SetQOutCMSLRange(Double_t min, Double_t max)
 void AliAODPairCut::SetQSideCMSLRange(Double_t min, Double_t max)
 {
   // set range of accepted QSide in CMS
-  AliAODQSideLCMSCut* cut= (AliAODQSideLCMSCut*)FindCut(kHbtPairCutPropQSideLCMS);
+  AliAODQSideLCMSCut* cut= (AliAODQSideLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQSideLCMS);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODQSideLCMSCut(min,max);
 }
@@ -219,7 +218,7 @@ void AliAODPairCut::SetQSideCMSLRange(Double_t min, Double_t max)
 void AliAODPairCut::SetQLongCMSLRange(Double_t min, Double_t max)
 {
   // set range of accepted QLong in CMS
-  AliAODQLongLCMSCut* cut= (AliAODQLongLCMSCut*)FindCut(kHbtPairCutPropQLongLCMS);
+  AliAODQLongLCMSCut* cut= (AliAODQLongLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQLongLCMS);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODQLongLCMSCut(min,max);
 }
@@ -229,7 +228,7 @@ void AliAODPairCut::SetQLongCMSLRange(Double_t min, Double_t max)
 void AliAODPairCut::SetKtRange(Double_t min, Double_t max)
 {
   // set range of accepted Kt (?)
-  AliAODKtCut* cut= (AliAODKtCut*)FindCut(kHbtPairCutPropKt);
+  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKt);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODKtCut(min,max);
 }
@@ -238,7 +237,7 @@ void AliAODPairCut::SetKtRange(Double_t min, Double_t max)
 void AliAODPairCut::SetKStarRange(Double_t min, Double_t max)
 {
   // set range of accepted KStar (?)
-  AliAODKStarCut* cut= (AliAODKStarCut*)FindCut(kHbtPairCutPropKStar);
+  AliAODKStarCut* cut= (AliAODKStarCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStar);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODKStarCut(min,max);
 }
@@ -247,7 +246,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
-  AliAODPairBaseCut* cut= FindCut(kHbtPairCutPropAvSepar);
+  AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropAvSepar);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
 }
@@ -256,7 +255,7 @@ void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
 void AliAODPairCut::SetITSSeparation(Int_t layer, Double_t drphi, Double_t dz)
 {
   //Anti-Merging Cut for first pixel layer
-  AliAODITSSeparationCut* cut= dynamic_cast<AliAODITSSeparationCut*>(FindCut(kHbtPairCutPropPixelSepar));
+  AliAODITSSeparationCut* cut= dynamic_cast<AliAODITSSeparationCut*>(FindCut(AliAODPairBaseCut::kHbtPairCutPropPixelSepar));
   if(cut) 
    {
      if (layer == cut->GetLayer())
@@ -280,13 +279,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 
   
-  AliAODPairBaseCut* cut= FindCut(kHbtPairCutPropClOverlap);
+  AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropClOverlap);
   if(cut) cut->SetRange(min,max);
   else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
 }
 /**********************************************************/
 
-AliAODPairBaseCut* AliAODPairCut::FindCut(EAODPairCutProperty property)
+AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairBaseCut::EAODPairCutProperty property)
 {
   // Find the cut corresponding to "property"
   for (Int_t i = 0;i<fNCuts;i++)
@@ -355,259 +354,3 @@ void AliAODPairEmptyCut::Streamer(TBuffer &b)
 }
 /******************************************************************/
 
-ClassImp(AliAODPairBaseCut)
-ClassImp(AliAODQInvCut)
-ClassImp(AliAODKtCut)
-ClassImp(AliAODQSideLCMSCut)
-ClassImp(AliAODQOutLCMSCut)
-ClassImp(AliAODQLongLCMSCut)
-
-/******************************************************************/
-ClassImp(AliAODAvSeparationCut)
-    
-Double_t AliAODAvSeparationCut::GetValue(AliAODPair* pair) const 
-{
-  //chacks if avarage distance of two tracks is in given range
-  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-
-  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-   
-  return tpts1->AvarageDistance(*tpts2);
-}
-/******************************************************************/
-ClassImp(AliAODSeparationCut)
-    
-Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const 
-{
-  //chacks if avarage distance of two tracks is in given range
-  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-
-  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-  Float_t x1=0,y1=0,z1=0; 
-  Float_t x2=0,y2=0,z2=0;
-  
-  tpts1->PositionAt(fPoint,x1,y1,z1);
-  tpts2->PositionAt(fPoint,x2,y2,z2);
-  Double_t dx1 = x1 - x2;
-  Double_t dy1 = y1 - y2;
-  Double_t dz1 = z1 - z2;
-  Double_t d = TMath::Sqrt(dx1*dx1 + dy1*dy1 + dz1*dz1);
-  return d;
-}
-/******************************************************************/
-
-ClassImp(AliAODITSSeparationCut)
-
-Bool_t AliAODITSSeparationCut::Rejected(AliAODPair* pair) const
-{
- //Checks if two tracks do not cross first pixels too close to each other
- //If two tracks use the same cluster in pixels they are given
- //the same position what skews theta angles (both are the same)
- //These guys create artificial correlation in non-id analyses
- //which is positive for identical polar angles (Qlong=0) 
- //and negative for a little bit different theta angle (Qlong=epsilon)
- //Such tracks "attracks" each other.
-  AliTrackPoints* tpts1 = pair->Particle1()->GetITSTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-     Warning("Pass","Track 1 does not have ITS Track Points. Pair NOT Passed.");
-     return kTRUE;//reject 
-   }
-
-  AliTrackPoints* tpts2 = pair->Particle2()->GetITSTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-     Warning("Pass","Track 2 does not have ITS Track Points. Pair NOT Passed.");
-     return kTRUE;//reject 
-   }
-  Float_t  x1=0.0,y1=0.0,z1=0.0,x2=0.0,y2=0.0,z2=0.0;
-  tpts1->PositionAt(fLayer,x1,y1,z1);
-  tpts2->PositionAt(fLayer,x2,y2,z2);
-  
-//  Info("Pass","rphi %f z %f",fMin,fMax);
-//  Info("Pass","P1: %f %f %f", x1,y1,z1);
-//  Info("Pass","P2: %f %f %f", x2,y2,z2);
-  
-  Double_t dz = TMath::Abs(z1-z2);
-  
-  //fMax encodes treshold valaue of distance in Z
-  if (dz > fMax) return kFALSE;//pair accepted
-  
-  Double_t drphi = TMath::Hypot(x1-x2,y1-y2);
-  
-  //fMin encodes treshold valaue of distance in r-phi
-  if (drphi > fMin) return kFALSE;
-  
-  return kTRUE;//they are too close, rejected
-}
-/******************************************************************/
-
-ClassImp(AliAODCluterOverlapCut)
-
-Double_t  AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
-{
-  //Returns Cluter Overlap Factor
-  //It ranges between -0.5 (in all padrows both tracks have cluters) 
-  // and 1 (in all padrows one track has cluter and second has not)
-  // When Overlap Factor is 1 this pair of tracks in highly probable to be
-  // splitted track: one particle that is recontructed twise
-
-  AliClusterMap* cm1 = pair->Particle1()->GetClusterMap();
-  if ( cm1 == 0x0)
-   {
-     Warning("GetValue","Track 1 does not have Cluster Map. Returning -0.5.");
-     return -.5;
-   }
-
-  AliClusterMap* cm2 = pair->Particle2()->GetClusterMap();
-  if ( cm2 == 0x0)
-   {
-     Warning("GetValue","Track 2 does not have Cluster Map. Returning -0.5.");
-     return -.5;
-   }
-  return cm1->GetOverlapFactor(*cm2);
-}
-/******************************************************************/
-ClassImp(AliAODOutSideSameSignCut)
-
-Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
-{
-  //returns kTRUE if pair DO NOT meet cut criteria
-  
-  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
-   {
-     return kFALSE;//accpeted
-   }
-
-  return kTRUE ;//rejected
-}
-/******************************************************************/
-ClassImp(AliAODOutSideDiffSignCut)
-
-Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
-{
-  //returns kTRUE if pair DO NOT meet cut criteria
-  
-  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
-   {
-     return kTRUE;//rejected
-   }
-  
-  return kFALSE;//accepted
-}
-/******************************************************************/
-ClassImp( AliAODLogicalOperPairCut )
-
-AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
- AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
- fFirst(new AliAODDummyBasePairCut),
- fSecond(new AliAODDummyBasePairCut)
-{
- //ctor
-}
-/******************************************************************/
-
-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
-  if ( (fFirst && fSecond) == kFALSE) 
-   {
-     Fatal("AliAODLogicalOperPairCut","One of parameters is NULL!");
-   }
-}
-/******************************************************************/
-
-AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
-{
-  //destructor
-  delete fFirst;
-  delete fSecond;
-}
-/******************************************************************/
-
-Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Rejected(AliAODPair* /*pair*/)  const
-{
-  //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
-}
-/******************************************************************/
-
-void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
-{
-  // Stream all objects in the array to or from the I/O buffer.
-  UInt_t R__s, R__c;
-  if (b.IsReading()) 
-   {
-     delete fFirst;
-     delete fSecond;
-     fFirst  = 0x0;
-     fSecond = 0x0;
-
-     b.ReadVersion(&R__s, &R__c);
-     TObject::Streamer(b);
-     b >> fFirst;
-     b >> fSecond;
-     b.CheckByteCount(R__s, R__c,AliAODLogicalOperPairCut::IsA());
-   } 
-  else 
-   {
-     R__c = b.WriteVersion(AliAODLogicalOperPairCut::IsA(), kTRUE);
-     TObject::Streamer(b);
-     b << fFirst;
-     b << fSecond;
-     b.SetByteCount(R__c, kTRUE);
-  }
-}
-
-/******************************************************************/
-ClassImp(AliAODOrPairCut)
-
-Bool_t AliAODOrPairCut::Rejected(AliAODPair * p) const
-{
-  //returns true when rejected 
-  //AND operation is a little bit misleading but is correct
-  //User wants to build logical cuts with natural (positive) logic
-  //while ALIAN use inernally reverse (returns true when rejected)
-  if (fFirst->Rejected(p) && fSecond->Rejected(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
-  return kFALSE;//accepted, at least one accepted (returned kFALSE)
-}
-/******************************************************************/
-
-ClassImp(AliAODAndPairCut)
-
-Bool_t AliAODAndPairCut::Rejected(AliAODPair * p)  const
-{
-  //returns true when rejected 
-  //OR operation is a little bit misleading but is correct
-  //User wants to build logical cuts with natural (positive) logic
-  //while ALIAN use inernally reverse (returns true when rejected)
-  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
-  return kFALSE;//accepted (both accepted (returned kFALSE))
-}
-/******************************************************************/
index e0fd7a9..e4e9739 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef AliAODPairCUT_H
-#define AliAODPairCUT_H
+#ifndef ALIAODPAIRCUT_H
+#define ALIAODPAIRCUT_H
 
 /* $Id$ */
 
@@ -8,30 +8,11 @@
 //
 //more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
 #include <TNamed.h> 
-
-#include "AliAODPair.h"
+#include "AliAODPairBaseCut.h"
 
 class AliAODParticleCut;
 class AliAODPairBaseCut;
 
-enum EAODPairCutProperty
-{
-  kHbtPairCutPropQInv, //Q invariant
-  kHbtPairCutPropKt,
-  kHbtPairCutPropKStar,
-  kHbtPairCutPropQSideLCMS,
-  kHbtPairCutPropQOutLCMS,
-  kHbtPairCutPropQLongLCMS,
-  kHbtPairCutPropDeltaPhi,
-  kHbtPairCutPropDeltaTheta,
-  kHbtPairCutPropDeltaP,
-  kHbtPairCutPropDeltaPt,
-  kHbtPairCutPropAvSepar,
-  kHbtPairCutPropSepar,
-  kHbtPairCutPropClOverlap,
-  kHbtPairCutPropPixelSepar,
-  kHbtPairCutPropNone
-};
 /******************************************************************/
 
 class AliAODPairCut: public TNamed
@@ -76,7 +57,7 @@ class AliAODPairCut: public TNamed
   Int_t fNCuts;//Number of cuts in fCuts array
   
   
-  AliAODPairBaseCut* FindCut(EAODPairCutProperty cut);
+  AliAODPairBaseCut* FindCut(AliAODPairBaseCut::EAODPairCutProperty cut);
  private:
   static const Int_t fgkMaxCuts; // Max number of cuts
   ClassDef(AliAODPairCut,2)
@@ -101,288 +82,4 @@ class AliAODPairEmptyCut:  public AliAODPairCut
 };
 
 
-
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODPairBaseCut: public TObject
-{
-  //This class defines the range of some property - pure virtual
-  //Property is coded by AliAODCutTypes type
-   
- public:
-     
-  AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, EAODPairCutProperty prop= kHbtPairCutPropNone):
-    fMin(min),fMax(max),fProperty(prop){}
-  
-  virtual   ~AliAODPairBaseCut(){}
-     
-  virtual Bool_t    Rejected(AliAODPair* pair) const;
-  
-  void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
-  
-  void      SetMinimum(Double_t min){fMin = min;}
-  void      SetMaximum(Double_t max){fMax = max;}
-  
-  Double_t  GetMinimum() const {return fMin;}
-  Double_t  GetMaximum() const {return fMax;}
-  
-  EAODPairCutProperty GetProperty() const {return fProperty;}
-  
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const = 0;
-  
-  Double_t fMin; // Lower boundary of the range
-  Double_t fMax; // Upper boundary of the range
-  
-  EAODPairCutProperty fProperty; // The property itself
-  
-  ClassDef(AliAODPairBaseCut,1)
- };
-/******************************************************************/
-
-inline Bool_t AliAODPairBaseCut::Rejected(AliAODPair* pair) const
-{
-  //checks if pair proprty is in range
-  //null pointer check is made by AliAODPairCut, so here is unnecesary
-  
-  Double_t value = GetValue(pair);
-  if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
-  else return kTRUE; //rejected
-}
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODQInvCut: public AliAODPairBaseCut
-{
- public:
-  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();}
-  
-  ClassDef(AliAODQInvCut,1)
- };
-/******************************************************************/
-
-class AliAODKtCut: public AliAODPairBaseCut {
- public:
-  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();}
-
-  ClassDef(AliAODKtCut,1)
- };
-/******************************************************************/
-
-class AliAODKStarCut: public AliAODPairBaseCut
-{
- public:
-  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();}
-
-  ClassDef(AliAODKStarCut,1)
-};
-/******************************************************************/
-
-class AliAODQSideLCMSCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
-  virtual ~AliAODQSideLCMSCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetQSideLCMS();}
-
-  ClassDef(AliAODQSideLCMSCut,1)
-};
-/******************************************************************/
-
-
-class AliAODQOutLCMSCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
-  virtual ~AliAODQOutLCMSCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetQOutLCMS();}
-  
-  ClassDef(AliAODQOutLCMSCut,1)
-};
-/******************************************************************/
-
-class AliAODQLongLCMSCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
-  virtual ~AliAODQLongLCMSCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetQLongLCMS();}
-
-  ClassDef(AliAODQLongLCMSCut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaPhiCut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
-  virtual ~AliAODDeltaPhiCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return TMath::Abs(pair->GetDeltaPhi());}
-
-  ClassDef(AliAODDeltaPhiCut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaThetaCut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
-  virtual ~AliAODDeltaThetaCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return TMath::Abs(pair->GetDeltaTheta());}
-
-  ClassDef(AliAODDeltaThetaCut,1)
-};
-/******************************************************************/
-
-class AliAODCluterOverlapCut: public AliAODPairBaseCut
-{
- public:
-  AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
-  virtual ~AliAODCluterOverlapCut(){}
-
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const;
-  ClassDef(AliAODCluterOverlapCut,1)
-};
-/******************************************************************/
-  
-class AliAODAvSeparationCut: public AliAODPairBaseCut
-{
- public:
-  AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
-  virtual ~AliAODAvSeparationCut(){}
-  
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const;
-  ClassDef(AliAODAvSeparationCut,1)
-};
-/******************************************************************/
-  
-class AliAODSeparationCut: public AliAODPairBaseCut
-{
- public:
-  AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
-  virtual ~AliAODSeparationCut(){}
-  
- protected:
-  Int_t fPoint;//index of the point that distance should be measured
-  virtual Double_t  GetValue(AliAODPair* pair) const;
-  ClassDef(AliAODSeparationCut,1)
-};
-/******************************************************************/
-  
-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):
-    AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
-  virtual ~AliAODITSSeparationCut(){}
-  Bool_t   Rejected(AliAODPair* pair) const;
-  Int_t    GetLayer() const {return fLayer;}
- protected:
-  Int_t fLayer;//index of the layer that distance should be measured 0: 1st pixels
-  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}//not used
-  ClassDef(AliAODITSSeparationCut,1)
-};
-/******************************************************************/
-
-class AliAODOutSideSameSignCut: public AliAODPairBaseCut
-{
- public:
-  AliAODOutSideSameSignCut(){}
-  virtual ~AliAODOutSideSameSignCut(){}
-  virtual Bool_t Rejected(AliAODPair *p) const;
- protected:
-  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-  ClassDef(AliAODOutSideSameSignCut,1)
-};
-/******************************************************************/
-
-class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
-{
- public:
-  AliAODOutSideDiffSignCut(){}
-  virtual ~AliAODOutSideDiffSignCut(){}
-  virtual Bool_t Rejected(AliAODPair *p) const;
- protected:
-  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-  ClassDef(AliAODOutSideDiffSignCut,1)
-};
-/******************************************************************/
-
-class AliAODLogicalOperPairCut:  public AliAODPairBaseCut
- {
-   public:
-     AliAODLogicalOperPairCut();
-     AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
-     virtual   ~AliAODLogicalOperPairCut();
-   protected:
-     Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
-
-     AliAODPairBaseCut* fFirst;   //second cut
-     AliAODPairBaseCut* fSecond;  //first cut
-   private:
-    class  AliAODDummyBasePairCut: public AliAODPairBaseCut
-     {
-       Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-       Bool_t    Rejected(AliAODPair* /*pair*/) const;
-     };
-
-    ClassDef(AliAODLogicalOperPairCut,1)
- };
-/******************************************************************/
-
-class AliAODOrPairCut: public AliAODLogicalOperPairCut
-{
-   public:
-     AliAODOrPairCut(){}
-     AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
-     virtual   ~AliAODOrPairCut(){}
-     Bool_t    Rejected(AliAODPair *p) const;
-     ClassDef(AliAODOrPairCut,1)
-};
-/******************************************************************/
-
-class AliAODAndPairCut: public AliAODLogicalOperPairCut
-{
-   public:
-     AliAODAndPairCut(){}
-     AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
-     virtual   ~AliAODAndPairCut(){}
-     Bool_t    Rejected(AliAODPair *p) const;
-     ClassDef(AliAODAndPairCut,1)
-};
-
 #endif
index 4d7d509..ab84f23 100644 (file)
@@ -1,9 +1,9 @@
 SRCS= AliAOD.cxx AliEventBuffer.cxx \
+      AliRunAnalysis.cxx AliAnalysis.cxx \
       AliVAODParticle.cxx AliAODParticle.cxx \
-      AliAODPair.cxx        AliAODPairCut.cxx \
+      AliAODPair.cxx   AliAODRun.cxx     \
       AliAODParticleCut.cxx AliAODParticleBaseCut.cxx \
-      AliAODRun.cxx \
-      AliRunAnalysis.cxx AliAnalysis.cxx \
+      AliAODPairCut.cxx AliAODPairBaseCut.cxx \
       AliEventCut.cxx AliEventBaseCut.cxx \
       AliReader.cxx AliReaderESD.cxx AliReaderKineTree.cxx\
       AliTrackPoints.cxx AliClusterMap.cxx \
@@ -15,9 +15,9 @@ DHDR:=ANALYSISLinkDef.h
 
 EXPORT:=AliAOD.h AliEventBuffer.h\
       AliVAODParticle.h     AliAODParticle.h  \
-      AliAODPair.h          AliAODPairCut.h   \
+      AliAODPair.h          AliAODRun.h \
+      AliAODPairCut.h       AliAODPairBaseCut.h \
       AliAODParticleCut.h   AliAODParticleBaseCut.h \
-      AliAODRun.h       \
       AliRunAnalysis.h      AliAnalysis.h     \
       AliEventCut.h         AliEventBaseCut.h \
       AliReader.h           AliReaderESD.h    \