Pass() renamed to Rejected()
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 5 Jul 2004 16:43:11 +0000 (16:43 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 5 Jul 2004 16:43:11 +0000 (16:43 +0000)
24 files changed:
ANALYSIS/AliAODPairCut.cxx
ANALYSIS/AliAODPairCut.h
ANALYSIS/AliAODParticleCut.cxx
ANALYSIS/AliAODParticleCut.h
ANALYSIS/AliAnalysis.cxx
ANALYSIS/AliAnalysis.h
ANALYSIS/AliEventBaseCut.cxx
ANALYSIS/AliEventBaseCut.h
ANALYSIS/AliEventCut.cxx
ANALYSIS/AliEventCut.h
ANALYSIS/AliFlowAnalysis.cxx
ANALYSIS/AliReader.cxx
ANALYSIS/AliReader.h
ANALYSIS/AliReaderESD.cxx
ANALYSIS/AliReaderKineTree.cxx
ANALYSIS/AliRunAnalysis.cxx
ANALYSIS/AliRunAnalysis.h
HBTAN/AliHBTAnalysis.cxx
HBTAN/AliHBTFunction.h
HBTAN/AliHBTMonitorFunction.h
HBTAN/AliHBTReader.cxx
HBTAN/AliHBTReader.h
HBTAN/AliHBTReaderInternal.cxx
HBTAN/AliHBTReaderTPC.cxx

index 4bc41ba..5c2a529 100644 (file)
@@ -100,7 +100,7 @@ void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
 }
 /**********************************************************/
 
-Bool_t AliAODPairCut::Pass(AliAODPair* pair) const
+Bool_t AliAODPairCut::Rejected(AliAODPair* pair) const
 {
   //methods which checks if given pair meets all criteria of the cut
   //if it meets returns FALSE
@@ -112,8 +112,8 @@ Bool_t AliAODPairCut::Pass(AliAODPair* pair) const
     }
   
   //check particle's cuts
-  if( ( fFirstPartCut->Pass( pair->Particle1()) ) || 
-      ( fSecondPartCut->Pass(pair->Particle2()) )   )
+  if( ( fFirstPartCut->Rejected( pair->Particle1()) ) || 
+      ( fSecondPartCut->Rejected(pair->Particle2()) )   )
     {  
       return kTRUE;
     }
@@ -129,7 +129,7 @@ Bool_t AliAODPairCut::PassPairProp(AliAODPair* pair) const
   //examine all base pair cuts
   for (Int_t i = 0;i<fNCuts;i++)
     {
-      if ( (fCuts[i]->Pass(pair)) ) return kTRUE; //if one of the cuts reject, then reject
+      if ( (fCuts[i]->Rejected(pair)) ) return kTRUE; //if one of the cuts reject, then reject
     }
   return kFALSE;
 }
@@ -418,7 +418,7 @@ Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const
 
 ClassImp(AliAODITSSeparationCut)
 
-Bool_t AliAODITSSeparationCut::Pass(AliAODPair* pair) const
+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
@@ -491,7 +491,7 @@ Double_t  AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
 /******************************************************************/
 ClassImp(AliAODOutSideSameSignCut)
 
-Bool_t AliAODOutSideSameSignCut::Pass(AliAODPair *p) const
+Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
 {
   //returns kTRUE if pair DO NOT meet cut criteria
   
@@ -505,7 +505,7 @@ Bool_t AliAODOutSideSameSignCut::Pass(AliAODPair *p) const
 /******************************************************************/
 ClassImp(AliAODOutSideDiffSignCut)
 
-Bool_t AliAODOutSideDiffSignCut::Pass(AliAODPair *p) const
+Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
 {
   //returns kTRUE if pair DO NOT meet cut criteria
   
@@ -550,7 +550,7 @@ AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
 }
 /******************************************************************/
 
-Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Pass(AliAODPair* /*pair*/)  const
+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");
@@ -588,26 +588,26 @@ void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
 /******************************************************************/
 ClassImp(AliAODOrPairCut)
 
-Bool_t AliAODOrPairCut::Pass(AliAODPair * p) const
+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->Pass(p) && fSecond->Pass(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
+  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::Pass(AliAODPair * p)  const
+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->Pass(p) || fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
+  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
   return kFALSE;//accepted (both accepted (returned kFALSE))
 }
 /******************************************************************/
index 0597588..e0fd7a9 100644 (file)
@@ -42,7 +42,7 @@ class AliAODPairCut: public TNamed
   AliAODPairCut& operator = (const AliAODPairCut& in);
   
   virtual ~AliAODPairCut();
-  virtual Bool_t Pass(AliAODPair* pair) const;
+  virtual Bool_t Rejected(AliAODPair* pair) const;
   virtual Bool_t PassPairProp(AliAODPair* pair) const;
      
   virtual Bool_t IsEmpty() const {return kFALSE;}
@@ -94,7 +94,7 @@ class AliAODPairEmptyCut:  public AliAODPairCut
   AliAODPairEmptyCut(const AliAODPairEmptyCut& in):AliAODPairCut(in){};
   virtual ~AliAODPairEmptyCut(){};
   
-  Bool_t Pass(AliAODPair*) const {return kFALSE;} //accpept everything
+  Bool_t Rejected(AliAODPair*) const {return kFALSE;} //accpept everything
   Bool_t IsEmpty() const {return kTRUE;}
   
   ClassDef(AliAODPairEmptyCut,1)
@@ -118,7 +118,7 @@ class AliAODPairBaseCut: public TObject
   
   virtual   ~AliAODPairBaseCut(){}
      
-  virtual Bool_t    Pass(AliAODPair* pair) const;
+  virtual Bool_t    Rejected(AliAODPair* pair) const;
   
   void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
   
@@ -143,7 +143,7 @@ class AliAODPairBaseCut: public TObject
  };
 /******************************************************************/
 
-inline Bool_t AliAODPairBaseCut::Pass(AliAODPair* pair) const
+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
@@ -309,7 +309,7 @@ class AliAODITSSeparationCut: public AliAODPairBaseCut
   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   Pass(AliAODPair* pair) const;
+  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
@@ -323,7 +323,7 @@ class AliAODOutSideSameSignCut: public AliAODPairBaseCut
  public:
   AliAODOutSideSameSignCut(){}
   virtual ~AliAODOutSideSameSignCut(){}
-  virtual Bool_t Pass(AliAODPair *p) const;
+  virtual Bool_t Rejected(AliAODPair *p) const;
  protected:
   virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
   ClassDef(AliAODOutSideSameSignCut,1)
@@ -335,7 +335,7 @@ class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
  public:
   AliAODOutSideDiffSignCut(){}
   virtual ~AliAODOutSideDiffSignCut(){}
-  virtual Bool_t Pass(AliAODPair *p) const;
+  virtual Bool_t Rejected(AliAODPair *p) const;
  protected:
   virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
   ClassDef(AliAODOutSideDiffSignCut,1)
@@ -357,7 +357,7 @@ class AliAODLogicalOperPairCut:  public AliAODPairBaseCut
     class  AliAODDummyBasePairCut: public AliAODPairBaseCut
      {
        Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-       Bool_t    Pass(AliAODPair* /*pair*/) const;
+       Bool_t    Rejected(AliAODPair* /*pair*/) const;
      };
 
     ClassDef(AliAODLogicalOperPairCut,1)
@@ -370,7 +370,7 @@ class AliAODOrPairCut: public AliAODLogicalOperPairCut
      AliAODOrPairCut(){}
      AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
      virtual   ~AliAODOrPairCut(){}
-     Bool_t    Pass(AliAODPair *p) const;
+     Bool_t    Rejected(AliAODPair *p) const;
      ClassDef(AliAODOrPairCut,1)
 };
 /******************************************************************/
@@ -381,7 +381,7 @@ class AliAODAndPairCut: public AliAODLogicalOperPairCut
      AliAODAndPairCut(){}
      AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
      virtual   ~AliAODAndPairCut(){}
-     Bool_t    Pass(AliAODPair *p) const;
+     Bool_t    Rejected(AliAODPair *p) const;
      ClassDef(AliAODAndPairCut,1)
 };
 
index 4537c68..bf5c977 100644 (file)
@@ -81,21 +81,21 @@ AliAODParticleCut::~AliAODParticleCut()
 } 
 /******************************************************************/
 
-Bool_t AliAODParticleCut::Pass(AliVAODParticle* p) const
+Bool_t AliAODParticleCut::Rejected(AliVAODParticle* p) const
 {
 //method checks all the cuts that are set (in the list)
 //If any of the baseCuts rejects particle False(rejection) is returned
 
  if(!p) 
   {
-    Warning("Pass()","No Pasaran! We never accept NULL pointers");
+    Warning("Rejected()","No Pasaran! We never accept NULL pointers");
     return kTRUE;
   }
  if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
  
  for (Int_t i = 0;i<fNCuts;i++)
    {
-    if ( (fCuts[i]->Pass(p)) )
+    if ( (fCuts[i]->Rejected(p)) )
      {
 //       fCuts[i]->Print();
        return kTRUE; //if one of the cuts rejects, then reject
@@ -424,7 +424,7 @@ AliAODLogicalOperCut::~AliAODLogicalOperCut()
 }
 /******************************************************************/
 
-Bool_t AliAODLogicalOperCut::AliAODDummyBaseCut::Pass(AliVAODParticle* /*part*/)  const
+Bool_t AliAODLogicalOperCut::AliAODDummyBaseCut::Rejected(AliVAODParticle* /*part*/)  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");
@@ -462,26 +462,26 @@ void AliAODLogicalOperCut::Streamer(TBuffer &b)
 /******************************************************************/
 ClassImp(AliAODOrCut)
 
-Bool_t AliAODOrCut::Pass(AliVAODParticle * p) const
+Bool_t AliAODOrCut::Rejected(AliVAODParticle * 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 AODAN use inernally reverse (returns true when rejected)
-  if (fFirst->Pass(p) && fSecond->Pass(p)) return kTRUE;//rejected (both rejected, returned kTRUE)
+  if (fFirst->Rejected(p) && fSecond->Rejected(p)) return kTRUE;//rejected (both rejected, returned kTRUE)
   return kFALSE;//accepted, at least one accepted (returned kFALSE)
 }
 /******************************************************************/
 
 ClassImp(AliAODAndCut)
 
-Bool_t AliAODAndCut::Pass(AliVAODParticle * p)  const
+Bool_t AliAODAndCut::Rejected(AliVAODParticle * 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 AODAN use inernally reverse (returns true when rejected)
-  if (fFirst->Pass(p) || fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
+  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
   return kFALSE;//accepted (both accepted (returned kFALSE))
 }
 /******************************************************************/
index d28a593..ed647d3 100644 (file)
@@ -70,7 +70,7 @@ class AliAODParticleCut: public TObject
     virtual ~AliAODParticleCut();
     AliAODParticleCut& operator = (const AliAODParticleCut& in);
     
-    virtual Bool_t Pass(AliVAODParticle* p) const;
+    virtual Bool_t Rejected(AliVAODParticle* p) const;
     Bool_t IsEmpty() const {return kFALSE;}
     
     void AddBasePartCut(AliAODParticleBaseCut* basecut);
@@ -120,7 +120,7 @@ class AliAODParticleEmptyCut:  public AliAODParticleCut
     AliAODParticleEmptyCut(){};
     virtual ~AliAODParticleEmptyCut(){};
     
-    Bool_t Pass(AliVAODParticle*) const {return kFALSE;} //accept everything
+    Bool_t Rejected(AliVAODParticle*) const {return kFALSE;} //accept everything
     Bool_t IsEmpty() const {return kTRUE;}
 
     ClassDef(AliAODParticleEmptyCut,1)
@@ -143,7 +143,7 @@ class AliAODParticleBaseCut: public TObject
 
      virtual           ~AliAODParticleBaseCut(){}
      
-     virtual Bool_t    Pass(AliVAODParticle *p) const;
+     virtual Bool_t    Rejected(AliVAODParticle *p) const;
      
      void              SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
 
@@ -170,7 +170,7 @@ class AliAODParticleBaseCut: public TObject
  };
 
 inline Bool_t
-AliAODParticleBaseCut::Pass(AliVAODParticle *p) const
+AliAODParticleBaseCut::Rejected(AliVAODParticle *p) const
 {
   //cjecks if particle property fits in range
   if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
@@ -361,7 +361,7 @@ class AliAODLogicalOperCut:  public AliAODParticleBaseCut
     class  AliAODDummyBaseCut: public AliAODParticleBaseCut 
      {
        Double_t  GetValue(AliVAODParticle * /*part*/) const {return 0.0;}
-       Bool_t    Pass(AliVAODParticle* /*part*/) const;
+       Bool_t    Rejected(AliVAODParticle* /*part*/) const;
      };
      
     ClassDef(AliAODLogicalOperCut,1)
@@ -373,7 +373,7 @@ class AliAODOrCut: public AliAODLogicalOperCut
      AliAODOrCut(){}
      AliAODOrCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
      virtual   ~AliAODOrCut(){}
-     Bool_t    Pass(AliVAODParticle *p) const;
+     Bool_t    Rejected(AliVAODParticle *p) const;
      ClassDef(AliAODOrCut,1)
 };
 
@@ -383,7 +383,7 @@ class AliAODAndCut: public AliAODLogicalOperCut
      AliAODAndCut(){}
      AliAODAndCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
      virtual   ~AliAODAndCut(){}
-     Bool_t    Pass(AliVAODParticle *p) const;
+     Bool_t    Rejected(AliVAODParticle *p) const;
      ClassDef(AliAODAndCut,1)
 };
 
index a9956b8..7ad46df 100644 (file)
@@ -63,16 +63,16 @@ void AliAnalysis::SetEventCut(AliEventCut* evcut)
 }
 /*********************************************************/
 
-Bool_t AliAnalysis::Pass(AliAOD* recevent, AliAOD* simevent)
+Bool_t AliAnalysis::Rejected(AliAOD* recevent, AliAOD* simevent)
 {
   //checks the event cut
   if (fEventCut == 0x0) return kFALSE;
   
   if (fCutOnRec)
-    if (fEventCut->Pass(recevent)) return kTRUE;
+    if (fEventCut->Rejected(recevent)) return kTRUE;
     
   if (fCutOnSim)
-    if (fEventCut->Pass(simevent)) return kTRUE;
+    if (fEventCut->Rejected(simevent)) return kTRUE;
   
   return kFALSE;
 }
index 7afebb5..79fe759 100644 (file)
@@ -41,7 +41,7 @@ class AliAnalysis: public TTask
     void          SetPairCut(AliAODPairCut* cut);
     
   protected:
-    Bool_t        Pass(AliAOD* recevent, AliAOD* simevent);
+    Bool_t        Rejected(AliAOD* recevent, AliAOD* simevent);
     AliEventCut*  fEventCut;//event cut
 
     Bool_t        fCutOnSim;//flag indicating that event cut is performed on simulated particles 
@@ -58,19 +58,19 @@ class AliAnalysis: public TTask
     Bool_t (AliAnalysis::*fkPass2)(AliVAODParticle* partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on second particle
     Bool_t (AliAnalysis::*fkPassPairProp)(AliAODPair* partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
 
-    Bool_t PassPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->Pass((AliAODPair*)partpair))?kTRUE:fPairCut->Pass((AliAODPair*)trackpair);}
+    Bool_t PassPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->Rejected((AliAODPair*)partpair))?kTRUE:fPairCut->Rejected((AliAODPair*)trackpair);}
     Bool_t PassPartAndTrack1(AliVAODParticle* part, AliVAODParticle* track) const;
     Bool_t PassPartAndTrack2(AliVAODParticle* part, AliVAODParticle* track) const;
     Bool_t PassPairPropPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->PassPairProp((AliAODPair*)partpair))?kTRUE:fPairCut->PassPairProp((AliAODPair*)trackpair);}
 
-    Bool_t PassPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->Pass((AliAODPair*)partpair);}
-    Bool_t PassPart1(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetFirstPartCut()->Pass(part);}
-    Bool_t PassPart2(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetSecondPartCut()->Pass(part);}
+    Bool_t PassPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->Rejected((AliAODPair*)partpair);}
+    Bool_t PassPart1(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetFirstPartCut()->Rejected(part);}
+    Bool_t PassPart2(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetSecondPartCut()->Rejected(part);}
     Bool_t PassPairPropPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->PassPairProp((AliAODPair*)partpair);}
 
-    Bool_t PassTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->Pass((AliAODPair*)trackpair);}
-    Bool_t PassTrack1(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetFirstPartCut()->Pass(track);}
-    Bool_t PassTrack2(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetSecondPartCut()->Pass(track);}
+    Bool_t PassTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->Rejected((AliAODPair*)trackpair);}
+    Bool_t PassTrack1(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetFirstPartCut()->Rejected(track);}
+    Bool_t PassTrack2(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetSecondPartCut()->Rejected(track);}
     Bool_t PassPairPropTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->PassPairProp((AliAODPair*)trackpair);}
 
   private:
@@ -82,7 +82,7 @@ inline Bool_t AliAnalysis::PassPartAndTrack1(AliVAODParticle* part,AliVAODPartic
 {
 //Checks first particle from both, particle and track pairs
   AliAODParticleCut* pc = fPairCut->GetFirstPartCut();
-  return (pc->Pass(part))?kTRUE:pc->Pass(track);
+  return (pc->Rejected(part))?kTRUE:pc->Rejected(track);
 }
 /*************************************************************************************/
 
@@ -90,7 +90,7 @@ inline Bool_t AliAnalysis::PassPartAndTrack2(AliVAODParticle* part,AliVAODPartic
 {
 //Checks second particle from both, particle and track pairs
   AliAODParticleCut* pc = fPairCut->GetSecondPartCut();
-  return (pc->Pass(part))?kTRUE:pc->Pass(track);
+  return (pc->Rejected(part))?kTRUE:pc->Rejected(track);
 }
 /*************************************************************************************/ 
 
index d209305..e5fbe7f 100644 (file)
@@ -30,7 +30,7 @@ AliEventBaseCut::AliEventBaseCut(Double_t min, Double_t max, EEventCutProperty p
 }
 /**********************************************************/
 
-Bool_t AliEventBaseCut::Pass(AliAOD* aod) const
+Bool_t AliEventBaseCut::Rejected(AliAOD* aod) const
 {
   if ( (GetValue(aod) < fMin) || (GetValue(aod) > fMax) ) return kTRUE;
   return kFALSE;
index c50d19f..9ba71a4 100644 (file)
@@ -30,7 +30,7 @@ class AliEventBaseCut: public TObject
     AliEventBaseCut();
     AliEventBaseCut(Double_t min,Double_t max, EEventCutProperty prop = kNone);
     virtual ~AliEventBaseCut(){}
-    virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
+    virtual Bool_t Rejected(AliAOD* aod) const;//returns kTRUE if rejected
     virtual void   SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
 
     virtual EEventCutProperty GetProperty()const{return fProperty;}
index 9124460..af3cb70 100644 (file)
@@ -40,7 +40,7 @@ AliEventCut::~AliEventCut()
 
 /*********************************************************/
 
-Bool_t AliEventCut::Pass(AliAOD* aod) const
+Bool_t AliEventCut::Rejected(AliAOD* aod) const
 {
   //returns kTRUE if rejected
   if (aod == 0x0)
@@ -53,7 +53,7 @@ Bool_t AliEventCut::Pass(AliAOD* aod) const
   AliEventBaseCut* becut;
   while (( becut = (AliEventBaseCut*)iter() ))
    {
-     if (becut->Pass(aod)) return kTRUE;
+     if (becut->Rejected(aod)) return kTRUE;
    }
   return kFALSE;
 }
index 58518bb..7c45ba7 100644 (file)
@@ -26,7 +26,7 @@ class AliEventCut: public TObject
     AliEventCut(const AliEventCut& in);
     virtual ~AliEventCut();
     
-    virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
+    virtual Bool_t Rejected(AliAOD* aod) const;//returns kTRUE if rejected
     void           AddBasePartCut(AliEventBaseCut* ebcut);
 
     void           SetNChargedRange(Int_t min,Int_t max, Double_t etamin = -10.0,Double_t etamax = 10.0);
@@ -45,7 +45,7 @@ class AliEventEmptyCut: public TObject
     AliEventEmptyCut(){}
     virtual ~AliEventEmptyCut(){}
     
-    Bool_t Pass(AliAOD* aod) const {return kFALSE;}//always accept
+    Bool_t Rejected(AliAOD* aod) const {return kFALSE;}//always accept
     
   protected:
   private:
index 46046f3..c596cd2 100644 (file)
@@ -102,7 +102,7 @@ Double_t AliFlowAnalysis::GetEventPlane(AliAOD* aod)
       }
      
      if (fPartCut)
-      if (fPartCut->Pass(aodtrack))
+      if (fPartCut->Rejected(aodtrack))
         continue;
 
      Double_t phi = TMath::Pi()+TMath::ATan2(-aodtrack->Py(),-aodtrack->Px()); 
@@ -142,7 +142,7 @@ void AliFlowAnalysis::GetFlow(AliAOD* aod,Double_t& v2,Double_t& psi)
         continue;
       }
      if (fPartCut)
-      if (fPartCut->Pass(aodtrack))
+      if (fPartCut->Rejected(aodtrack))
         continue;
       
      Double_t phi = TMath::Pi()+TMath::ATan2(-aodtrack->Py(),-aodtrack->Px()); 
index d4ef948..41bbf11 100644 (file)
@@ -346,13 +346,13 @@ Int_t AliReader::Read(AliAODRun* particles, AliAODRun *tracks)
 }      
 /*************************************************************************************/
 
-Bool_t AliReader::Pass(AliVAODParticle* p)
+Bool_t AliReader::Rejected(AliVAODParticle* p)
 {
  //Method examines whether particle meets all cut and particle type criteria
   
    if(p==0x0)//of corse we not pass NULL pointers
     {
-     Warning("Pass()","No Pasaran! We never accept NULL pointers");
+     Warning("Rejected()","No Pasaran! We never accept NULL pointers");
      return kTRUE;
     }
    //if no particle is specified, we pass all particles
@@ -361,14 +361,14 @@ Bool_t AliReader::Pass(AliVAODParticle* p)
   for(Int_t i=0; i<fCuts->GetEntriesFast(); i++)   
    {
      AliAODParticleCut &cut = *((AliAODParticleCut*)fCuts->At(i));
-     if(!cut.Pass(p)) return kFALSE;  //accepted
+     if(!cut.Rejected(p)) return kFALSE;  //accepted
    }
    
   return kTRUE;//not accepted
 }
 /*************************************************************************************/
 
-Bool_t  AliReader::Pass(Int_t pid)
+Bool_t  AliReader::Rejected(Int_t pid)
 {
 //this method checks if any of existing cuts accepts this pid particles
 //or any cuts accepts all particles
index edc5a2c..2411aa8 100644 (file)
@@ -125,8 +125,8 @@ class AliReader: public TNamed
     TH1I*                fTrackCounter; //histogram with number of tracks read
     
     virtual Int_t        ReadNext() = 0; //this methods reads next event and put result in fTracksEvent and/or fParticlesEvent
-    Bool_t               Pass(AliVAODParticle* p);//Checks if a given particle agains cuts
-    Bool_t               Pass(Int_t pid);//Checks if a given pid passes cuts
+    Bool_t               Rejected(AliVAODParticle* p);//Checks if a given particle agains cuts
+    Bool_t               Rejected(Int_t pid);//Checks if a given pid passes cuts
     void                 Blend();//Mixes current events in a symmetric way so after mixing thy are consistent
     
     TString&             GetDirName(Int_t entry);
index d214be4..796c91e 100644 (file)
@@ -372,7 +372,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
          
         if (fCheckParticlePID)
          {
-           if(Pass(p->GetPdgCode())) 
+           if(Rejected(p->GetPdgCode())) 
             {
               if ( AliVAODParticle::GetDebug() > 5 )
                 Info("ReadNext","Simulated Particle PID (%d) did not pass the cut.",p->GetPdgCode());
@@ -475,7 +475,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
            continue;
          }
 
-        if(Pass(pdgcode)) 
+        if(Rejected(pdgcode)) 
          {
            if ( AliVAODParticle::GetDebug() > 5 )
              Info("ReadNext","PID (%d) did not pass the cut.",pdgcode);
@@ -496,7 +496,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
            track->SetPIDprobability(charge*GetSpeciesPdgCode( (ESpecies)k ),w[k]);
          }
 
-        if(Pass(track))//check if meets all criteria of any of our cuts
+        if(Rejected(track))//check if meets all criteria of any of our cuts
                        //if it does not delete it and take next good track
          { 
            if ( AliVAODParticle::GetDebug() > 4 )
index c07e41d..c69f1e2 100644 (file)
@@ -130,11 +130,11 @@ Int_t AliReaderKineTree::ReadNext()
          TParticle * p = stack->Particle(i);
 //         if (p->GetFirstMother() >= 0) continue; do not apply with pythia etc
          
-         if(Pass(p->GetPdgCode())) continue; //check if we are intersted with particles of this type 
+         if(Rejected(p->GetPdgCode())) continue; //check if we are intersted with particles of this type 
                                              //if not take next partilce
          
          AliAODParticle* part = new AliAODParticle(*p,i);
-         if(Pass(part)) { delete part; continue;}//check if meets all criteria of any of our cuts
+         if(Rejected(part)) { delete part; continue;}//check if meets all criteria of any of our cuts
                                                   //if it does not delete it and take next good track
          fEventSim->AddParticle(part);//put particle in event
       }
index 3376377..2dfdbeb 100644 (file)
@@ -78,7 +78,7 @@ Int_t AliRunAnalysis::Run()
       /******************************/ 
       /*  Event Cut                 */ 
       /******************************/ 
-      if ( Pass(eventrec,eventsim) )
+      if ( Rejected(eventrec,eventsim) )
        {
          if (AliVAODParticle::GetDebug()) Info("Run","Event rejected by Event Cut");
          continue; //Did not pass the 
@@ -125,16 +125,16 @@ void AliRunAnalysis::SetEventCut(AliEventCut* evcut)
 
 /*********************************************************/
 
-Bool_t AliRunAnalysis::Pass(AliAOD* recevent, AliAOD* simevent)
+Bool_t AliRunAnalysis::Rejected(AliAOD* recevent, AliAOD* simevent)
 {
   //checks the event cut
   if (fEventCut == 0x0) return kFALSE;
   
   if (fCutOnRec)
-    if (fEventCut->Pass(recevent)) return kTRUE;
+    if (fEventCut->Rejected(recevent)) return kTRUE;
     
   if (fCutOnSim)
-    if (fEventCut->Pass(simevent)) return kTRUE;
+    if (fEventCut->Rejected(simevent)) return kTRUE;
   
   return kFALSE;
 }
index 3a9aee6..9ff2f4c 100644 (file)
@@ -45,7 +45,7 @@ class AliRunAnalysis: public TTask
     Bool_t        fCutOnSim;//flag indicating that event cut is performed on simulated particles 
     Bool_t        fCutOnRec;//flag indicating that event cut is performed on reconstructed tracks
     
-    Bool_t        Pass(AliAOD* recevent, AliAOD* simevent);
+    Bool_t        Rejected(AliAOD* recevent, AliAOD* simevent);
     
   private:
     void SetName(const char *){}//change SetName to be private
index 359f260..e6ebb15 100644 (file)
@@ -150,7 +150,7 @@ Int_t AliHBTAnalysis::ProcessEvent(AliAOD* aodrec, AliAOD* aodsim)
      Error("ProcessEvent","Analysis <<%s>> option not specified.",GetName());
      return 1;
    }
-  if ( Pass(aodrec,aodsim) ) return 0;
+  if ( Rejected(aodrec,aodsim) ) return 0;
   
   //Move event to the apparent vertex -> must be after the event cut
   //It is important for any cut that use any spacial coordiantes, 
@@ -555,10 +555,10 @@ Int_t AliHBTAnalysis::ProcessSim(AliAOD* /*aodrec*/, AliAOD* aodsim)
 
      part1= partEvent->GetParticle(j);
 
-     Bool_t firstcut = fPairCut->GetFirstPartCut()->Pass(part1);
+     Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(part1);
 
      if (fBufferSize != 0) 
-       if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Pass(part1) == kFALSE ) )
+       if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(part1) == kFALSE ) )
         {
           //accepted by any cut
           // we have to copy because reader keeps only one event
@@ -579,9 +579,9 @@ Int_t AliHBTAnalysis::ProcessSim(AliAOD* /*aodrec*/, AliAOD* aodsim)
         if (part1->GetUID() == part2->GetUID()) continue;
         partpair->SetParticles(part1,part2);
 
-           if(fPairCut->Pass(partpair)) //check pair cut
+           if(fPairCut->Rejected(partpair)) //check pair cut
             { //do not meets crietria of the 
-              if( fPairCut->Pass((AliHBTPair*)partpair->GetSwappedPair()) ) continue;
+              if( fPairCut->Rejected((AliHBTPair*)partpair->GetSwappedPair()) ) continue;
               else tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
             }
            else
@@ -614,9 +614,9 @@ Int_t AliHBTAnalysis::ProcessSim(AliAOD* /*aodrec*/, AliAOD* aodsim)
                 part2= partEvent2->GetParticle(l);
                 partpair->SetParticles(part1,part2);
 
-                if( fPairCut->Pass(partpair) ) //check pair cut
+                if( fPairCut->Rejected(partpair) ) //check pair cut
                   { //do not meets crietria of the 
-                    if( fPairCut->Pass((AliHBTPair*)partpair->GetSwappedPair()) )
+                    if( fPairCut->Rejected((AliHBTPair*)partpair->GetSwappedPair()) )
                       continue;
                     else 
                      {
@@ -678,10 +678,10 @@ Int_t AliHBTAnalysis::ProcessRec(AliAOD* aodrec, AliAOD* /*aodsim*/)
 
      track1= trackEvent->GetParticle(j);
 
-     Bool_t firstcut = fPairCut->GetFirstPartCut()->Pass(track1);
+     Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(track1);
 
      if (fBufferSize != 0) 
-       if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Pass(track1) == kFALSE ) )
+       if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(track1) == kFALSE ) )
         {
           //accepted by any cut
           // we have to copy because reader keeps only one event
@@ -702,9 +702,9 @@ Int_t AliHBTAnalysis::ProcessRec(AliAOD* aodrec, AliAOD* /*aodsim*/)
         if (track1->GetUID() == track2->GetUID()) continue;
         trackpair->SetParticles(track1,track2);
 
-           if(fPairCut->Pass(trackpair)) //check pair cut
+           if(fPairCut->Rejected(trackpair)) //check pair cut
             { //do not meets crietria of the 
-              if( fPairCut->Pass((AliHBTPair*)trackpair->GetSwappedPair()) ) continue;
+              if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) ) continue;
               else tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
             }
            else
@@ -737,9 +737,9 @@ Int_t AliHBTAnalysis::ProcessRec(AliAOD* aodrec, AliAOD* /*aodsim*/)
                 track2= trackEvent2->GetParticle(l);
                 trackpair->SetParticles(track1,track2);
 
-                if( fPairCut->Pass(trackpair) ) //check pair cut
+                if( fPairCut->Rejected(trackpair) ) //check pair cut
                   { //do not meets crietria of the 
-                    if( fPairCut->Pass((AliHBTPair*)trackpair->GetSwappedPair()) )
+                    if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) )
                       continue;
                     else 
                      {
@@ -1671,8 +1671,8 @@ void AliHBTAnalysis::FilterOut(AliAOD* out1, AliAOD* out2, AliAOD* in) const
      in1 = in2 = kTRUE;
      part = in->GetParticle(i);
      
-     if ( cut1->Pass(part) ) in1 = kFALSE; //if part is rejected by cut1, in1 is false
-     if ( cut2->Pass(part) ) in2 = kFALSE; //if part is rejected by cut2, in2 is false
+     if ( cut1->Rejected(part) ) in1 = kFALSE; //if part is rejected by cut1, in1 is false
+     if ( cut2->Rejected(part) ) in2 = kFALSE; //if part is rejected by cut2, in2 is false
      
      if (gDebug)//to be removed in real analysis     
      if ( in1 && in2 ) //both cuts accepted, should never happen, just in case
index 5b2d920..0a03880 100644 (file)
@@ -61,14 +61,14 @@ class AliHBTFunction: public TNamed
 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
 {
   //check if pair and both particles meets the cut criteria
-  if(fPairCut->Pass(pair)) return 0x0; //if the pair is BAD
+  if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD
 
 //   It is notallowed to change the order here beacause analysis enforce the order
 
 //   {//it is BAD 
 //    pair = pair->GetSwappedPair();
 //    if(pair)
-//     if(fPairCut->Pass(pair)) //so try reverse combination
+//     if(fPairCut->Rejected(pair)) //so try reverse combination
 //       { 
 //        return 0x0;//it is BAD as well - so return
 //       }
index 13457ea..3556a76 100644 (file)
@@ -83,7 +83,7 @@ class AliHBTMonitorFunction: public TNamed
 inline AliVAODParticle* AliHBTMonitorFunction::CheckParticle(AliVAODParticle* particle) const
 {
   //check if particle meets the cut criteria
-  if(fParticleCut->Pass(particle)) //if the particle is BAD
+  if(fParticleCut->Rejected(particle)) //if the particle is BAD
    { 
      return 0x0;//it is BAD as well - so return
    }
index 4a77039..4489f65 100644 (file)
@@ -323,13 +323,13 @@ Int_t AliHBTReader::Read(AliHBTRun* particles, AliHBTRun *tracks)
 }      
 /*************************************************************************************/
 
-Bool_t AliHBTReader::Pass(AliHBTParticle* p)
+Bool_t AliHBTReader::Rejected(AliHBTParticle* p)
 {
  //Method examines whether particle meets all cut and particle type criteria
   
    if(p==0x0)//of corse we not pass NULL pointers
     {
-     Warning("Pass()","No Pasaran! We never accept NULL pointers");
+     Warning("Rejected()","No Pasaran! We never accept NULL pointers");
      return kTRUE;
     }
    //if no particle is specified, we pass all particles
@@ -338,14 +338,14 @@ Bool_t AliHBTReader::Pass(AliHBTParticle* p)
   for(Int_t i=0; i<fCuts->GetEntriesFast(); i++)   
    {
      AliHBTParticleCut &cut = *((AliHBTParticleCut*)fCuts->At(i));
-     if(!cut.Pass(p)) return kFALSE;  //accepted
+     if(!cut.Rejected(p)) return kFALSE;  //accepted
    }
    
   return kTRUE;//not accepted
 }
 /*************************************************************************************/
 
-Bool_t  AliHBTReader::Pass(Int_t pid)
+Bool_t  AliHBTReader::Rejected(Int_t pid)
 {
 //this method checks if any of existing cuts accepts this pid particles
 //or any cuts accepts all particles
index 47858d6..7e819b7 100644 (file)
@@ -85,8 +85,8 @@ class AliHBTReader: public TNamed
     TH1I*         fTrackCounter; //histogram with number of tracks read
     
     virtual Int_t ReadNext() = 0; //this methods reads next event and put result in fTracksEvent and/or fParticlesEvent
-    Bool_t Pass(AliHBTParticle* p);
-    Bool_t Pass(Int_t pid);
+    Bool_t Rejected(AliHBTParticle* p);
+    Bool_t Rejected(Int_t pid);
     void Blend();
     
     TString& GetDirName(Int_t entry);
index 8480c42..6d9f6a5 100644 (file)
@@ -197,7 +197,7 @@ Int_t AliHBTReaderInternal::ReadNext()
             {
               //check if we are intersted with particles of this type
               //if not take next partilce
-              if( Pass(ttrack->GetNthPid(s)) ) 
+              if( Rejected(ttrack->GetNthPid(s)) ) 
                {
                  if (AliHBTParticle::GetDebug() > 9)
                   Info("ReadNext","Track Incarnation %d did not pass PID cut.",ttrack->GetNthPid(s));
@@ -225,7 +225,7 @@ Int_t AliHBTReaderInternal::ReadNext()
               track->SetCalcMass(mass);
               track->SetPdgCode(ttrack->GetNthPid(s),ttrack->GetNthPidProb(s));
               
-              if( Pass(track) )
+              if( Rejected(track) )
                 {
                   if (AliHBTParticle::GetDebug() > 9)
                    Info("ReadNext","Track Incarnation %d did not pass cut.",ttrack->GetNthPid(s));
@@ -255,10 +255,10 @@ Int_t AliHBTReaderInternal::ReadNext()
            for (Int_t s = 0; s < tpart->GetNumberOfPids(); s++)
             {
               if( pdgdb->GetParticle(tpart->GetNthPid(s)) == 0x0 ) continue; //if particle has crazy PDG code (not known to our database)
-              if( Pass(tpart->GetNthPid(s)) ) continue; //check if we are intersted with particles of this type
+              if( Rejected(tpart->GetNthPid(s)) ) continue; //check if we are intersted with particles of this type
               AliHBTParticle* part = new AliHBTParticle(*tpart);
               part->SetPdgCode(tpart->GetNthPid(s),tpart->GetNthPidProb(s));
-              if( Pass(part) )
+              if( Rejected(part) )
                 {
                   delete part;
                   continue; 
@@ -281,7 +281,7 @@ Int_t AliHBTReaderInternal::ReadNext()
 
            for (Int_t s = 0; s < ttrack->GetNumberOfPids(); s++)
             {
-              if( Pass(ttrack->GetNthPid(s)) ) continue; //check if we are intersted with particles of this type
+              if( Rejected(ttrack->GetNthPid(s)) ) continue; //check if we are intersted with particles of this type
                                                          //if not take next partilce
               TParticlePDG* pdgp = pdgdb->GetParticle(ttrack->GetNthPid(s));
               if (pdgp == 0x0)//PDG part corresponding to new incarnation
@@ -304,7 +304,7 @@ Int_t AliHBTReaderInternal::ReadNext()
               track->SetCalcMass(mass);
               track->SetPdgCode(ttrack->GetNthPid(s),ttrack->GetNthPidProb(s));
               
-              if( Pass(track) )
+              if( Rejected(track) )
                 {
                   delete track;
                   continue; 
index b3e33a0..d4c8e6b 100644 (file)
@@ -301,11 +301,11 @@ Int_t AliHBTReaderTPC::ReadNext()
        if(p == 0x0) continue; //if returned pointer is NULL
        if(p->GetPDG() == 0x0) continue; //if particle has crezy PDG code (not known to our database)
 
-       if(Pass(p->GetPdgCode())) continue; //check if we are intersted with particles of this type 
+       if(Rejected(p->GetPdgCode())) continue; //check if we are intersted with particles of this type 
                                    //if not take next partilce
 
        AliHBTParticle* part = new AliHBTParticle(*p,i);
-       if(Pass(part)) { delete part; continue;}//check if meets all criteria of any of our cuts
+       if(Rejected(part)) { delete part; continue;}//check if meets all criteria of any of our cuts
                                                //if it does not delete it and take next good track
 
 //       iotrack->PropagateTo(3.,0.0028,65.19);
@@ -328,7 +328,7 @@ Int_t AliHBTReaderTPC::ReadNext()
        Double_t tEtot = TMath::Sqrt( tpx*tpx + tpy*tpy + tpz*tpz + mass*mass);//total energy of the track
 
        AliHBTParticle* track = new AliHBTParticle(p->GetPdgCode(),i, tpx, tpy , tpz, tEtot, 0., 0., 0., 0.);
-       if(Pass(track))//check if meets all criteria of any of our cuts
+       if(Rejected(track))//check if meets all criteria of any of our cuts
                     //if it does not delete it and take next good track
         { 
           delete track;