#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
+#include "TF1.h"
#include "AliLog.h"
+#include "AliVParticle.h"
#include "AliAnalysisTaskSE.h"
+#include "AliESDtrackCuts.h"
#define ID(x) x, #x
#define LAB(x) x + 1, #x
class TList;
class TClonesArray;
-class AliVParticle;
+class AliOADBContainer;
+class AliTOFPIDParams;
class AliVTrack;
class AliPIDResponse;
class AliEventPoolManager;
class AliEventPool;
-class AliESDtrackCuts;
+class AliEventplane;
class AliAnalysisTaskJetProtonCorr :
public AliAnalysisTaskSE
virtual void UserExec(Option_t *option);
virtual void Terminate(const Option_t *option);
+ void SetParamsTOF();
+
// task configuration
- void SetJetBranchName(const char* const branchName) { strncpy(fJetBranchName, branchName, fgkStringLength); }
+ void SetJetBranchName(const char* branchName) { strncpy(fJetBranchName, branchName, fgkStringLength-1); }
const char* GetJetBranchName() const { return fJetBranchName; }
void SetPtThrPart(Float_t minPt, Float_t maxPt) { fTrgPartPtMin = minPt; fTrgPartPtMax = maxPt; }
Float_t GetPtMinAss() const { return fAssPartPtMin; }
Float_t GetPtMaxAss() const { return fAssPartPtMax; }
+ void SetTwoTrackCut(Float_t cut) { fCutsTwoTrackEff = cut; }
+ Float_t GetTwoTrackCut() const { return fCutsTwoTrackEff; }
+
+ void SetTrackCutsAss(const AliESDtrackCuts &cuts) { *fCutsPrimAss = cuts; }
+ void SetTrackCutsTrg(const AliESDtrackCuts &cuts) { *fCutsPrimTrg = cuts; }
+ void SetTrackCutsTrgConstrain(const AliESDtrackCuts &cuts) { *fCutsPrimTrgConstrain = cuts; }
+
+ void SetTrgJetEtaMax(Float_t etamax) { fTrgJetEtaMax = etamax; }
+ Float_t GetTrgJetEtaMax() const { return fTrgJetEtaMax; }
+ void SetHadEtaMax(Float_t etamax) { fHadEtaMax = etamax; }
+ Float_t GetHadEtaMax() const { return fHadEtaMax; }
+
+ void SetUseEvplaneV0(Bool_t usev0 = kTRUE) { fUseEvplaneV0 = usev0; }
+ Bool_t GetUseEvplaneV0() const { return fUseEvplaneV0; }
+
+ void SetJetV2(Float_t v2Cent, Float_t v2Semi) {
+ fTrgJetPhiModCent->SetParameter(0, v2Cent);
+ fTrgJetPhiModSemi->SetParameter(0, v2Semi);
+ }
+ void SetHadV2(Float_t v2Cent, Float_t v2Semi) {
+ fTrgHadPhiModCent->SetParameter(0, v2Cent);
+ fTrgHadPhiModSemi->SetParameter(0, v2Semi);
+ }
+
+ void SetLeadingTrackPtMin(Float_t pt) { fTrgJetLeadTrkPtMin = pt; }
+ void SetLeadingTrackPtMax(Float_t pt) { fTrgJetLeadTrkPtMax = pt; }
+
+ void SetJetAreaMin(Float_t area) { fTrgJetAreaMin = area; }
+ Float_t GetJetAreaMin() const { return fTrgJetAreaMin; }
+
+ void SetRequirePID(Bool_t req = kTRUE) { fRequirePID = req; }
+ Bool_t GetRequirePID() const { return fRequirePID; }
+
+ void SetFilterMask(Int_t mask) { fAssFilterMask = mask; }
+ Int_t GetFilterMask() const { return fAssFilterMask; }
+
+ void SetErrorCount(Int_t cnt) { fErrorMsg = cnt; }
+ Int_t GetErrorCount() const { return fErrorMsg; }
+
+ void SetTrgAngleToEvPlane(Float_t angle) { fTrgAngleToEvPlane = angle; }
+ Float_t GetTrgAngleToEvPlane() const { return fTrgAngleToEvPlane; }
+
+ void SetToyMeanNoPart(Float_t mean) { fToyMeanNoPart = mean; }
+ Float_t GetToyMeanNoPart() const { return fToyMeanNoPart; }
+ void SetToyRadius(Float_t radius) { fToyRadius = radius; }
+ Float_t GetToyRadius() const { return fToyRadius; }
+ void SetToySmearPhi(Float_t sigma) { fToySmearPhi = sigma; }
+ Float_t GetToySmearPhi() const { return fToySmearPhi; }
+
+ void PrintTask(Option_t *option, Int_t indent) const;
+
+ static Double_t TOFsignal(Double_t *x, Double_t *par)
+ {
+ Double_t norm = par[0];
+ Double_t mean = par[1];
+ Double_t sigma = par[2];
+ Double_t tail = par[3];
+
+ if (x[0] <= (tail + mean))
+ return norm * TMath::Gaus(x[0], mean, sigma);
+ else
+ return norm * TMath::Gaus(tail + mean, mean, sigma) * TMath::Exp(-tail * (x[0] - tail - mean) / (sigma * sigma));
+ }
+
// histograms
enum Hist_t {
kHistStat = 0,
+ kHistVertexNctb,
+ kHistVertexZ,
kHistCentrality,
kHistCentralityUsed,
kHistCentralityCheck,
kHistCentralityCheckUsed,
+ kHistCentralityVsMult,
+ kHistSignalTPC,
+ kHistSignalTOF,
+ kHistBetaTOF,
+ kHistDeltaTPC,
+ kHistDeltaTPCSemi,
+ kHistDeltaTOF,
+ kHistDeltaTOFSemi,
+ // kHistExpSigmaTOFe,
+ // kHistExpSigmaTOFmu,
+ // kHistExpSigmaTOFpi,
+ // kHistExpSigmaTOFk,
+ // kHistExpSigmaTOFp,
+ // kHistExpSigmaTOFd,
+ // kHistExpSigmaTOFeSemi,
+ // kHistExpSigmaTOFmuSemi,
+ // kHistExpSigmaTOFpiSemi,
+ // kHistExpSigmaTOFkSemi,
+ // kHistExpSigmaTOFpSemi,
+ // kHistExpSigmaTOFdSemi,
+ // kHistCmpSigmaTOFe,
+ // kHistCmpSigmaTOFmu,
+ // kHistCmpSigmaTOFpi,
+ // kHistCmpSigmaTOFk,
+ // kHistCmpSigmaTOFp,
+ // kHistCmpSigmaTOFd,
+ // kHistCmpSigmaTOFeSemi,
+ // kHistCmpSigmaTOFmuSemi,
+ // kHistCmpSigmaTOFpiSemi,
+ // kHistCmpSigmaTOFkSemi,
+ // kHistCmpSigmaTOFpSemi,
+ // kHistCmpSigmaTOFdSemi,
+ kHistNsigmaTPCe,
+ kHistNsigmaTPCmu,
+ kHistNsigmaTPCpi,
+ kHistNsigmaTPCk,
+ kHistNsigmaTPCp,
+ kHistNsigmaTPCd,
+ kHistNsigmaTPCe_e,
+ kHistNsigmaTOFe,
+ kHistNsigmaTOFmu,
+ kHistNsigmaTOFpi,
+ kHistNsigmaTOFk,
+ kHistNsigmaTOFp,
+ kHistNsigmaTOFd,
+ kHistNsigmaTOFmismatch,
+ kHistDeltaTOFe,
+ kHistDeltaTOFmu,
+ kHistDeltaTOFpi,
+ kHistDeltaTOFk,
+ kHistDeltaTOFp,
+ kHistDeltaTOFd,
+
+ kHistNsigmaTPCeSemi,
+ kHistNsigmaTPCmuSemi,
+ kHistNsigmaTPCpiSemi,
+ kHistNsigmaTPCkSemi,
+ kHistNsigmaTPCpSemi,
+ kHistNsigmaTPCdSemi,
+ kHistNsigmaTPCe_eSemi,
+ kHistNsigmaTOFeSemi,
+ kHistNsigmaTOFmuSemi,
+ kHistNsigmaTOFpiSemi,
+ kHistNsigmaTOFkSemi,
+ kHistNsigmaTOFpSemi,
+ kHistNsigmaTOFdSemi,
+ kHistNsigmaTOFmismatchSemi,
+ kHistDeltaTOFeSemi,
+ kHistDeltaTOFmuSemi,
+ kHistDeltaTOFpiSemi,
+ kHistDeltaTOFkSemi,
+ kHistDeltaTOFpSemi,
+ kHistDeltaTOFdSemi,
+
kHistNsigmaTPCTOF,
+ kHistNsigmaTPCTOFPt,
+ kHistNsigmaTPCTOFUsed,
+ kHistNsigmaTPCTOFUsedCentral,
+ kHistNsigmaTPCTOFUsedSemiCentral,
+ kHistNsigmaTPCTOFUsedPt,
+ kHistNsigmaTPCTOFUsedPtCentral,
+ kHistNsigmaTPCTOFUsedPtSemiCentral,
+
+ kHistNsigmaTPCTOFUsedCentralMCe,
+ kHistNsigmaTPCTOFUsedCentralMCmu,
+ kHistNsigmaTPCTOFUsedCentralMCpi,
+ kHistNsigmaTPCTOFUsedCentralMCk,
+ kHistNsigmaTPCTOFUsedCentralMCp,
+ kHistNsigmaTPCTOFUsedCentralMCd,
+
+ kHistNsigmaTPCTOFUsedSemiCentralMCe,
+ kHistNsigmaTPCTOFUsedSemiCentralMCmu,
+ kHistNsigmaTPCTOFUsedSemiCentralMCpi,
+ kHistNsigmaTPCTOFUsedSemiCentralMCk,
+ kHistNsigmaTPCTOFUsedSemiCentralMCp,
+ kHistNsigmaTPCTOFUsedSemiCentralMCd,
+
kHistEvPlane,
kHistEvPlaneUsed,
- kHistJetPt,
+ kHistEvPlaneCheck,
+ kHistEvPlaneCheckUsed,
+ kHistEvPlane3,
+ kHistEvPlaneCorr,
+ kHistEvPlaneCorrNoTrgJets,
+ kHistEvPlaneCorrNoTrgJetsTrgd,
+ kHistJetPtCentral,
+ kHistJetPtSemi,
kHistEtaPhiTrgHad,
kHistEtaPhiTrgJet,
kHistEtaPhiAssHad,
kHistEtaPhiAssProt,
+ kHistPhiTrgJetEvPlane,
+ kHistPhiTrgHadEvPlane,
+ kHistPhiRndTrgJetEvPlane,
+ kHistPhiRndTrgHadEvPlane,
+ kHistPhiAssHadEvPlane,
+ kHistPhiAssHadVsEvPlane,
+ kHistPhiAssProtEvPlane,
+ kHistPhiTrgJetEvPlane3,
+ kHistPhiTrgHadEvPlane3,
+ kHistPhiAssHadEvPlane3,
+ kHistPhiAssProtEvPlane3,
kHistLast
};
enum Stat_t {
kStatSeen = 1,
kStatTrg,
- kStatUsed,
+ kStatVtx,
kStatCent,
kStatEvPlane,
kStatPID,
+ kStatUsed,
kStatEvCuts,
+ kStatCentral,
+ kStatSemiCentral,
kStatLast
};
// trigger conditions
- enum Trigger_t {
+ enum Trigger_t {
kTriggerMB = 0,
kTriggerInt,
kTriggerLast
- };
+ };
// classification
enum CorrType_t {
kCorrHadProt,
kCorrJetHad,
kCorrJetProt,
+
+ kCorrRndHadHad,
+ kCorrRndHadProt,
+ kCorrRndJetHad,
+ kCorrRndJetProt,
+
+ kCorrRndHadExcHad,
+ kCorrRndHadExcProt,
+ kCorrRndJetExcHad,
+ kCorrRndJetExcProt,
+
kCorrLast
};
enum Class_t {
kClCentral = 0,
kClSemiCentral,
- kClDijet,
+ // kClDijet,
kClLast
};
enum Trg_t {
kTrgHad = 0,
kTrgJet,
+ kTrgHadRnd,
+ kTrgJetRnd,
kTrgLast
};
enum Ass_t {
- kAssHad,
+ kAssHad = 0,
kAssProt,
+ kAssHadJetExc,
+ kAssProtJetExc,
+ kAssHadHadExc,
+ kAssProtHadExc,
kAssLast
};
kEvLast
};
+ class AliPartCorr : public AliVParticle {
+ public:
+ AliPartCorr(Float_t eta = 0., Float_t phi = 0., Float_t pt = 0., Float_t charge = 0) :
+ fPt(pt), fEta(eta), fPhi(phi), fCharge(charge) {}
+ AliPartCorr(const AliVParticle &rhs) :
+ fPt(rhs.Pt()), fEta(rhs.Eta()), fPhi(rhs.Phi()), fCharge(rhs.Charge()) {}
+ virtual ~AliPartCorr() {}
+
+ // kinematics
+ virtual Double_t Px() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t Py() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t Pz() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t Pt() const { return fPt; }
+ virtual Double_t P() const { AliFatal("not implemented"); return 0; }
+ virtual Bool_t PxPyPz(Double_t[3]) const { AliFatal("not implemented"); return 0; }
+
+ virtual Double_t Xv() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t Yv() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t Zv() const { AliFatal("not implemented"); return 0; }
+ virtual Bool_t XvYvZv(Double_t[3]) const { AliFatal("not implemented"); return 0; }
+
+ virtual Double_t OneOverPt() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t Phi() const { return fPhi; }
+ virtual Double_t Theta() const { AliFatal("not implemented"); return 0; }
+
+ virtual Double_t E() const { AliFatal("not implemented"); return 0; }
+ virtual Double_t M() const { AliFatal("not implemented"); return 0; }
+
+ virtual Double_t Eta() const { return fEta; }
+ virtual Double_t Y() const { AliFatal("not implemented"); return 0; }
+
+ virtual Short_t Charge() const { return fCharge; }
+ virtual Int_t GetLabel() const { AliFatal("not implemented"); return 0; }
+
+ virtual Int_t PdgCode() const { AliFatal("not implemented"); return 0; }
+ virtual const Double_t *PID() const { AliFatal("not implemented"); return 0; }
+
+ protected:
+ Float_t fPt;
+ Float_t fEta;
+ Float_t fPhi;
+ Short_t fCharge;
+
+ ClassDef(AliPartCorr, 1);
+ };
+
class AliHistCorr : public TNamed {
public:
AliHistCorr(TString name, TList *outputList = 0x0);
~AliHistCorr();
- void Trigger(Float_t weight = 1.) { fHistStat->Fill(1., weight); }
+ void Trigger(Float_t phi, Float_t eta, Float_t weight = 1.) {
+ fHistStat->Fill(1., weight);
+ if (fHistCorrTrgEtaPhi)
+ fHistCorrTrgEtaPhi->Fill(phi, eta, weight);
+ }
+ void Ass(Float_t phi, Float_t eta, Float_t weight = 1.) {
+ if (fHistCorrAssEtaPhi)
+ fHistCorrAssEtaPhi->Fill(phi, eta, weight);
+ }
void Fill(AliVParticle *trgPart, AliVParticle *assPart, Float_t weight = 1.);
+ void Fill(TLorentzVector *trgPart, AliVParticle *assPart, Float_t weight = 1.);
+ void Fill(TLorentzVector *trgPart, TLorentzVector *assPart, Float_t weight = 1.);
protected:
TList *fOutputList;
TH1F *fHistCorrPhi;
TH2F *fHistCorrPhi2;
TH2F *fHistCorrEtaPhi;
+ TH2F *fHistCorrAvgEtaPhi;
+ TH2F *fHistCorrTrgEtaPhi;
+ TH2F *fHistCorrAssEtaPhi;
+
+ const Float_t fHistDphiLo;
+ const Int_t fHistDphiNbins;
+ const Int_t fHistDetaNbins;
AliHistCorr(const AliHistCorr &rhs);
AliHistCorr& operator=(const AliHistCorr &rhs);
};
AliHistCorr*& GetHistCorr(CorrType_t corr, Class_t cl, Ev_t ev) { return fHistCorr[kEvLast*(kClLast*corr + cl) + ev]; }
- AliEventPoolManager*& GetPoolMgr(Trg_t trg, Ass_t ass) { return fPoolMgr[kTrgLast * ass + trg]; }
- AliEventPool*& GetPool(Class_t cls, Trg_t trg, Ass_t ass) { return fPool[kClLast * (kTrgLast * ass + trg) + cls]; }
+ AliEventPoolManager*& GetPoolMgr(Ass_t ass) { return fPoolMgr[ass]; }
+ AliEventPool*& GetPool(Ass_t ass) { return fPool[ass]; }
protected:
AliMCEvent *fMCEvent; //!
AliESDEvent *fESDEvent; //!
AliAODEvent *fAODEvent; //!
+ Int_t fRunNumber; //! current run number
+ AliOADBContainer *fOADBContainerTOF; //! container for OADB entry with TOF parameters
+ AliTOFPIDParams *fParamsTOF; //! TOF parametrization
+
+ AliEventplane *fEventplane; //! pointer to the event plane
+
UInt_t fTriggerMask; //! internal representation of trigger conditions
UInt_t fClassMask; //! internal representation of event classes
Float_t fCentrality; //!
Float_t fCentralityCheck; //!
Float_t fZvtx; //!
AliPIDResponse *fPIDResponse; //!
- Float_t fEventPlane; //!
- TObjArray *fPrimTrackArray; //!
+ Float_t fEventPlaneAngle; //!
+ Float_t fEventPlaneAngleCheck; //!
+ Float_t fEventPlaneAngle3; //!
+
+ TObjArray *fPrimTrackArrayAss; //!
+ TObjArray *fPrimTrackArrayTrg; //!
+ TClonesArray *fPrimConstrainedTrackArray; //!
TClonesArray *fJetArray; //!
- AliEventPoolManager *fPoolMgr[kTrgLast * kAssLast]; //!
- AliEventPool *fPool[kClLast * kTrgLast * kAssLast]; //!
+ AliEventPoolManager *fPoolMgr[kAssProt + 1]; //!
+ AliEventPool *fPool[kAssProt + 1]; //!
AliHistCorr **fHistCorr; //! [kCorrLast*kEvLast*kClLast]; //!
+ Int_t fErrorMsg; //! remaining number of error messages to be printed
+
Bool_t DetectTriggers();
void MarkTrigger(Trigger_t trg) { fTriggerMask |= (1 << trg); }
Bool_t IsTrigger(Trigger_t trg) const { return (fTriggerMask & (1 << trg)); }
Bool_t CleanUpEvent();
Float_t GetCentrality() const { return fCentrality; }
- Float_t GetEventPlane() const { return fEventPlane; }
+ Float_t GetEventPlaneAngle() const { return fEventPlaneAngle; }
AliPIDResponse* GetPID() const { return fPIDResponse; }
- Bool_t IsCentral() { return ((fCentrality >= 0.) && (fCentrality <= 10.)); }
- Bool_t IsSemiCentral() { return ((fCentrality >= 30.) && (fCentrality <= 50.)); }
+ Bool_t IsCentral() const { return ((fCentrality >= 0.) && (fCentrality <= 10.)); }
+ Bool_t IsSemiCentral() const { return ((fCentrality >= 30.) && (fCentrality <= 50.)); }
+
+ AliVTrack* GetLeadingTrack(const AliAODJet *jet) const;
- Bool_t AcceptTrigger(AliVTrack *trg);
- Bool_t AcceptTrigger(AliAODJet *trg);
- Bool_t AcceptAssoc(AliVTrack *ass);
- Bool_t IsProton(AliVTrack *trk);
+ Float_t GetDPhiStar(Float_t phi1, Float_t pt1, Float_t charge1,
+ Float_t phi2, Float_t pt2, Float_t charge2,
+ Float_t radius, Float_t bSign) const;
+
+ Bool_t AcceptTrigger(const AliVTrack *trg);
+ Bool_t AcceptTrigger(const AliAODJet *trg);
+ Bool_t AcceptAssoc(const AliVTrack *trk) const;
+ Bool_t IsProton(const AliVTrack *trk) const;
+ Bool_t AcceptAngleToEvPlane(Float_t phi, Float_t psi) const;
+ Bool_t AcceptTwoTracks(const AliVParticle *trgPart, const AliVParticle *assPart) const;
TObjArray* CloneTracks(TObjArray *tracks) const;
+ Bool_t GenerateRandom(TCollection *trgJetArray, TCollection *trgHadArray,
+ TCollection *assHadJetArray, TCollection *assProtJetArray,
+ TCollection *assHadHadArray, TCollection *assProtHadArray,
+ Float_t pFraction = .5);
+
Bool_t Correlate(CorrType_t corr, Class_t cl, Ev_t ev,
TCollection *trgArray, TCollection *assArray, Float_t weight = 1.);
static const Int_t fgkStringLength = 100; // max length for the jet branch name
char fJetBranchName[fgkStringLength]; // jet branch name
- AliESDtrackCuts *fCutsPrim; // track cuts for primary particles
+ const Bool_t fUseStandardCuts;
+ Bool_t fUseEvplaneV0;
+
+ AliESDtrackCuts *fCutsPrimTrg; // track cuts for primary particles (trigger)
+ AliESDtrackCuts *fCutsPrimTrgConstrain; // track cuts for primary particles (trigger)
+ AliESDtrackCuts *fCutsPrimAss; // track cuts for primary particles (associate)
+ Float_t fCutsTwoTrackEff;
+ UInt_t fAssFilterMask;
+ Bool_t fRequirePID;
+ Float_t fTrgJetEtaMax;
+ Float_t fHadEtaMax;
Float_t fTrgPartPtMin;
Float_t fTrgPartPtMax;
Float_t fTrgJetPtMin;
Float_t fTrgJetPtMax;
+ Float_t fTrgJetLeadTrkPtMin;
+ Float_t fTrgJetLeadTrkPtMax;
+ Float_t fTrgJetAreaMin;
Float_t fAssPartPtMin;
Float_t fAssPartPtMax;
+ Float_t fTrgAngleToEvPlane;
+
+ Float_t fToyMeanNoPart;
+ Float_t fToyRadius;
+ Float_t fToySmearPhi;
+
+ TF1 *fTrgJetPhiModCent;
+ TF1 *fTrgJetPhiModSemi;
+ TF1 *fTrgHadPhiModCent;
+ TF1 *fTrgHadPhiModSemi;
// not implemented
AliAnalysisTaskJetProtonCorr(const AliAnalysisTaskJetProtonCorr &rhs);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff