Base Pair Cuts that perform logical operations on results of other base pair cuts...
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Mar 2004 15:46:39 +0000 (15:46 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Mar 2004 15:46:39 +0000 (15:46 +0000)
HBTAN/AliHBTPairCut.cxx
HBTAN/AliHBTPairCut.h
HBTAN/HBTAnalysisLinkDef.h

index edaef33d33be4615f1f73427b30935024185fe8c..c0486a62858b6caeddc0bc42c5845e474abf07a8 100644 (file)
@@ -311,6 +311,7 @@ void AliHBTPairCut::Streamer(TBuffer &b)
       b.SetByteCount(R__c, kTRUE);
     }
 }
+/******************************************************************/
 
 ClassImp(AliHBTEmptyPairCut)
   
@@ -319,6 +320,7 @@ void AliHBTEmptyPairCut::Streamer(TBuffer &b)
 //streamer for empty pair cut
   AliHBTPairCut::Streamer(b);
 }
+/******************************************************************/
 
 ClassImp(AliHbtBasePairCut)
 ClassImp(AliHBTQInvCut)
@@ -326,8 +328,9 @@ ClassImp(AliHBTKtCut)
 ClassImp(AliHBTQSideCMSLCCut)
 ClassImp(AliHBTQOutCMSLCCut)
 ClassImp(AliHBTQLongCMSLCCut)
-ClassImp(AliHBTAvSeparationCut)
 
+/******************************************************************/
+ClassImp(AliHBTAvSeparationCut)
     
 Double_t AliHBTAvSeparationCut::GetValue(AliHBTPair* pair) const 
 {
@@ -336,18 +339,19 @@ Double_t AliHBTAvSeparationCut::GetValue(AliHBTPair* pair) const
   if ( tpts1 == 0x0)
    {//it could be simulated pair
 //     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
-     return 10e5;
+     return -1.0;
    }
 
   AliHBTTrackPoints* tpts2 = pair->Particle2()->GetTrackPoints();
   if ( tpts2 == 0x0)
    {
 //     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
-     return 10e5;
+     return -1.0;
    }
    
   return tpts1->AvarageDistance(*tpts2);
 }
+/******************************************************************/
 
 ClassImp(AliHBTCluterOverlapCut)
 
@@ -374,3 +378,99 @@ Double_t  AliHBTCluterOverlapCut::GetValue(AliHBTPair* pair) const
    }
   return cm1->GetOverlapFactor(*cm2);
 }
+/******************************************************************/
+
+ClassImp( AliHBTLogicalOperPairCut )
+
+AliHBTLogicalOperPairCut::AliHBTLogicalOperPairCut():
+ AliHbtBasePairCut(-10e10,10e10,kHbtPairCutPropNone),
+ fFirst(new AliHBTDummyBasePairCut),
+ fSecond(new AliHBTDummyBasePairCut)
+{
+ //ctor
+}
+/******************************************************************/
+
+AliHBTLogicalOperPairCut::AliHBTLogicalOperPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):
+ AliHbtBasePairCut(-10e10,10e10,kHbtPairCutPropNone),
+ fFirst((first)?(AliHbtBasePairCut*)first->Clone():0x0),
+ fSecond((second)?(AliHbtBasePairCut*)second->Clone():0x0)
+{
+  //ctor
+  //note that base cuts are copied, not just pointers assigned
+  if ( (fFirst && fSecond) == kFALSE) 
+   {
+     Fatal("AliHBTLogicalOperPairCut","One of parameters is NULL!");
+   }
+}
+/******************************************************************/
+
+AliHBTLogicalOperPairCut::~AliHBTLogicalOperPairCut()
+{
+  //destructor
+  delete fFirst;
+  delete fSecond;
+}
+/******************************************************************/
+
+Bool_t AliHBTLogicalOperPairCut::AliHBTDummyBasePairCut::Pass(AliHBTPair* /*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 AliHBTLogicalOperPairCut::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,AliHBTLogicalOperPairCut::IsA());
+   } 
+  else 
+   {
+     R__c = b.WriteVersion(AliHBTLogicalOperPairCut::IsA(), kTRUE);
+     TObject::Streamer(b);
+     b << fFirst;
+     b << fSecond;
+     b.SetByteCount(R__c, kTRUE);
+  }
+}
+
+/******************************************************************/
+ClassImp(AliHBTOrPairCut)
+
+Bool_t AliHBTOrPairCut::Pass(AliHBTPair * 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 HBTAN use inernally reverse (returns true when rejected)
+  if (fFirst->Pass(p) && fSecond->Pass(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
+  return kFALSE;//accepted, at least one accepted (returned kFALSE)
+}
+/******************************************************************/
+
+ClassImp(AliHBTAndPairCut)
+
+Bool_t AliHBTAndPairCut::Pass(AliHBTPair * 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 HBTAN use inernally reverse (returns true when rejected)
+  if (fFirst->Pass(p) || fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
+  return kFALSE;//accepted (both accepted (returned kFALSE))
+}
+/******************************************************************/
index ba53bde9c67e6ed950b2ec4e5f8540e95688ac2c..826490414f006bc8ba6fa4fa3e687b21dbd2e17b 100644 (file)
@@ -25,6 +25,7 @@ enum AliHBTPairCutProperty
   kHbtPairCutPropClOverlap,
   kHbtPairCutPropNone
 };
+/******************************************************************/
 
 class AliHBTPairCut: public TNamed
 {
@@ -107,7 +108,7 @@ class AliHbtBasePairCut: public TObject
   
   virtual   ~AliHbtBasePairCut(){}
      
-  Bool_t    Pass(AliHBTPair* pair) const;
+  virtual Bool_t    Pass(AliHBTPair* pair) const;
   
   void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
   
@@ -130,6 +131,7 @@ class AliHbtBasePairCut: public TObject
   ClassDef(AliHbtBasePairCut,1)
  
  };
+/******************************************************************/
 
 inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
 {
@@ -143,6 +145,7 @@ inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
+
 class AliHBTQInvCut: public AliHbtBasePairCut
 {
  public:
@@ -153,7 +156,7 @@ class AliHBTQInvCut: public AliHbtBasePairCut
   
   ClassDef(AliHBTQInvCut,1)
  };
-
+/******************************************************************/
 
 class AliHBTKtCut: public AliHbtBasePairCut {
  public:
@@ -164,6 +167,7 @@ class AliHBTKtCut: public AliHbtBasePairCut {
 
   ClassDef(AliHBTKtCut,1)
  };
+/******************************************************************/
 
 class AliHBTKStarCut: public AliHbtBasePairCut
 {
@@ -175,6 +179,7 @@ class AliHBTKStarCut: public AliHbtBasePairCut
 
   ClassDef(AliHBTKStarCut,1)
 };
+/******************************************************************/
 
 class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
 {
@@ -188,6 +193,7 @@ class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
 
   ClassDef(AliHBTQSideCMSLCCut,1)
 };
+/******************************************************************/
 
 
 class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
@@ -202,6 +208,7 @@ class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
   
   ClassDef(AliHBTQOutCMSLCCut,1)
 };
+/******************************************************************/
 
 class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
 {
@@ -215,7 +222,7 @@ class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
 
   ClassDef(AliHBTQLongCMSLCCut,1)
 };
-
+/******************************************************************/
   
 class AliHBTAvSeparationCut: public AliHbtBasePairCut
 {
@@ -228,6 +235,7 @@ class AliHBTAvSeparationCut: public AliHbtBasePairCut
   virtual Double_t  GetValue(AliHBTPair* pair) const;
   ClassDef(AliHBTAvSeparationCut,1)
 };
+/******************************************************************/
 
 class AliHBTCluterOverlapCut: public AliHbtBasePairCut
 {
@@ -240,5 +248,49 @@ class AliHBTCluterOverlapCut: public AliHbtBasePairCut
   virtual Double_t  GetValue(AliHBTPair* pair) const;
   ClassDef(AliHBTCluterOverlapCut,1)
 };
-  
+/******************************************************************/
+
+class AliHBTLogicalOperPairCut:  public AliHbtBasePairCut
+ {
+   public:
+     AliHBTLogicalOperPairCut();
+     AliHBTLogicalOperPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second);
+     virtual   ~AliHBTLogicalOperPairCut();
+   protected:
+     Double_t  GetValue(AliHBTPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
+
+     AliHbtBasePairCut* fFirst;   //second cut
+     AliHbtBasePairCut* fSecond;  //first cut
+   private:
+    class  AliHBTDummyBasePairCut: public AliHbtBasePairCut
+     {
+       Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
+       Bool_t    Pass(AliHBTPair* /*pair*/) const;
+     };
+
+    ClassDef(AliHBTLogicalOperPairCut,1)
+ };
+/******************************************************************/
+
+class AliHBTOrPairCut: public AliHBTLogicalOperPairCut
+{
+   public:
+     AliHBTOrPairCut(){}
+     AliHBTOrPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
+     virtual   ~AliHBTOrPairCut(){}
+     Bool_t    Pass(AliHBTPair *p) const;
+     ClassDef(AliHBTOrPairCut,1)
+};
+/******************************************************************/
+
+class AliHBTAndPairCut: public AliHBTLogicalOperPairCut
+{
+   public:
+     AliHBTAndPairCut(){}
+     AliHBTAndPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
+     virtual   ~AliHBTAndPairCut(){}
+     Bool_t    Pass(AliHBTPair *p) const;
+     ClassDef(AliHBTAndPairCut,1)
+};
+
 #endif
index ef158ef7a7003941c82ac4c0bcb2a0ae35fe1aec..62074310a5db4032542a792e6cf13ea2f14fa870 100644 (file)
@@ -52,6 +52,9 @@
 #pragma link C++ class AliHBTQLongCMSLCCut+;
 #pragma link C++ class AliHBTAvSeparationCut+;
 #pragma link C++ class AliHBTCluterOverlapCut+;
+#pragma link C++ class AliHBTLogicalOperPairCut-;
+#pragma link C++ class AliHBTOrPairCut+;
+#pragma link C++ class AliHBTAndPairCut+;
     
 #pragma link C++ class AliHBTMomentumCut+;
 #pragma link C++ class AliHBTPtCut+;
 #pragma link C++ class AliHBTMonThetaResolutionVsThetaFctn+;
 
 #pragma link C++ class AliHBTTwoTrackEffFctn+;
-#pragma link C++ class AliHBTTwoTrackEffFctn3D+;
+#pragma link C++ class AliHBTTwoTrackEffFctnPtThetaPhi+;
+#pragma link C++ class AliHBTTwoTrackEffFctnPxPyPz+;
 
 #pragma link C++ class AliHBTWeights+;
 #pragma link C++ class AliHBTCrab+;