#pragma link C++ class AliFlowAnalysis+;
#pragma link C++ class AliEventCut+;
-#pragma link C++ class AliEmptyEventCut+;
-#pragma link C++ class AliBaseEventCut+;
+#pragma link C++ class AliEventEmptyCut+;
+#pragma link C++ class AliEventBaseCut+;
#pragma link C++ class AliPrimVertexXCut+;
#pragma link C++ class AliPrimVertexYCut+;
#pragma link C++ class AliNChargedCut+;
#pragma link C++ class AliAODParticleCut-;
-#pragma link C++ class AliAODEmptyParticleCut-;
-#pragma link C++ class AliAODBaseCut+;
+#pragma link C++ class AliAODParticleEmptyCut-;
+#pragma link C++ class AliAODParticleBaseCut+;
#pragma link C++ class AliAODMomentumCut+;
#pragma link C++ class AliAODPtCut+;
#pragma link C++ class AliAODPairCut-;
-#pragma link C++ class AliAODEmptyPairCut-;
-#pragma link C++ class AliAODBasePairCut+;
+#pragma link C++ class AliAODPairEmptyCut-;
+#pragma link C++ class AliAODPairBaseCut+;
#pragma link C++ class AliAODQInvCut+;
#pragma link C++ class AliAODKtCut+;
fNCuts(0)
{
//constructor
- fFirstPartCut = new AliAODEmptyParticleCut(); //empty cuts
- fSecondPartCut= new AliAODEmptyParticleCut(); //empty cuts
+ fFirstPartCut = new AliAODParticleEmptyCut(); //empty cuts
+ fSecondPartCut= new AliAODParticleEmptyCut(); //empty cuts
- fCuts = new AliAODBasePairCut*[fgkMaxCuts];
+ fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
for (Int_t i = 0;i<fNCuts;i++)
{
fCuts[i] = 0x0;
TNamed(in)
{
//copy constructor
- fCuts = new AliAODBasePairCut*[fgkMaxCuts];
+ fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
fNCuts = in.fNCuts;
fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
for (Int_t i = 0;i<fNCuts;i++)
{
- fCuts[i] = (AliAODBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+ fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
}
}
/**********************************************************/
AliAODPairCut& AliAODPairCut::operator=(const AliAODPairCut& in)
{
//assignment operator
- fCuts = new AliAODBasePairCut*[fgkMaxCuts];
+ fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
fNCuts = in.fNCuts;
fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
for (Int_t i = 0;i<fNCuts;i++)
{
- fCuts[i] = (AliAODBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+ fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
}
return * this;
}
/**********************************************************/
-void AliAODPairCut::AddBasePairCut(AliAODBasePairCut* basecut)
+void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
{
//adds the base pair cut (cut on one value)
void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
{
//sets avarage separation cut ->Anti-Merging cut
- AliAODBasePairCut* cut= FindCut(kHbtPairCutPropAvSepar);
+ AliAODPairBaseCut* cut= FindCut(kHbtPairCutPropAvSepar);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
}
// splitted track: one particle that is recontructed twise
// STAR uses range from -0.5 to 0.6
- AliAODBasePairCut* cut= FindCut(kHbtPairCutPropClOverlap);
+ AliAODPairBaseCut* cut= FindCut(kHbtPairCutPropClOverlap);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
}
/**********************************************************/
-AliAODBasePairCut* AliAODPairCut::FindCut(AliAODPairCutProperty property)
+AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairCutProperty property)
{
// Find the cut corresponding to "property"
for (Int_t i = 0;i<fNCuts;i++)
}
/******************************************************************/
-ClassImp(AliAODEmptyPairCut)
+ClassImp(AliAODPairEmptyCut)
-void AliAODEmptyPairCut::Streamer(TBuffer &b)
+void AliAODPairEmptyCut::Streamer(TBuffer &b)
{
//streamer for empty pair cut
AliAODPairCut::Streamer(b);
}
/******************************************************************/
-ClassImp(AliAODBasePairCut)
+ClassImp(AliAODPairBaseCut)
ClassImp(AliAODQInvCut)
ClassImp(AliAODKtCut)
ClassImp(AliAODQSideLCMSCut)
ClassImp( AliAODLogicalOperPairCut )
AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
- AliAODBasePairCut(-10e10,10e10,kHbtPairCutPropNone),
+ AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
fFirst(new AliAODDummyBasePairCut),
fSecond(new AliAODDummyBasePairCut)
{
}
/******************************************************************/
-AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):
- AliAODBasePairCut(-10e10,10e10,kHbtPairCutPropNone),
- fFirst((first)?(AliAODBasePairCut*)first->Clone():0x0),
- fSecond((second)?(AliAODBasePairCut*)second->Clone():0x0)
+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
#include "AliAODPair.h"
class AliAODParticleCut;
-class AliAODBasePairCut;
+class AliAODPairBaseCut;
enum AliAODPairCutProperty
{
void SetPartCut(AliAODParticleCut* cut);//sets the the same cut on both particles
- virtual void AddBasePairCut(AliAODBasePairCut* cut);
+ virtual void AddBasePairCut(AliAODPairBaseCut* cut);
virtual void Print();
AliAODParticleCut* fFirstPartCut;//cut on first particle in pair
AliAODParticleCut* fSecondPartCut;//cut on second particle in pair
- AliAODBasePairCut** fCuts; //! array of poiters to base cuts
+ AliAODPairBaseCut** fCuts; //! array of poiters to base cuts
Int_t fNCuts;//Number of cuts in fCuts array
- AliAODBasePairCut* FindCut(AliAODPairCutProperty cut);
+ AliAODPairBaseCut* FindCut(AliAODPairCutProperty cut);
private:
static const Int_t fgkMaxCuts; // Max number of cuts
ClassDef(AliAODPairCut,2)
/******************************************************************/
/******************************************************************/
-class AliAODEmptyPairCut: public AliAODPairCut
+class AliAODPairEmptyCut: public AliAODPairCut
{
//Empty - it passes possitively all particles - it means returns always False
//Class describing cut on pairs of particles
public:
- AliAODEmptyPairCut(){};
- AliAODEmptyPairCut(const AliAODEmptyPairCut& in):AliAODPairCut(in){};
- virtual ~AliAODEmptyPairCut(){};
+ AliAODPairEmptyCut(){};
+ AliAODPairEmptyCut(const AliAODPairEmptyCut& in):AliAODPairCut(in){};
+ virtual ~AliAODPairEmptyCut(){};
Bool_t Pass(AliAODPair*) const {return kFALSE;} //accpept everything
Bool_t IsEmpty() const {return kTRUE;}
- ClassDef(AliAODEmptyPairCut,1)
+ ClassDef(AliAODPairEmptyCut,1)
};
/******************************************************************/
/******************************************************************/
-class AliAODBasePairCut: public TObject
+class AliAODPairBaseCut: public TObject
{
//This class defines the range of some property - pure virtual
//Property is coded by AliAODCutTypes type
public:
- AliAODBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliAODPairCutProperty prop= kHbtPairCutPropNone):
+ AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, AliAODPairCutProperty prop= kHbtPairCutPropNone):
fMin(min),fMax(max),fProperty(prop){}
- virtual ~AliAODBasePairCut(){}
+ virtual ~AliAODPairBaseCut(){}
virtual Bool_t Pass(AliAODPair* pair) const;
AliAODPairCutProperty fProperty; // The property itself
- ClassDef(AliAODBasePairCut,1)
+ ClassDef(AliAODPairBaseCut,1)
};
/******************************************************************/
-inline Bool_t AliAODBasePairCut::Pass(AliAODPair* pair) const
+inline Bool_t AliAODPairBaseCut::Pass(AliAODPair* pair) const
{
//checks if pair proprty is in range
//null pointer check is made by AliAODPairCut, so here is unnecesary
/******************************************************************/
/******************************************************************/
-class AliAODQInvCut: public AliAODBasePairCut
+class AliAODQInvCut: public AliAODPairBaseCut
{
public:
- AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropQInv){}
+ 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();}
};
/******************************************************************/
-class AliAODKtCut: public AliAODBasePairCut {
+class AliAODKtCut: public AliAODPairBaseCut {
public:
- AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropKt){}
+ 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();}
};
/******************************************************************/
-class AliAODKStarCut: public AliAODBasePairCut
+class AliAODKStarCut: public AliAODPairBaseCut
{
public:
- AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropKStar){}
+ 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();}
};
/******************************************************************/
-class AliAODQSideLCMSCut: public AliAODBasePairCut
+class AliAODQSideLCMSCut: public AliAODPairBaseCut
{
public:
AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
- AliAODBasePairCut(min,max,kHbtPairCutPropQSideLCMS){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
virtual ~AliAODQSideLCMSCut(){}
protected:
virtual Double_t GetValue(AliAODPair* pair) const
/******************************************************************/
-class AliAODQOutLCMSCut: public AliAODBasePairCut
+class AliAODQOutLCMSCut: public AliAODPairBaseCut
{
public:
AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
- AliAODBasePairCut(min,max,kHbtPairCutPropQOutLCMS){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
virtual ~AliAODQOutLCMSCut(){}
protected:
virtual Double_t GetValue(AliAODPair* pair) const
};
/******************************************************************/
-class AliAODQLongLCMSCut: public AliAODBasePairCut
+class AliAODQLongLCMSCut: public AliAODPairBaseCut
{
public:
AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
- AliAODBasePairCut(min,max,kHbtPairCutPropQLongLCMS){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
virtual ~AliAODQLongLCMSCut(){}
protected:
virtual Double_t GetValue(AliAODPair* pair) const
};
/******************************************************************/
-class AliAODDeltaPhiCut: public AliAODBasePairCut
+class AliAODDeltaPhiCut: public AliAODPairBaseCut
{
public:
AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
- AliAODBasePairCut(min,max,kHbtPairCutPropDeltaPhi){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
virtual ~AliAODDeltaPhiCut(){}
protected:
virtual Double_t GetValue(AliAODPair* pair) const
};
/******************************************************************/
-class AliAODDeltaThetaCut: public AliAODBasePairCut
+class AliAODDeltaThetaCut: public AliAODPairBaseCut
{
public:
AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
- AliAODBasePairCut(min,max,kHbtPairCutPropDeltaTheta){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
virtual ~AliAODDeltaThetaCut(){}
protected:
virtual Double_t GetValue(AliAODPair* pair) const
};
/******************************************************************/
-class AliAODCluterOverlapCut: public AliAODBasePairCut
+class AliAODCluterOverlapCut: public AliAODPairBaseCut
{
public:
AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
- AliAODBasePairCut(min,max,kHbtPairCutPropClOverlap){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
virtual ~AliAODCluterOverlapCut(){}
protected:
};
/******************************************************************/
-class AliAODAvSeparationCut: public AliAODBasePairCut
+class AliAODAvSeparationCut: public AliAODPairBaseCut
{
public:
AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
- AliAODBasePairCut(min,max,kHbtPairCutPropAvSepar){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
virtual ~AliAODAvSeparationCut(){}
protected:
};
/******************************************************************/
-class AliAODSeparationCut: public AliAODBasePairCut
+class AliAODSeparationCut: public AliAODPairBaseCut
{
public:
AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
- AliAODBasePairCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
+ AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
virtual ~AliAODSeparationCut(){}
protected:
};
/******************************************************************/
-class AliAODITSSeparationCut: public AliAODBasePairCut
+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):
- AliAODBasePairCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
+ AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
virtual ~AliAODITSSeparationCut(){}
Bool_t Pass(AliAODPair* pair) const;
Int_t GetLayer() const {return fLayer;}
};
/******************************************************************/
-class AliAODOutSideSameSignCut: public AliAODBasePairCut
+class AliAODOutSideSameSignCut: public AliAODPairBaseCut
{
public:
AliAODOutSideSameSignCut(){}
};
/******************************************************************/
-class AliAODOutSideDiffSignCut: public AliAODBasePairCut
+class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
{
public:
AliAODOutSideDiffSignCut(){}
};
/******************************************************************/
-class AliAODLogicalOperPairCut: public AliAODBasePairCut
+class AliAODLogicalOperPairCut: public AliAODPairBaseCut
{
public:
AliAODLogicalOperPairCut();
- AliAODLogicalOperPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second);
+ AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
virtual ~AliAODLogicalOperPairCut();
protected:
Double_t GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
- AliAODBasePairCut* fFirst; //second cut
- AliAODBasePairCut* fSecond; //first cut
+ AliAODPairBaseCut* fFirst; //second cut
+ AliAODPairBaseCut* fSecond; //first cut
private:
- class AliAODDummyBasePairCut: public AliAODBasePairCut
+ class AliAODDummyBasePairCut: public AliAODPairBaseCut
{
Double_t GetValue(AliAODPair* /*pair*/) const {return 0.0;}
Bool_t Pass(AliAODPair* /*pair*/) const;
{
public:
AliAODOrPairCut(){}
- AliAODOrPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):AliAODLogicalOperPairCut(first,second){}
+ AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
virtual ~AliAODOrPairCut(){}
Bool_t Pass(AliAODPair *p) const;
ClassDef(AliAODOrPairCut,1)
{
public:
AliAODAndPairCut(){}
- AliAODAndPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):AliAODLogicalOperPairCut(first,second){}
+ AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
virtual ~AliAODAndPairCut(){}
Bool_t Pass(AliAODPair *p) const;
ClassDef(AliAODAndPairCut,1)
/******************************************************************/
AliAODParticleCut::AliAODParticleCut():
- fCuts(new AliAODBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
+ fCuts(new AliAODParticleBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
fNCuts(0),
fPID(0)
{
TObject(in)
{
//cpy ctor
- fCuts = new AliAODBaseCut* [fgkMaxCuts];//last property in the property
+ fCuts = new AliAODParticleBaseCut* [fgkMaxCuts];//last property in the property
//property enum => defines number of properties
fNCuts = in.fNCuts;
fPID = in.fPID;
for (Int_t i = 0;i<fNCuts;i++)
{
- fCuts[i] = (AliAODBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+ fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
}
}
/******************************************************************/
fPID = in.fPID;
for (Int_t i = 0;i<fNCuts;i++)
{
- fCuts[i] = (AliAODBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
+ fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
}
return *this;
}
}
/******************************************************************/
-void AliAODParticleCut::AddBasePartCut(AliAODBaseCut* basecut)
+void AliAODParticleCut::AddBasePartCut(AliAODParticleBaseCut* basecut)
{
//adds the base pair cut (cut on one value)
}
/******************************************************************/
-AliAODBaseCut* AliAODParticleCut::FindCut(AliAODCutProperty property)
+AliAODParticleBaseCut* AliAODParticleCut::FindCut(AliAODCutProperty property)
{
//returns pointer to the cut checking the given property
for (Int_t i = 0;i<fNCuts;i++)
void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODRapidity);
+ AliAODParticleBaseCut* cut = FindCut(kAODRapidity);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODRapidityCut(min,max);
void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODPseudoRapidity);
+ AliAODParticleBaseCut* cut = FindCut(kAODPseudoRapidity);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODPseudoRapidityCut(min,max);
void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODPx);
+ AliAODParticleBaseCut* cut = FindCut(kAODPx);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODPxCut(min,max);
}
void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODPy);
+ AliAODParticleBaseCut* cut = FindCut(kAODPy);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODPyCut(min,max);
}
void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODPz);
+ AliAODParticleBaseCut* cut = FindCut(kAODPz);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODPzCut(min,max);
}
void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODPhi);
+ AliAODParticleBaseCut* cut = FindCut(kAODPhi);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODPhiCut(min,max);
}
void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODTheta);
+ AliAODParticleBaseCut* cut = FindCut(kAODTheta);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODThetaCut(min,max);
}
void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODVx);
+ AliAODParticleBaseCut* cut = FindCut(kAODVx);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODVxCut(min,max);
}
void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODVy);
+ AliAODParticleBaseCut* cut = FindCut(kAODVy);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODVyCut(min,max);
}
void AliAODParticleCut::SetVzRange(Double_t min, Double_t max)
{
//name self descriptive
- AliAODBaseCut* cut = FindCut(kAODVz);
+ AliAODParticleBaseCut* cut = FindCut(kAODVz);
if(cut) cut->SetRange(min,max);
else fCuts[fNCuts++] = new AliAODVzCut(min,max);
}
/******************************************************************/
/******************************************************************/
-ClassImp(AliAODEmptyParticleCut)
-void AliAODEmptyParticleCut::Streamer(TBuffer &b)
+ClassImp(AliAODParticleEmptyCut)
+void AliAODParticleEmptyCut::Streamer(TBuffer &b)
{
//stramer
AliAODParticleCut::Streamer(b);
/******************************************************************/
/******************************************************************/
-ClassImp(AliAODBaseCut)
-void AliAODBaseCut::Print(void) const
+ClassImp(AliAODParticleBaseCut)
+void AliAODParticleBaseCut::Print(void) const
{
// prints the information anout the base cut to stdout
cout<<"fMin="<<fMin <<", fMax=" <<fMax<<" ";
}
/******************************************************************/
-void AliAODBaseCut::PrintProperty(void) const
+void AliAODParticleBaseCut::PrintProperty(void) const
{
//prints the property name
switch (fProperty)
void AliAODPIDCut::Print(void) const
{
cout<<"PID "<<fPID<<" ";
- AliAODBaseCut::Print();
+ AliAODParticleBaseCut::Print();
}
ClassImp( AliAODLogicalOperCut )
AliAODLogicalOperCut::AliAODLogicalOperCut():
- AliAODBaseCut(-10e10,10e10,kAODNone),
+ AliAODParticleBaseCut(-10e10,10e10,kAODNone),
fFirst(new AliAODDummyBaseCut),
fSecond(new AliAODDummyBaseCut)
{
}
/******************************************************************/
-AliAODLogicalOperCut::AliAODLogicalOperCut(AliAODBaseCut* first, AliAODBaseCut* second):
- AliAODBaseCut(-10e10,10e10,kAODNone),
- fFirst((first)?(AliAODBaseCut*)first->Clone():0x0),
- fSecond((second)?(AliAODBaseCut*)second->Clone():0x0)
+AliAODLogicalOperCut::AliAODLogicalOperCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):
+ AliAODParticleBaseCut(-10e10,10e10,kAODNone),
+ fFirst((first)?(AliAODParticleBaseCut*)first->Clone():0x0),
+ fSecond((second)?(AliAODParticleBaseCut*)second->Clone():0x0)
{
//ctor
if ( (fFirst && fSecond) == kFALSE)
#include "AliVAODParticle.h"
-class AliAODEmptyParticleCut;
+class AliAODParticleEmptyCut;
class AliAODParticleCut;
-class AliAODBaseCut;
+class AliAODParticleBaseCut;
/******************************************************************/
virtual Bool_t Pass(AliVAODParticle* p) const;
Bool_t IsEmpty() const {return kFALSE;}
- void AddBasePartCut(AliAODBaseCut* basecut);
+ void AddBasePartCut(AliAODParticleBaseCut* basecut);
Int_t GetPID() const { return fPID;}
void SetPID(Int_t pid){fPID=pid;}
void Print(void) const;
protected:
- AliAODBaseCut* FindCut(AliAODCutProperty property);
+ AliAODParticleBaseCut* FindCut(AliAODCutProperty property);
- AliAODBaseCut ** fCuts;//! Array with cuts
+ AliAODParticleBaseCut ** fCuts;//! Array with cuts
Int_t fNCuts; //number of base cuts stored in fCuts
Int_t fPID; //particle PID - if=0 (rootino) all pids are accepted
/******************************************************************/
/******************************************************************/
-class AliAODEmptyParticleCut: public AliAODParticleCut
+class AliAODParticleEmptyCut: public AliAODParticleCut
{
//Empty - it passes possitively all particles - it means returns always False
//Class describing cut on particles
public:
- AliAODEmptyParticleCut(){};
- virtual ~AliAODEmptyParticleCut(){};
+ AliAODParticleEmptyCut(){};
+ virtual ~AliAODParticleEmptyCut(){};
Bool_t Pass(AliVAODParticle*) const {return kFALSE;} //accept everything
Bool_t IsEmpty() const {return kTRUE;}
- ClassDef(AliAODEmptyParticleCut,1)
+ ClassDef(AliAODParticleEmptyCut,1)
};
/******************************************************************/
/******************************************************************/
-class AliAODBaseCut: public TObject
+class AliAODParticleBaseCut: public TObject
{
//This class defines the range of some property - pure virtual
//Property is coded by AliAODCutTypes type
public:
- AliAODBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliAODCutProperty prop = kAODNone):
+ AliAODParticleBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliAODCutProperty prop = kAODNone):
fProperty(prop),fMin(min),fMax(max){}
- virtual ~AliAODBaseCut(){}
+ virtual ~AliAODParticleBaseCut(){}
virtual Bool_t Pass(AliVAODParticle *p) const;
private:
void PrintProperty(void) const;
- ClassDef(AliAODBaseCut,1)
+ ClassDef(AliAODParticleBaseCut,1)
};
inline Bool_t
-AliAODBaseCut::Pass(AliVAODParticle *p) const
+AliAODParticleBaseCut::Pass(AliVAODParticle *p) const
{
//cjecks if particle property fits in range
if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
/******************************************************************/
-class AliAODMomentumCut: public AliAODBaseCut
+class AliAODMomentumCut: public AliAODParticleBaseCut
{
public:
- AliAODMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODP){}
+ AliAODMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODP){}
virtual ~AliAODMomentumCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->P();}
ClassDef(AliAODMomentumCut,1)
};
-class AliAODPtCut: public AliAODBaseCut
+class AliAODPtCut: public AliAODParticleBaseCut
{
public:
- AliAODPtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPt){}
+ AliAODPtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPt){}
virtual ~AliAODPtCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Pt();}
};
-class AliAODEnergyCut: public AliAODBaseCut
+class AliAODEnergyCut: public AliAODParticleBaseCut
{
public:
- AliAODEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODE){}
+ AliAODEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODE){}
virtual ~AliAODEnergyCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const {return p->E();}
ClassDef(AliAODEnergyCut,1)
};
-class AliAODRapidityCut: public AliAODBaseCut
+class AliAODRapidityCut: public AliAODParticleBaseCut
{
public:
- AliAODRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODRapidity){}
+ AliAODRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODRapidity){}
virtual ~AliAODRapidityCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Y();}
ClassDef(AliAODRapidityCut,1)
};
-class AliAODPseudoRapidityCut: public AliAODBaseCut
+class AliAODPseudoRapidityCut: public AliAODParticleBaseCut
{
public:
- AliAODPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPseudoRapidity){}
+ AliAODPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPseudoRapidity){}
virtual ~AliAODPseudoRapidityCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Eta();}
ClassDef(AliAODPseudoRapidityCut,1)
};
-class AliAODPxCut: public AliAODBaseCut
+class AliAODPxCut: public AliAODParticleBaseCut
{
public:
- AliAODPxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPx){}
+ AliAODPxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPx){}
virtual ~AliAODPxCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Px();}
ClassDef(AliAODPxCut,1)
};
-class AliAODPyCut: public AliAODBaseCut
+class AliAODPyCut: public AliAODParticleBaseCut
{
public:
- AliAODPyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPy){}
+ AliAODPyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPy){}
virtual ~AliAODPyCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Py();}
};
-class AliAODPzCut: public AliAODBaseCut
+class AliAODPzCut: public AliAODParticleBaseCut
{
public:
- AliAODPzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPz){}
+ AliAODPzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPz){}
virtual ~AliAODPzCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Pz();}
ClassDef(AliAODPzCut,1)
};
-class AliAODPhiCut: public AliAODBaseCut
+class AliAODPhiCut: public AliAODParticleBaseCut
{
public:
- AliAODPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPhi){}
+ AliAODPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPhi){}
virtual ~AliAODPhiCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Phi();}
};
-class AliAODThetaCut: public AliAODBaseCut
+class AliAODThetaCut: public AliAODParticleBaseCut
{
public:
- AliAODThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODTheta){}
+ AliAODThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODTheta){}
virtual ~AliAODThetaCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Theta();}
};
-class AliAODVxCut: public AliAODBaseCut
+class AliAODVxCut: public AliAODParticleBaseCut
{
//Cut of the X coAnddinate of the vertex position
public:
- AliAODVxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVx){}
+ AliAODVxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVx){}
virtual ~AliAODVxCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Vx();} //retruns value of the vertex
};
-class AliAODVyCut: public AliAODBaseCut
+class AliAODVyCut: public AliAODParticleBaseCut
{
//Cut of the X coAnddinate of the vertex position
public:
- AliAODVyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVy){}
+ AliAODVyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVy){}
virtual ~AliAODVyCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Vy();} //retruns value of the vertex
};
-class AliAODVzCut: public AliAODBaseCut
+class AliAODVzCut: public AliAODParticleBaseCut
{
//Cut of the X coAnddinate of the vertex position
public:
- AliAODVzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVz){}
+ AliAODVzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVz){}
virtual ~AliAODVzCut(){}
protected:
Double_t GetValue(AliVAODParticle * p)const{return p->Vz();} //retruns value of the vertex
};
-class AliAODPIDCut: public AliAODBaseCut
+class AliAODPIDCut: public AliAODParticleBaseCut
{
public:
- AliAODPIDCut():AliAODBaseCut(0.0,0.0,kAODPid),fPID(0){}
- AliAODPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliAODBaseCut(min,max,kAODPid),fPID(pid){}
+ AliAODPIDCut():AliAODParticleBaseCut(0.0,0.0,kAODPid),fPID(0){}
+ AliAODPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliAODParticleBaseCut(min,max,kAODPid),fPID(pid){}
virtual ~AliAODPIDCut(){}
void SetPID(Int_t pid){fPID = pid;}
// logical operations on cuts //
// //
/////////////////////////////////////////////////////
-class AliAODLogicalOperCut: public AliAODBaseCut
+class AliAODLogicalOperCut: public AliAODParticleBaseCut
{
public:
AliAODLogicalOperCut();
- AliAODLogicalOperCut(AliAODBaseCut* first, AliAODBaseCut* second);
+ AliAODLogicalOperCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second);
virtual ~AliAODLogicalOperCut();
protected:
Double_t GetValue(AliVAODParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
- AliAODBaseCut* fFirst; //second cut
- AliAODBaseCut* fSecond; //first cut
+ AliAODParticleBaseCut* fFirst; //second cut
+ AliAODParticleBaseCut* fSecond; //first cut
private:
- class AliAODDummyBaseCut: public AliAODBaseCut
+ class AliAODDummyBaseCut: public AliAODParticleBaseCut
{
Double_t GetValue(AliVAODParticle * /*part*/) const {return 0.0;}
Bool_t Pass(AliVAODParticle* /*part*/) const;
{
public:
AliAODOrCut(){}
- AliAODOrCut(AliAODBaseCut* first, AliAODBaseCut* second):AliAODLogicalOperCut(first,second){}
+ AliAODOrCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
virtual ~AliAODOrCut(){}
Bool_t Pass(AliVAODParticle *p) const;
ClassDef(AliAODOrCut,1)
{
public:
AliAODAndCut(){}
- AliAODAndCut(AliAODBaseCut* first, AliAODBaseCut* second):AliAODLogicalOperCut(first,second){}
+ AliAODAndCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
virtual ~AliAODAndCut(){}
Bool_t Pass(AliVAODParticle *p) const;
ClassDef(AliAODAndCut,1)
fEventCut(0x0),
fCutOnSim(kTRUE),
fCutOnRec(kTRUE),
- fPairCut(new AliAODEmptyPairCut()),//empty cut - accepts all particles
+ fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
fkPass2(&AliAnalysis::PassPartAndTrack2),
fEventCut(0x0),
fCutOnSim(kTRUE),
fCutOnRec(kTRUE),
- fPairCut(new AliAODEmptyPairCut()),//empty cut - accepts all particles
+ fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
fkPass2(&AliAnalysis::PassPartAndTrack2),
-#include "AliBaseEventCut.h"
+#include "AliEventBaseCut.h"
//________________________________
///////////////////////////////////////////////////////////
//
-// class AliBaseEventCut
+// class AliEventBaseCut
//
//
//
///////////////////////////////////////////////////////////
#include <AliAOD.h>
-ClassImp(AliBaseEventCut)
+ClassImp(AliEventBaseCut)
-AliBaseEventCut::AliBaseEventCut():
+AliEventBaseCut::AliEventBaseCut():
fMin(0.0),
fMax(0.0)
{
}
/**********************************************************/
-AliBaseEventCut::AliBaseEventCut(Double_t min, Double_t max):
+AliEventBaseCut::AliEventBaseCut(Double_t min, Double_t max):
fMin(min),
fMax(max)
{
}
/**********************************************************/
-Bool_t AliBaseEventCut::Pass(AliAOD* aod) const
+Bool_t AliEventBaseCut::Pass(AliAOD* aod) const
{
if ( (GetValue(aod) < fMin) || (GetValue(aod) > fMax) ) return kTRUE;
return kFALSE;
-#ifndef ALIBASEEVENTCUT_H
-#define ALIBASEEVENTCUT_H
+#ifndef ALIEVENTBASECUT_H
+#define ALIEVENTBASECUT_H
//________________________________
///////////////////////////////////////////////////////////
//
-// class AliBaseEventCut
+// class AliEventBaseCut
//
// Base class for cauts that checks only one event property
//
kNChargedCut
};
-class AliBaseEventCut: public TObject
+class AliEventBaseCut: public TObject
{
public:
- AliBaseEventCut();
- AliBaseEventCut(Double_t min,Double_t max);
- virtual ~AliBaseEventCut(){}
+ AliEventBaseCut();
+ AliEventBaseCut(Double_t min,Double_t max);
+ virtual ~AliEventBaseCut(){}
virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
protected:
Double_t fMin;//Minimum value
Double_t fMax;//Maximum value
private:
- ClassDef(AliBaseEventCut,1)
+ ClassDef(AliEventBaseCut,1)
};
/************************************************************/
-class AliPrimVertexXCut: public AliBaseEventCut
+class AliPrimVertexXCut: public AliEventBaseCut
{
public:
AliPrimVertexXCut(){}
- AliPrimVertexXCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
+ AliPrimVertexXCut(Double_t min,Double_t max):AliEventBaseCut(min,max){}
virtual ~AliPrimVertexXCut(){}
protected:
Double_t GetValue(AliAOD* aod) const;
};
/************************************************************/
-class AliPrimVertexYCut: public AliBaseEventCut
+class AliPrimVertexYCut: public AliEventBaseCut
{
public:
AliPrimVertexYCut(){}
- AliPrimVertexYCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
+ AliPrimVertexYCut(Double_t min,Double_t max):AliEventBaseCut(min,max){}
virtual ~AliPrimVertexYCut(){}
protected:
};
/************************************************************/
-class AliPrimVertexZCut: public AliBaseEventCut
+class AliPrimVertexZCut: public AliEventBaseCut
{
public:
AliPrimVertexZCut(){}
- AliPrimVertexZCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
+ AliPrimVertexZCut(Double_t min,Double_t max):AliEventBaseCut(min,max){}
virtual ~AliPrimVertexZCut(){}
protected:
Double_t GetValue(AliAOD* aod) const;
/************************************************************/
-class AliNChargedCut: public AliBaseEventCut
+class AliNChargedCut: public AliEventBaseCut
{
public:
AliNChargedCut(){}
AliNChargedCut(Double_t min, Double_t max, Double_t etamin = -10.0, Double_t etamax = 10.0):
- AliBaseEventCut(min,max),fEtaMin(etamin),fEtaMax(etamax){}
+ AliEventBaseCut(min,max),fEtaMin(etamin),fEtaMax(etamax){}
virtual ~AliNChargedCut(){}
protected:
Double_t GetValue(AliAOD* aod) const;
#include <TObjArray.h>
//#include <TIter.h>
-#include "AliBaseEventCut.h"
+#include "AliEventBaseCut.h"
ClassImp(AliEventCut)
}
TIter iter(&fBaseCuts);
- AliBaseEventCut* becut;
- while (( becut = (AliBaseEventCut*)iter() ))
+ AliEventBaseCut* becut;
+ while (( becut = (AliEventBaseCut*)iter() ))
{
if (becut->Pass(aod)) return kTRUE;
}
/*********************************************************/
/*********************************************************/
-ClassImp(AliEmptyEventCut)
+ClassImp(AliEventEmptyCut)
#include <TObject.h>
#include <TObjArray.h>
-#include "AliBaseEventCut.h"
+#include "AliEventBaseCut.h"
class AliAOD;
virtual ~AliEventCut();
virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
- void AddBasePartCut(AliBaseEventCut* ebcut){fBaseCuts.Add(ebcut);}
+ void AddBasePartCut(AliEventBaseCut* ebcut){fBaseCuts.Add(ebcut);}
protected:
TObjArray fBaseCuts;
ClassDef(AliEventCut,1)
};
-class AliEmptyEventCut: public TObject
+class AliEventEmptyCut: public TObject
{
public:
- AliEmptyEventCut(){}
- virtual ~AliEmptyEventCut(){}
+ AliEventEmptyCut(){}
+ virtual ~AliEventEmptyCut(){}
Bool_t Pass(AliAOD* aod) const {return kFALSE;}//always accept
protected:
private:
- ClassDef(AliEmptyEventCut,1)
+ ClassDef(AliEventEmptyCut,1)
};
#endif
AliAODPair.cxx AliAODPairCut.cxx \
AliAODParticleCut.cxx AliAODRun.cxx \
AliRunAnalysis.cxx AliAnalysis.cxx \
- AliEventCut.cxx AliBaseEventCut.cxx \
+ AliEventCut.cxx AliEventBaseCut.cxx \
AliReader.cxx AliReaderESD.cxx AliReaderKineTree.cxx\
AliTrackPoints.cxx AliClusterMap.cxx \
AliD0toKpi.cxx AliD0toKpiAnalysis.cxx AliFlowAnalysis.cxx \
DHDR:=ANALYSISLinkDef.h
EXPORT:=AliAOD.h AliEventBuffer.h\
- AliVAODParticle.h AliAODParticle.h \
- AliAODPair.h AliAODPairCut.h \
- AliAODParticleCut.h AliAODRun.h \
- AliRunAnalysis.h AliAnalysis.h AliEventCut.h \
- AliReader.h AliReaderESD.h \
- AliTrackPoints.h AliClusterMap.h \
- AliFlowAnalysis.h
+ AliVAODParticle.h AliAODParticle.h \
+ AliAODPair.h AliAODPairCut.h \
+ AliAODParticleCut.h AliAODRun.h \
+ AliRunAnalysis.h AliAnalysis.h \
+ AliEventCut.h AliEventBaseCut.h \
+ AliReader.h AliReaderESD.h \
+ AliTrackPoints.h AliClusterMap.h \
+ AliFlowAnalysis.h
EINCLUDE:= TPC CONTAINERS ITS
ClassImp( AliHBTFunction )
AliHBTFunction::AliHBTFunction():
- fPairCut(new AliAODEmptyPairCut()), //dummy cut
+ fPairCut(new AliAODPairEmptyCut()), //dummy cut
fWriteNumAndDen(kFALSE)
{
//Default constructor
AliHBTFunction::AliHBTFunction(const char* name,const char* title):
TNamed(name,title),
- fPairCut(new AliAODEmptyPairCut()), //dummy cut
+ fPairCut(new AliAODPairEmptyCut()), //dummy cut
fWriteNumAndDen(kFALSE)
{
//Constructor
ClassImp( AliHBTMonitorFunction )
AliHBTMonitorFunction::AliHBTMonitorFunction():
- fParticleCut(new AliAODEmptyParticleCut())
+ fParticleCut(new AliAODParticleEmptyCut())
{
//ctor
}
/******************************************************************/
AliHBTMonitorFunction::AliHBTMonitorFunction(const char* name,const char* title):
TNamed(name,title),
- fParticleCut(new AliAODEmptyParticleCut())
+ fParticleCut(new AliAODParticleEmptyCut())
{
//ctor
}
/******************************************************************/
AliHBTMonitorFunction::AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/):
TNamed(),
- fParticleCut(new AliAODEmptyParticleCut())
+ fParticleCut(new AliAODParticleEmptyCut())
{
//cpy ctor
// We cannot copy because it is a mess with names (histogram and functions)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff