b.SetByteCount(R__c, kTRUE);
}
}
+/******************************************************************/
ClassImp(AliHBTEmptyPairCut)
//streamer for empty pair cut
AliHBTPairCut::Streamer(b);
}
+/******************************************************************/
ClassImp(AliHbtBasePairCut)
ClassImp(AliHBTQInvCut)
ClassImp(AliHBTQSideCMSLCCut)
ClassImp(AliHBTQOutCMSLCCut)
ClassImp(AliHBTQLongCMSLCCut)
-ClassImp(AliHBTAvSeparationCut)
+/******************************************************************/
+ClassImp(AliHBTAvSeparationCut)
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)
}
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))
+}
+/******************************************************************/
kHbtPairCutPropClOverlap,
kHbtPairCutPropNone
};
+/******************************************************************/
class AliHBTPairCut: public TNamed
{
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;}
ClassDef(AliHbtBasePairCut,1)
};
+/******************************************************************/
inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
{
/******************************************************************/
/******************************************************************/
/******************************************************************/
+
class AliHBTQInvCut: public AliHbtBasePairCut
{
public:
ClassDef(AliHBTQInvCut,1)
};
-
+/******************************************************************/
class AliHBTKtCut: public AliHbtBasePairCut {
public:
ClassDef(AliHBTKtCut,1)
};
+/******************************************************************/
class AliHBTKStarCut: public AliHbtBasePairCut
{
ClassDef(AliHBTKStarCut,1)
};
+/******************************************************************/
class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
{
ClassDef(AliHBTQSideCMSLCCut,1)
};
+/******************************************************************/
class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
ClassDef(AliHBTQOutCMSLCCut,1)
};
+/******************************************************************/
class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
{
ClassDef(AliHBTQLongCMSLCCut,1)
};
-
+/******************************************************************/
class AliHBTAvSeparationCut: public AliHbtBasePairCut
{
virtual Double_t GetValue(AliHBTPair* pair) const;
ClassDef(AliHBTAvSeparationCut,1)
};
+/******************************************************************/
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
#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+;