--- /dev/null
+#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))
+}
+/******************************************************************/
--- /dev/null
+#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
+#include "AliAODPairCut.h"
/* $Id$ */
//____________________________________
/////////////////////////////////////////////////////////////////////////
// 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"
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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())
// 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++)
}
/******************************************************************/
-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))
-}
-/******************************************************************/
-#ifndef AliAODPairCUT_H
-#define AliAODPairCUT_H
+#ifndef ALIAODPAIRCUT_H
+#define ALIAODPAIRCUT_H
/* $Id$ */
//
//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
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)
};
-
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-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
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 \
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 \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff