fPID(pid),
fCutQuality(Form("%sQuality", name)),
fPIDCut(3.0),
- fMinTPCcluster(70)
+ fMinTPCcluster(70),
+ fDCARptFormula("")
{
//
// Constructor
fCutQuality.SetPtRange(0.15, 1E+20);
fCutQuality.SetEtaRange(-0.8, 0.8);
- fCutQuality.SetDCARmax(0.05);
- //fCutQuality.SetDCARPtFormula("0.0182+0.0350/pt^1.01");
+ fCutQuality.SetDCARPtFormula(fDCARptFormula);
fCutQuality.SetDCAZmax(2.0);
fCutQuality.SetSPDminNClusters(1);
fCutQuality.SetITSminNClusters(0);
//For the moment TOF is not used - PID ONLY WITH TPC - 3 sigmas in the whole range
// TPC:
- // below 350 MeV: 5sigma
- // between 350 and 500 MeV: 3sigma
- // pions above 500 MeV: 2sigma
- // kaons between 500 and 700 MeV: 2sigma
- // kaons above 700 MeV: rejected
- /*if (pTPC <= 0.35)
- maxTPC = 5.0;
- else if (pTPC <= 0.5)
- maxTPC = 3.0;
- else if (pTPC > 0.5 && fPID == AliPID::kPion)
- maxTPC = 2.0;
- else if (pTPC > 0.5 && pTPC <= 0.7 && fPID == AliPID::kKaon)
- maxTPC = 2.0;
- else
- return kFALSE;*/
- //maxTPC = 3.0;
+
maxTPC = fPIDCut;
return (nsTPC <= maxTPC);
public:
AliRsnCutDaughterSigmaStar2010PP(const char *name = "", AliPID::EParticleType pid = AliPID::kPion);
+ AliRsnCutDaughterSigmaStar2010PP(const AliRsnCutDaughterSigmaStar2010PP ©);
+ AliRsnCutDaughterSigmaStar2010PP &operator=(const AliRsnCutDaughterSigmaStar2010PP ©);
virtual ~AliRsnCutDaughterSigmaStar2010PP() { }
- //void SetPID(AliPID::EParticleType type) {fPID = type;}
- AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
+ AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
Bool_t MatchTOF(const AliVTrack *vtrack);
virtual Bool_t IsSelected(TObject *obj);
- void SetPIDCut(Double_t value) {fPIDCut = value;}
- void SetMinTPCcluster(Int_t value) {fMinTPCcluster = value;}
-
+ void SetPIDCut(Double_t value) {fPIDCut = value;}
+ void SetMinTPCcluster(Int_t value) {fMinTPCcluster = value;}
+ void SetDCARPtFormula(const char *formula) {fDCARptFormula = formula;}
+
private:
- AliPID::EParticleType fPID; // PID for track
- AliRsnCutTrackQuality fCutQuality; // track quality cut
+ AliPID::EParticleType fPID; // PID for track
+ AliRsnCutTrackQuality fCutQuality; // track quality cut
ClassDef(AliRsnCutDaughterSigmaStar2010PP,2) // cut definitions for Sigma*
protected:
- Double_t fPIDCut; // nsigmas for pions
- Int_t fMinTPCcluster; // min allowed TPC cluster
+ Double_t fPIDCut; // nsigmas for pions
+ Int_t fMinTPCcluster; // min allowed TPC cluster
+ TString fDCARptFormula; // min DCAR pt dependent formula
};
//__________________________________________________________________________________________________
ClassImp(AliRsnCutV0)
//_________________________________________________________________________________________________
-//AliRsnCutV0::AliRsnCutV0(const char *name, Int_t hypothesis) :
AliRsnCutV0::AliRsnCutV0(const char *name, Int_t hypothesis, AliPID::EParticleType pid, AliPID::EParticleType pid2) :
AliRsnCut(name, AliRsnTarget::kDaughter),
fHypothesis(0),
fMaxDaughtersDCA(0.5),
fMinTPCcluster(70),
fMaxRapidity(0.8),
+ fDCARptFormula(""),
fPID(pid),
fPID2(pid2),
- fPIDCut1(0),
- fPIDCut2(0),
- fPIDCut3(0),
+ fPIDCutProton(0),
+ fPIDCutPion(0),
fESDtrackCuts(0x0),
fCutQuality(Form("%sDaughtersQuality", name)),
fAODTestFilterBit(5)
fMaxDaughtersDCA(copy.fMaxDaughtersDCA),
fMinTPCcluster(copy.fMinTPCcluster),
fMaxRapidity(copy.fMaxRapidity),
+ fDCARptFormula(copy.fDCARptFormula),
fPID(copy.fPID),
fPID2(copy.fPID2),
- fPIDCut1(copy.fPIDCut1),
- fPIDCut2(copy.fPIDCut2),
- fPIDCut3(copy.fPIDCut3),
+ fPIDCutProton(copy.fPIDCutProton),
+ fPIDCutPion(copy.fPIDCutPion),
fESDtrackCuts(copy.fESDtrackCuts),
fCutQuality(copy.fCutQuality),
fAODTestFilterBit(copy.fAODTestFilterBit)
//
fCutQuality.SetPtRange(0.15, 1E+20);
fCutQuality.SetEtaRange(-0.8, 0.8);
- fCutQuality.SetDCARmax(0.05);
- //fCutQuality.SetDCARPtFormula("0.0182+0.0350/pt^1.01");
+ fCutQuality.SetDCARPtFormula(fDCARptFormula);
fCutQuality.SetDCAZmax(2.0);
fCutQuality.SetSPDminNClusters(1);
fCutQuality.SetITSminNClusters(0);
fMaxDaughtersDCA = copy.fMaxDaughtersDCA;
fMinTPCcluster = copy.fMinTPCcluster;
fMaxRapidity = copy.fMaxRapidity;
+ fDCARptFormula = copy.fDCARptFormula;
+ fCutQuality = copy.fCutQuality;
fPID = copy.fPID;
fPID2 = copy.fPID2;
- fPIDCut1 = copy.fPIDCut1;
- fPIDCut2 = copy.fPIDCut2;
- fPIDCut3 = copy.fPIDCut3;
+ fPIDCutProton = copy.fPIDCutProton;
+ fPIDCutPion = copy.fPIDCutPion;
fESDtrackCuts = copy.fESDtrackCuts;
fCutQuality = copy.fCutQuality;
fAODTestFilterBit = copy.fAODTestFilterBit;
// and computes all values used in the PID cut
//Bool_t isTOFpos = MatchTOF(ptrack);
//Bool_t isTOFneg = MatchTOF(ntrack);
- Double_t pospTPC = pTrack->GetTPCmomentum();
- Double_t negpTPC = nTrack->GetTPCmomentum();
+ //Double_t pospTPC = pTrack->GetTPCmomentum();
+ //Double_t negpTPC = nTrack->GetTPCmomentum();
//Double_t posp = pTrack->P();
//Double_t negp = nTrack->P();
Double_t posnsTPC = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, fPID));
//return (posnsTOF <= maxTOF);
//} else {
// TPC:
- // below 600 MeV: 4sigma
- // above 600 MeV: 3sigma
-
- if (pospTPC <= 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut1;
- else if (pospTPC > 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut2;
- else
- return kFALSE;
- maxTPC2 = fPIDCut3;
+ maxTPC = fPIDCutProton;
+ maxTPC2 = fPIDCutPion;
if (! ((posnsTPC <= maxTPC) && (negnsTPC2 <= maxTPC2)) ) {
AliDebugClass(2, "Failed check on V0 PID");
//return (negnsTOF <= maxTOF);
//} else {
// TPC:
- // below 600 MeV: 4sigma
- // above 600 MeV: 3sigma
-
- if (negpTPC <= 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut1;
- else if (negpTPC > 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut2;
- else
- return kFALSE;
- maxTPC2 = fPIDCut3;
+
+ maxTPC = fPIDCutProton;
+ maxTPC2 = fPIDCutPion;
if(! ((negnsTPC <= maxTPC) && (posnsTPC2 <= maxTPC2)) ) {
AliDebugClass(2, "Failed check on V0 PID");
// and computes all values used in the PID cut
//Bool_t isTOFpos = MatchTOF(ptrack);
//Bool_t isTOFneg = MatchTOF(ntrack);
- Double_t pospTPC = pTrack->GetTPCmomentum();
- Double_t negpTPC = nTrack->GetTPCmomentum();
+ //Double_t pospTPC = pTrack->GetTPCmomentum();
+ //Double_t negpTPC = nTrack->GetTPCmomentum();
//Double_t posp = pTrack->P();
//Double_t negp = nTrack->P();
Double_t posnsTPC = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, fPID));
//return (posnsTOF <= maxTOF);
//} else {
// TPC:
- // below 600 MeV: 4sigma
- // above 600 MeV: 3sigma
-
- if (pospTPC <= 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut1; // EF safer value to run on MC
- else if (pospTPC > 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut2; // EF safer value to run on MC
- else
- return kFALSE;
-
- maxTPC2 = fPIDCut3; // EF safer value to run on MC
+
+
+ maxTPC = fPIDCutProton;
+ maxTPC2 = fPIDCutPion;
if (! ((posnsTPC <= maxTPC) && (negnsTPC2 <= maxTPC2)) ) {
AliDebugClass(2, "Failed check on V0 PID");
//return (negnsTOF <= maxTOF);
//} else {
// TPC:
- // below 600 MeV: 4sigma
- // above 600 MeV: 3sigma
-
- if (negpTPC <= 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut1; // EF safer value to run on MC
- else if (negpTPC > 0.6 && fPID==AliPID::kProton)
- maxTPC = fPIDCut2; // EF safer value to run on MC
- else
- return kFALSE;
- maxTPC2 = fPIDCut3; // EF safer value to run on MC
+
+ maxTPC = fPIDCutProton;
+ maxTPC2 = fPIDCutPion;
if(! ((negnsTPC <= maxTPC) && (posnsTPC2 <= maxTPC2)) ) {
AliDebugClass(2, "Failed check on V0 PID");
public:
- //AliRsnCutV0(const char *name = "AliRsnCutV0", Int_t hypothesis = kLambda0);
AliRsnCutV0(const char *name = "AliRsnCutV0", Int_t hypothesis = kLambda0, AliPID::EParticleType pid = AliPID::kProton, AliPID::EParticleType pid2 = AliPID::kPion);
AliRsnCutV0(const AliRsnCutV0 ©);
AliRsnCutV0 &operator=(const AliRsnCutV0 ©);
void SetMaxDaughtersDCA(Double_t value) {fMaxDaughtersDCA = value;}
void SetMinTPCcluster(Int_t value) {fMinTPCcluster = value;}
void SetMaxRapidity(Double_t value) {fMaxRapidity = value;}
-
- void SetPIDCut1(Double_t value) {fPIDCut1 = value;}
- void SetPIDCut2(Double_t value) {fPIDCut2 = value;}
- void SetPIDCut3(Double_t value) {fPIDCut3 = value;}
-
- AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
- void SetAODTestFilterBit(Int_t value) {fAODTestFilterBit = value;}
+ void SetDCARPtFormula(const char *formula) {fDCARptFormula = formula;}
+
+ void SetPIDCutProton(Double_t value) {fPIDCutProton = value;}
+ void SetPIDCutPion(Double_t value) {fPIDCutPion = value;}
+
+
+ AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
+ void SetAODTestFilterBit(Int_t value) {fAODTestFilterBit = value;}
Int_t GetAODTestFilterBit() {return fAODTestFilterBit;}
virtual Bool_t IsSelected(TObject *obj);
Bool_t CheckESD(AliESDv0 *track);
Bool_t CheckAOD(AliAODv0 *track);
+
Int_t fHypothesis; // PDG code corresponding to expected V0 hypothesis
Double_t fMass; // mass corresponding to hypothesis
Double_t fTolerance; // tolerance in the difference between computed and expected mass
Double_t fMaxDaughtersDCA; // max allowed DCA between the two daughers
Int_t fMinTPCcluster; // min allowed TOC cluster
Double_t fMaxRapidity; // max allowed V0 rapidity
-
+ TString fDCARptFormula; // min DCAR pt dependent formula
+
AliPID::EParticleType fPID; // PID for track
AliPID::EParticleType fPID2; // PID for track
- Double_t fPIDCut1; // nsigmas for protons < 600 MeV/c
- Double_t fPIDCut2; // nsigmas for protons > 600 MeV/c
- Double_t fPIDCut3; // nsigmas for pions
-
-
+ Double_t fPIDCutProton; // nsigmas for protons
+ Double_t fPIDCutPion; // nsigmas for pions
+
AliESDtrackCuts *fESDtrackCuts; // quality cuts for v0 daughters
-
- AliRsnCutTrackQuality fCutQuality; // track quality cut
- Int_t fAODTestFilterBit; // test filter bit for AODs
-
+
+ AliRsnCutTrackQuality fCutQuality; // track quality cut
+
+ Int_t fAODTestFilterBit; // test filter bit for AODs
+
ClassDef(AliRsnCutV0, 1)
};
//
switch (fType) {
- case kP: return "SingleTrackPtot";
- case kPt: return "SingleTrackPt";
- case kPtpc: return "SingleTrackPtpc";
- case kEta: return "SingleTrackEta";
- case kMass: return "SingleTrackMass";
- case kITSsignal: return "SingleTrackITSsignal";
- case kTPCsignal: return "SingleTrackTPCsignal";
- case kTOFsignal: return "SingleTrackTOFsignal";
- case kTPCnsigmaPi: return "SingleTrackTPCnsigmaPion";
- case kTPCnsigmaK: return "SingleTrackTPCnsigmaKaon";
- case kTPCnsigmaP: return "SingleTrackTPCnsigmaProton";
- case kTOFnsigmaPi: return "SingleTrackTOFnsigmaPion";
- case kTOFnsigmaK: return "SingleTrackTOFnsigmaKaon";
- case kTOFnsigmaP: return "SingleTrackTOFnsigmaProton";
- case kCharge: return "SingleTrackCharge";
- case kPhi: return "SingleTrackPhi";
- case kPhiOuterTPC: return "SingleTrackPhiOuterTPC";
- default: return "Undefined";
+ case kP: return "SingleTrackPtot";
+ case kPt: return "SingleTrackPt";
+ case kPtpc: return "SingleTrackPtpc";
+ case kEta: return "SingleTrackEta";
+ case kMass: return "SingleTrackMass";
+ case kITSsignal: return "SingleTrackITSsignal";
+ case kTPCsignal: return "SingleTrackTPCsignal";
+ case kTOFsignal: return "SingleTrackTOFsignal";
+ case kTPCnsigmaPi: return "SingleTrackTPCnsigmaPion";
+ case kTPCnsigmaK: return "SingleTrackTPCnsigmaKaon";
+ case kTPCnsigmaP: return "SingleTrackTPCnsigmaProton";
+ case kTOFnsigmaPi: return "SingleTrackTOFnsigmaPion";
+ case kTOFnsigmaK: return "SingleTrackTOFnsigmaKaon";
+ case kTOFnsigmaP: return "SingleTrackTOFnsigmaProton";
+ case kV0DCA: return "V0DCAToPrimaryVertex";
+ case kDaughterDCA: return "V0DaughterDCA";
+ case kCosPointAng: return "V0CosineOfPointingAngle";
+ case kLambdaProtonPIDCut: return "V0LambdaProtonNsigma";
+ case kAntiLambdaAntiProtonPIDCut: return "V0AntiLambdaAntiProtonNsigma";
+ case kLambdaPionPIDCut: return "V0LambdaPionNsigma";
+ case kAntiLambdaAntiPionPIDCut: return "V0AntiLambdaPionNsigma";
+ default: return "Undefined";
}
}
AliVParticle *ref = fDaughter->GetRef();
AliVParticle *refMC = fDaughter->GetRefMC();
AliVTrack *track = fDaughter->Ref2Vtrack();
+ AliESDv0 *v0esd = fDaughter->Ref2ESDv0();
+ AliAODv0 *v0aod = fDaughter->Ref2AODv0();
+ AliESDEvent *lESDEvent = fEvent->GetRefESD();
+
+ Double_t xPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetX();
+ Double_t yPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetY();
+ Double_t zPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetZ();
+
if (fUseMCInfo && !refMC) {
AliError("No MC");
return kFALSE;
fComputedValue = 0.0;
return kFALSE;
}
-
- case kCharge:
- fComputedValue = (fUseMCInfo ? refMC->Charge() : ref->Charge());
- return kTRUE;
-
- case kPhi:
- fComputedValue = (fUseMCInfo ? (refMC->Phi()*TMath::RadToDeg()) : (ref->Phi()*TMath::RadToDeg()));
- return kTRUE;
-
- case kPhiOuterTPC:
- if (track) {
- Double_t pos[3]={0.,0.,0.};
- Double_t phiOut = -999.0;
- Double_t radius = 278.;//TPC outer (vessel) = 278 cm, TOF radius (active surf.) = 378 cm; ref. PPR.1
- AliExternalTrackParam etp; //thanks to Andrea and Cristina
- etp.CopyFromVTrack(track);
- if(etp.GetXYZAt(radius, 5., pos)){
- phiOut=TMath::ATan2(pos[1],pos[0])*TMath::RadToDeg();
- if (phiOut<0) phiOut+= (2*TMath::Pi()*TMath::RadToDeg());
- }
- fComputedValue = phiOut;
- } else {
- AliWarning("Cannot get phi at outer TPC radius for non-track object");
- fComputedValue = -99.0;
+ case kV0DCA:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ fComputedValue = v0ESD->GetD(xPrimaryVertex,yPrimaryVertex,zPrimaryVertex);
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ fComputedValue = v0AOD->DcaV0ToPrimVertex();
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
+ return kFALSE;
+ }
+ case kDaughterDCA:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ fComputedValue = v0ESD->GetDcaV0Daughters();
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ fComputedValue = v0AOD->DcaV0Daughters();
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
+ return kFALSE;
+ }
+ case kCosPointAng:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ fComputedValue = v0ESD->GetV0CosineOfPointingAngle();
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ fComputedValue = TMath::Cos(v0AOD->OpenAngleV0());
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
+ return kFALSE;
+ }
+ case kLambdaProtonPIDCut:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ // retrieve the V0 daughters
+ UInt_t lIdxPos = (UInt_t) TMath::Abs(v0ESD->GetPindex());
+ AliESDtrack *pTrack = lESDEvent->GetTrack(lIdxPos);
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kProton));
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ AliAODTrack *pTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(0));
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kProton));
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
+ return kFALSE;
+ }
+ case kAntiLambdaAntiProtonPIDCut:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ // retrieve the V0 daughters
+ UInt_t lIdxNeg = (UInt_t) TMath::Abs(v0ESD->GetNindex());
+ AliESDtrack *nTrack = lESDEvent->GetTrack(lIdxNeg);
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kProton));
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ AliAODTrack *nTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(1));
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kProton));
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
+ return kFALSE;
+ }
+ case kLambdaPionPIDCut:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ // retrieve the V0 daughters
+ UInt_t lIdxNeg = (UInt_t) TMath::Abs(v0ESD->GetNindex());
+ AliESDtrack *nTrack = lESDEvent->GetTrack(lIdxNeg);
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kPion));
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ AliAODTrack *nTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(1));
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kPion));
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
+ return kFALSE;
+ }
+ case kAntiLambdaAntiPionPIDCut:
+ if(v0esd) {
+ AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
+ // retrieve the V0 daughters
+ UInt_t lIdxPos = (UInt_t) TMath::Abs(v0ESD->GetPindex());
+ AliESDtrack *pTrack = lESDEvent->GetTrack(lIdxPos);
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kPion));
+ return kTRUE;
+ }
+ if(v0aod) {
+ AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
+ AliAODTrack *pTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(0));
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kPion));
+ return kTRUE;
+ }
+ else {
+ fComputedValue = -999;
return kFALSE;
- }
- return kTRUE;
-
+ }
+
+
default:
AliError(Form("[%s] Invalid value type for this computation", GetName()));
return kFALSE;
kTOFnsigmaP, // TOF number of sigmas proton
kNITSclusters, // n ITS clusters
kNTPCclusters, // n TPC clusters
- kITSchi2, // ITS chi^2
- kTPCchi2, // TPC chi^2
- kDCAXY, // DCA xy
- kDCAZ, // DCA z
- kCharge, // charge
- kPhi, // azimuthal angle at vertex
- kPhiOuterTPC,// azimuthal angle at TPC outer radius
+ kITSchi2, // ITS chi^2
+ kTPCchi2, // TPC chi^2
+ kDCAXY, // DCA xy
+ kDCAZ, // DCA z
+ kV0DCA, // V0 DCA
+ kDaughterDCA, // DCA of V0 Daughters
+ kCosPointAng, // V0 Cosing of Pointing Angle
+ kLambdaProtonPIDCut, //V0 - Lambda number of sigmas proton
+ kAntiLambdaAntiProtonPIDCut, //V0 - AntiLambda number of sigmas antiproton
+ kLambdaPionPIDCut, //V0 - Lambda number of sigmas pion
+ kAntiLambdaAntiPionPIDCut, //V0 - AntiLambda number of sigmas pion
kTypes
};
Bool_t isPP,
Float_t cutV = 10.0,
Int_t aodFilterBit = 5,
- Int_t piPIDCut = 3.0,
- Int_t pPIDCut = 3.0,
- Float_t piDCAcut = 0.05,
+ Float_t piPIDCut = 3.0,
+ Float_t pPIDCut = 3.0,
+ Float_t trackDCAcut = 7.0,
Float_t massTol = 0.01,
Float_t lambdaDCA = 0.3,
Float_t lambdaCosPoinAn = 0.99,
}
// create the task and configure
- TString taskName = Form("SigmaStar%s%s_%.1f_%d", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"),cutV,NTPCcluster);
+ TString taskName = Form("SigmaStar%s%s_%.1f_%d_%.1f_%.1f_%.1f_%.2f_%.1f_%.2f_%.1f", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"),cutV,NTPCcluster,piPIDCut,pPIDCut,trackDCAcut,massTol,lambdaDCA,lambdaCosPoinAn,lambdaDaughDCA);
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC);
if (!isMC && !isPP){
Printf(Form("========== SETTING USE CENTRALITY PATCH AOD049 : %s", (aodN==49)? "yes" : "no"));
Printf("========================== MC analysis - PID cuts not used");
} else
Printf("========================== DATA analysis - PID cuts used");
- if (!ConfigSigmaStar(task, isPP, isMC, piPIDCut, pPIDCut, aodFilterBit, piDCAcut, massTol, lambdaDCA, lambdaCosPoinAn, lambdaDaughDCA, NTPCcluster, "", cutsPair)) return 0x0;
+ if (!ConfigSigmaStar(task, isPP, isMC, piPIDCut, pPIDCut, aodFilterBit, trackDCAcut, massTol, lambdaDCA, lambdaCosPoinAn, lambdaDaughDCA, NTPCcluster, "", cutsPair)) return 0x0;
//
// -- CONTAINERS --------------------------------------------------------------------------------
// outputFileName += ":Rsn";
Printf("AddAnalysisTaskSigmaStarPP - Set OutputFileName : \n %s\n", outputFileName.Data() );
- AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s_%.1f_%d",outNameSuffix.Data(), cutV, NTPCcluster),
+ AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s_%.1f_%d_%.1f_%.1f_%.1f_%.2f_%.1f_%.2f_%.1f",outNameSuffix.Data(),cutV,NTPCcluster,piPIDCut,pPIDCut,trackDCAcut,massTol,lambdaDCA,lambdaCosPoinAn,lambdaDaughDCA),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
Float_t piPIDCut,
Float_t pPIDCut,
Int_t aodFilterBit,
- Float_t piDCAcut,
+ Float_t trackDCAcut,
Float_t massTol,
Float_t lambdaDCA,
Float_t lambdaCosPoinAn,
// -- Define track cuts -------------------------------------------------------------------------
//
+ TString s = ""; s+=trackDCAcut; s+="*(0.0026+0.0050/pt^1.01)";
+
+ const char *formula = s;
+
// integrated pion cut
AliRsnCutDaughterSigmaStar2010PP *cutPi = new AliRsnCutDaughterSigmaStar2010PP("cutPionForSigmaStar", AliPID::kPion);
cutPi->SetPIDCut(piPIDCut);
cutPi->SetMinTPCcluster(NTPCcluster);
AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality();
- cutQuality->SetAODTestFilterBit(aodFilterBit);
- cutQuality->SetDCARmax(piDCAcut);
+ cutQuality->SetAODTestFilterBit(aodFilterBit);
+ cutQuality->SetDCARPtFormula(formula);
// cut set
AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForSigmaStar", AliRsnTarget::kDaughter);
cutLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
cutLambda->SetMinTPCcluster(NTPCcluster);
cutLambda->SetMaxRapidity(0.8);
+ cutLambda->SetDCARPtFormula(formula);
cutLambda->SetAODTestFilterBit(aodFilterBit);
- cutLambda->SetPIDCut1(pPIDCut);
- cutLambda->SetPIDCut2(piPIDCut);
- cutLambda->SetPIDCut3(piPIDCut);
+ cutLambda->SetPIDCutProton(pPIDCut);
+ cutLambda->SetPIDCutPion(piPIDCut);
// cut set
AliRsnCutSet *cutSetLambda = new AliRsnCutSet("setLambda", AliRsnTarget::kDaughter);
cutAntiLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
cutAntiLambda->SetMinTPCcluster(NTPCcluster);
cutAntiLambda->SetMaxRapidity(0.8);
+ cutAntiLambda->SetDCARPtFormula(formula);
cutAntiLambda->SetAODTestFilterBit(aodFilterBit);
- cutAntiLambda->SetPIDCut1(pPIDCut);
- cutAntiLambda->SetPIDCut2(piPIDCut);
- cutAntiLambda->SetPIDCut3(piPIDCut);
+ cutAntiLambda->SetPIDCutProton(pPIDCut);
+ cutAntiLambda->SetPIDCutPion(piPIDCut);
// cut set
AliRsnCutSet *cutSetAntiLambda = new AliRsnCutSet("setAntiLambda", AliRsnTarget::kDaughter);
//
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
- /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
/* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
/* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
- /* rapidity */ Int_t rapID = task->CreateValue(AliRsnMiniValue::kY, kFALSE);
//
// -- Create all needed outputs -----------------------------------------------------------------
out->AddAxis(imID, 800, 1.2, 2.0);
// axis Y: transverse momentum
out->AddAxis(ptID, 100, 0.0, 10.0);
- // axis Z: rapidity
- //out->AddAxis(rapID, 160, -0.8, 0.8);
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
}
+ AddMonitorOutput_PionDCA(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionPIDCut(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput());
+
+ AddMonitorOutput_LambdaMass(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDCA(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDaughterDCA(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaCosPointAngle(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaProtonPID(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaPionPID(cutSetLambda->GetMonitorOutput());
+
+ AddMonitorOutput_LambdaMass(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDCA(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDaughterDCA(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaCosPointAngle(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaAntiProtonPID(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaAntiPionPID(cutSetAntiLambda->GetMonitorOutput());
if (isMC) {
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// create output
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// create output
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// create output
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520M_TrueMC%s", suffix), mode.Data(), "MOTHER");
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520MBar_TrueMC%s", suffix), mode.Data(), "MOTHER");
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
return kTRUE;
}
+void AddMonitorOutput_PionDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdca=0)
+{
+
+ // PionDCA
+ AliRsnValueDaughter *axisPionDCA = new AliRsnValueDaughter("pion_dca", AliRsnValueDaughter::kDCAXY);
+ axisPionDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionDCA = new AliRsnListOutput("Pion_DCA", AliRsnListOutput::kHistoDefault);
+ outMonitorPionDCA->AddValue(axisPionDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionDCA);
+ if (pdca) pdca->AddOutput(outMonitorPionDCA);
+
+}
+
+void AddMonitorOutput_PionPIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piPID=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionPIDCut = new AliRsnValueDaughter("pionPID", AliRsnValueDaughter::kTPCnsigmaPi);
+ axisPionPIDCut->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionPIDCut = new AliRsnListOutput("Pion_PID_Cut", AliRsnListOutput::kHistoDefault);
+ outMonitorPionPIDCut->AddValue(axisPionPIDCut);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionPIDCut);
+ if (piPID) piPID->AddOutput(outMonitorPionPIDCut);
+
+}
+
+void AddMonitorOutput_PionNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piNTPC=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionNTPC = new AliRsnValueDaughter("pionNTPC", AliRsnValueDaughter::kNTPCclusters);
+ axisPionNTPC->SetBins(0.0,200,1);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionNTPC = new AliRsnListOutput("Pion_NTPC", AliRsnListOutput::kHistoDefault);
+ outMonitorPionNTPC->AddValue(axisPionNTPC);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionNTPC);
+ if (piNTPC) pNTPC->AddOutput(outMonitorPionNTPC);
+
+}
-void AddMonitorOutput(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
+void AddMonitorOutput_LambdaMass(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
{
// Mass
- AliRsnValueDaughter *axisMass = new AliRsnValueDaughter("m", AliRsnValueDaughter::kMass);
- axisMass->SetBins(0.7,1.5,0.05);
+ AliRsnValueDaughter *axisMass = new AliRsnValueDaughter("lambda_mass", AliRsnValueDaughter::kMass);
+ axisMass->SetBins(0.7,1.5,0.001);
// output: 2D histogram
- AliRsnListOutput *outMonitorM = new AliRsnListOutput("M", AliRsnListOutput::kHistoDefault);
+ AliRsnListOutput *outMonitorM = new AliRsnListOutput("Lambda_Mass", AliRsnListOutput::kHistoDefault);
outMonitorM->AddValue(axisMass);
// add outputs to loop
if (lm) lm->AddOutput(outMonitorM);
}
+
+void AddMonitorOutput_LambdaDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldca=0)
+{
+
+ // Lambda DCA
+ AliRsnValueDaughter *axisLambdaDCA = new AliRsnValueDaughter("lambda_dca", AliRsnValueDaughter::kV0DCA);
+ axisLambdaDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaDCA = new AliRsnListOutput("Lambda_DCA", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaDCA->AddValue(axisLambdaDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaDCA);
+ if (ldca) ldca->AddOutput(outMonitorLambdaDCA);
+
+}
+
+void AddMonitorOutput_LambdaDaughterDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldaugdca=0)
+{
+
+ // Lambda Daughter DCA
+ AliRsnValueDaughter *axisLambdaDDCA = new AliRsnValueDaughter("lambda_daughterDCA", AliRsnValueDaughter::kDaughterDCA);
+ axisLambdaDDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaDDCA = new AliRsnListOutput("Lambda_DaughterDCA", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaDDCA->AddValue(axisLambdaDDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaDDCA);
+ if (ldaugdca) ldaugdca->AddOutput(outMonitorLambdaDDCA);
+
+}
+
+void AddMonitorOutput_LambdaCosPointAngle(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lcpa=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaCPA = new AliRsnValueDaughter("lambda_cospointang", AliRsnValueDaughter::kCosPointAng);
+ axisLambdaCPA->SetBins(0.97,1,0.0001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaCPA = new AliRsnListOutput("Lambda_CosineOfPointingAngle", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaCPA->AddValue(axisLambdaCPA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaCPA);
+ if (lcpa) lcpa->AddOutput(outMonitorLambdaCPA);
+
+}
+
+void AddMonitorOutput_LambdaProtonPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lpPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaProtonPID = new AliRsnValueDaughter("lambda_protonPID", AliRsnValueDaughter::kLambdaProtonPIDCut);
+ axisLambdaProtonPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaProtonPID = new AliRsnListOutput("Lambda_ProtonPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaProtonPID->AddValue(axisLambdaProtonPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaProtonPID);
+ if (lpPID) lpPID->AddOutput(outMonitorLambdaProtonPID);
+
+}
+
+void AddMonitorOutput_LambdaPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lpiPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaPionPID = new AliRsnValueDaughter("lambda_pionPID", AliRsnValueDaughter::kLambdaPionPIDCut);
+ axisLambdaPionPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaPionPID = new AliRsnListOutput("Lambda_PionPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaPionPID->AddValue(axisLambdaPionPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaPionPID);
+ if (lpiPID) lpiPID->AddOutput(outMonitorLambdaPionPID);
+
+}
+
+void AddMonitorOutput_LambdaAntiProtonPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaAntiProtonPID = new AliRsnValueDaughter("lambda_antiprotonPID", AliRsnValueDaughter::kAntiLambdaAntiProtonPIDCut);
+ axisLambdaAntiProtonPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaAntiProtonPID = new AliRsnListOutput("Lambda_AntiProtonPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaAntiProtonPID->AddValue(axisLambdaAntiProtonPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaAntiProtonPID);
+ if (lapPID) lapPID->AddOutput(outMonitorLambdaAntiProtonPID);
+
+}
+
+void AddMonitorOutput_LambdaAntiPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapiPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaAntiPionPID = new AliRsnValueDaughter("lambda_antipionPID", AliRsnValueDaughter::kAntiLambdaAntiPionPIDCut);
+ axisLambdaAntiPionPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaAntiPionPID = new AliRsnListOutput("Lambda_AntiPionPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaAntiPionPID->AddValue(axisLambdaAntiPionPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaAntiPionPID);
+ if (lapiPID) lpiPID->AddOutput(outMonitorLambdaAntiPionPID);
+
+}
Float_t piPIDCut,
Float_t pPIDCut,
Int_t aodFilterBit,
- Float_t piDCAcut,
+ Float_t trackDCAcut,
Float_t massTol,
Float_t lambdaDCA,
Float_t lambdaCosPoinAn,
// -- Define track cuts -------------------------------------------------------------------------
//
+ TString s = ""; s+=trackDCAcut; s+="*(0.0026+0.0050/pt^1.01)";
+
+ const char *formula = s;
+
// integrated pion cut
AliRsnCutDaughterSigmaStar2010PP *cutPi = new AliRsnCutDaughterSigmaStar2010PP("cutPionForSigmaStar", AliPID::kPion);
cutPi->SetPIDCut(piPIDCut);
cutPi->SetMinTPCcluster(NTPCcluster);
AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality();
cutQuality->SetAODTestFilterBit(aodFilterBit);
- cutQuality->SetDCARmax(piDCAcut);
+ cutQuality->SetDCARPtFormula(formula);
// cut set
AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForSigmaStar", AliRsnTarget::kDaughter);
cutLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
cutLambda->SetMinTPCcluster(NTPCcluster);
cutLambda->SetMaxRapidity(0.8);
+ cutLambda->SetDCARPtFormula(formula);
cutLambda->SetAODTestFilterBit(aodFilterBit);
- cutLambda->SetPIDCut1(pPIDCut);
- cutLambda->SetPIDCut2(piPIDCut);
- cutLambda->SetPIDCut3(piPIDCut);
+ cutLambda->SetPIDCutProton(pPIDCut);
+ cutLambda->SetPIDCutPion(piPIDCut);
// cut set
AliRsnCutSet *cutSetLambda = new AliRsnCutSet("setLambda", AliRsnTarget::kDaughter);
cutAntiLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
cutAntiLambda->SetMinTPCcluster(NTPCcluster);
cutAntiLambda->SetMaxRapidity(0.8);
+ cutAntiLambda->SetDCARPtFormula(formula);
cutAntiLambda->SetAODTestFilterBit(aodFilterBit);
- cutAntiLambda->SetPIDCut1(pPIDCut);
- cutAntiLambda->SetPIDCut2(piPIDCut);
- cutAntiLambda->SetPIDCut3(piPIDCut);
+ cutAntiLambda->SetPIDCutProton(pPIDCut);
+ cutAntiLambda->SetPIDCutPion(piPIDCut);
// cut set
AliRsnCutSet *cutSetAntiLambda = new AliRsnCutSet("setAntiLambda", AliRsnTarget::kDaughter);
//
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
- /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
/* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
/* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
- /* rapidity */ Int_t rapID = task->CreateValue(AliRsnMiniValue::kY, kFALSE);
//
// -- Create all needed outputs -----------------------------------------------------------------
out->AddAxis(imID, 800, 1.2, 2.0);
// axis Y: transverse momentum
out->AddAxis(ptID, 100, 0.0, 10.0);
- // axis Z: rapidity
- //out->AddAxis(rapID, 160, -0.8, 0.8);
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
}
-
+ AddMonitorOutput_PionDCA(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionPIDCut(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput());
+
+ AddMonitorOutput_LambdaMass(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDCA(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDaughterDCA(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaCosPointAngle(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaProtonPID(cutSetLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaPionPID(cutSetLambda->GetMonitorOutput());
+
+ AddMonitorOutput_LambdaMass(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDCA(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaDaughterDCA(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaCosPointAngle(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaAntiProtonPID(cutSetAntiLambda->GetMonitorOutput());
+ AddMonitorOutput_LambdaAntiPionPID(cutSetAntiLambda->GetMonitorOutput());
+
if (isMC) {
TString mode = "HIST";
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// create output
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// create output
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// create output
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520M_TrueMC%s", suffix), mode.Data(), "MOTHER");
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520MBar_TrueMC%s", suffix), mode.Data(), "MOTHER");
// binnings
out->AddAxis(imID, 800, 1.2, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
- //out->AddAxis(rapID, 160, -0.8, 0.8);
+
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
return kTRUE;
}
+void AddMonitorOutput_PionDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdca=0)
+{
+
+ // PionDCA
+ AliRsnValueDaughter *axisPionDCA = new AliRsnValueDaughter("pion_dca", AliRsnValueDaughter::kDCAXY);
+ axisPionDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionDCA = new AliRsnListOutput("Pion_DCA", AliRsnListOutput::kHistoDefault);
+ outMonitorPionDCA->AddValue(axisPionDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionDCA);
+ if (pdca) pdca->AddOutput(outMonitorPionDCA);
+
+}
+
+void AddMonitorOutput_PionPIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piPID=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionPIDCut = new AliRsnValueDaughter("pionPID", AliRsnValueDaughter::kTPCnsigmaPi);
+ axisPionPIDCut->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionPIDCut = new AliRsnListOutput("Pion_PID_Cut", AliRsnListOutput::kHistoDefault);
+ outMonitorPionPIDCut->AddValue(axisPionPIDCut);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionPIDCut);
+ if (piPID) piPID->AddOutput(outMonitorPionPIDCut);
+
+}
+
+void AddMonitorOutput_PionNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piNTPC=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionNTPC = new AliRsnValueDaughter("pionNTPC", AliRsnValueDaughter::kNTPCclusters);
+ axisPionNTPC->SetBins(0.0,200,1);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionNTPC = new AliRsnListOutput("Pion_NTPC", AliRsnListOutput::kHistoDefault);
+ outMonitorPionNTPC->AddValue(axisPionNTPC);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionNTPC);
+ if (piNTPC) pNTPC->AddOutput(outMonitorPionNTPC);
+
+}
-void AddMonitorOutput(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
+void AddMonitorOutput_LambdaMass(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
{
// Mass
- AliRsnValueDaughter *axisMass = new AliRsnValueDaughter("m", AliRsnValueDaughter::kMass);
- axisMass->SetBins(0.7,1.5,0.05);
+ AliRsnValueDaughter *axisMass = new AliRsnValueDaughter("lambda_mass", AliRsnValueDaughter::kMass);
+ axisMass->SetBins(0.7,1.5,0.001);
// output: 2D histogram
- AliRsnListOutput *outMonitorM = new AliRsnListOutput("M", AliRsnListOutput::kHistoDefault);
+ AliRsnListOutput *outMonitorM = new AliRsnListOutput("Lambda_Mass", AliRsnListOutput::kHistoDefault);
outMonitorM->AddValue(axisMass);
// add outputs to loop
if (lm) lm->AddOutput(outMonitorM);
}
+
+void AddMonitorOutput_LambdaDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldca=0)
+{
+
+ // Lambda DCA
+ AliRsnValueDaughter *axisLambdaDCA = new AliRsnValueDaughter("lambda_dca", AliRsnValueDaughter::kV0DCA);
+ axisLambdaDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaDCA = new AliRsnListOutput("Lambda_DCA", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaDCA->AddValue(axisLambdaDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaDCA);
+ if (ldca) ldca->AddOutput(outMonitorLambdaDCA);
+
+}
+
+void AddMonitorOutput_LambdaDaughterDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldaugdca=0)
+{
+
+ // Lambda Daughter DCA
+ AliRsnValueDaughter *axisLambdaDDCA = new AliRsnValueDaughter("lambda_daughterDCA", AliRsnValueDaughter::kDaughterDCA);
+ axisLambdaDDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaDDCA = new AliRsnListOutput("Lambda_DaughterDCA", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaDDCA->AddValue(axisLambdaDDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaDDCA);
+ if (ldaugdca) ldaugdca->AddOutput(outMonitorLambdaDDCA);
+
+}
+
+void AddMonitorOutput_LambdaCosPointAngle(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lcpa=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaCPA = new AliRsnValueDaughter("lambda_cospointang", AliRsnValueDaughter::kCosPointAng);
+ axisLambdaCPA->SetBins(0.97,1,0.0001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaCPA = new AliRsnListOutput("Lambda_CosineOfPointingAngle", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaCPA->AddValue(axisLambdaCPA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaCPA);
+ if (lcpa) lcpa->AddOutput(outMonitorLambdaCPA);
+
+}
+
+void AddMonitorOutput_LambdaProtonPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lpPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaProtonPID = new AliRsnValueDaughter("lambda_protonPID", AliRsnValueDaughter::kLambdaProtonPIDCut);
+ axisLambdaProtonPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaProtonPID = new AliRsnListOutput("Lambda_ProtonPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaProtonPID->AddValue(axisLambdaProtonPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaProtonPID);
+ if (lpPID) lpPID->AddOutput(outMonitorLambdaProtonPID);
+
+}
+
+void AddMonitorOutput_LambdaPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lpiPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaPionPID = new AliRsnValueDaughter("lambda_pionPID", AliRsnValueDaughter::kLambdaPionPIDCut);
+ axisLambdaPionPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaPionPID = new AliRsnListOutput("Lambda_PionPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaPionPID->AddValue(axisLambdaPionPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaPionPID);
+ if (lpiPID) lpiPID->AddOutput(outMonitorLambdaPionPID);
+
+}
+
+void AddMonitorOutput_LambdaAntiProtonPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaAntiProtonPID = new AliRsnValueDaughter("lambda_antiprotonPID", AliRsnValueDaughter::kAntiLambdaAntiProtonPIDCut);
+ axisLambdaAntiProtonPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaAntiProtonPID = new AliRsnListOutput("Lambda_AntiProtonPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaAntiProtonPID->AddValue(axisLambdaAntiProtonPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaAntiProtonPID);
+ if (lapPID) lapPID->AddOutput(outMonitorLambdaAntiProtonPID);
+
+}
+
+void AddMonitorOutput_LambdaAntiPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapiPID=0)
+{
+
+ // Lambda Cosine of the Pointing Angle
+ AliRsnValueDaughter *axisLambdaAntiPionPID = new AliRsnValueDaughter("lambda_antipionPID", AliRsnValueDaughter::kAntiLambdaAntiPionPIDCut);
+ axisLambdaAntiPionPID->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorLambdaAntiPionPID = new AliRsnListOutput("Lambda_AntiPionPID", AliRsnListOutput::kHistoDefault);
+ outMonitorLambdaAntiPionPID->AddValue(axisLambdaAntiPionPID);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorLambdaAntiPionPID);
+ if (lapiPID) lpiPID->AddOutput(outMonitorLambdaAntiPionPID);
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff