[u/mrichter/AliRoot.git] / PWGJE / UserTasks / AliAnalysisTaskJetProtonCorr.h

#include "TH1.h"
#include "TH2.h"
#include "TH3.h"

#include "AliLog.h"

#include "AliAnalysisTaskSE.h"
#include "AliESDtrackCuts.h"

#define ID(x) x, #x
#define LAB(x) x + 1, #x

class TF1;
class TList;
class TClonesArray;
class AliOADBContainer;
class AliTOFPIDParams;
class AliVParticle;
class AliVTrack;
class AliPIDResponse;
class AliEventPoolManager;
class AliEventPool;
class AliEventplane;

class AliAnalysisTaskJetProtonCorr :
  public AliAnalysisTaskSE
{
public:
  AliAnalysisTaskJetProtonCorr(const char *name = "jets_trg_trd");
  ~AliAnalysisTaskJetProtonCorr();

  // analysis operations
  virtual void   UserCreateOutputObjects();
  virtual Bool_t Notify();
  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-1); }
  const char* GetJetBranchName() const { return fJetBranchName; }

  void SetPtThrPart(Float_t minPt, Float_t maxPt) { fTrgPartPtMin = minPt; fTrgPartPtMax = maxPt; }
  Float_t GetPtMinPart() const { return fTrgPartPtMin; }
  Float_t GetPtMaxPart() const { return fTrgPartPtMax; }
  void SetPtThrJet(Float_t minPt, Float_t maxPt) { fTrgJetPtMin = minPt; fTrgJetPtMax = maxPt; }
  Float_t GetPtMinJet() const { return fTrgJetPtMin; }
  Float_t GetPtMaxJet() const { return fTrgJetPtMax; }
  void SetPtThrAss(Float_t minPt, Float_t maxPt) { fAssPartPtMin = minPt; fAssPartPtMax = maxPt; }
  Float_t GetPtMinAss() const { return fAssPartPtMin; }
  Float_t GetPtMaxAss() const { return fAssPartPtMax; }

  void SetTrackCutsAss(AliESDtrackCuts cuts) { *fCutsPrimAss = cuts; }
  void SetTrackCutsTrg(AliESDtrackCuts cuts) { *fCutsPrimTrg = cuts; }
  void SetTrackCutsTrgConstrain(AliESDtrackCuts cuts) { *fCutsPrimTrgConstrain = cuts; }

  void SetUseEvplaneV0(Bool_t usev0 = kTRUE) { fUseEvplaneV0 = usev0; }
  Bool_t GetUseEvplaneV0() const { return fUseEvplaneV0; }

  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,

      kHistEvPlane,
      kHistEvPlaneUsed,
      kHistEvPlaneCheck,
      kHistEvPlaneCheckUsed,
      kHistEvPlane3,
      kHistEvPlaneCorr,
      kHistEvPlaneCorrNoTrgJets,
      kHistEvPlaneCorrNoTrgJetsTrgd,
      kHistJetPtCentral,
      kHistJetPtSemi,
      kHistEtaPhiTrgHad,
      kHistEtaPhiTrgJet,
      kHistEtaPhiAssHad,
      kHistEtaPhiAssProt,
      kHistPhiTrgJetEvPlane,
      kHistPhiTrgHadEvPlane,
      kHistPhiAssHadEvPlane,
      kHistPhiAssHadVsEvPlane,
      kHistPhiAssProtEvPlane,
      kHistPhiTrgJetEvPlane3,
      kHistPhiTrgHadEvPlane3,
      kHistPhiAssHadEvPlane3,
      kHistPhiAssProtEvPlane3,
      kHistLast
  };

  // statistics
  enum Stat_t {
      kStatSeen = 1,
      kStatTrg,
      kStatVtx,
      kStatCent,
      kStatEvPlane,
      kStatPID,
      kStatUsed,
      kStatEvCuts,
      kStatCentral,
      kStatSemiCentral,
      kStatLast
  };

  // trigger conditions
  enum Trigger_t {
      kTriggerMB = 0,
      kTriggerInt,
      kTriggerLast
  };

  // classification
  enum CorrType_t {
    kCorrHadHad = 0,
    kCorrHadProt,
    kCorrJetHad,
    kCorrJetProt,

    kCorrRndJetHad,
    kCorrRndJetProt,
    kCorrRndHadHad,
    kCorrRndHadProt,

    kCorrRndJetExcHad,
    kCorrRndJetExcProt,
    kCorrRndHadExcHad,
    kCorrRndHadExcProt,

    kCorrLast
  };

  enum Class_t {
    kClCentral = 0,
    kClSemiCentral,
    // kClDijet,
    kClLast
  };

  enum Trg_t {
    kTrgHad = 0,
    kTrgJet,
    kTrgHadRnd,
    kTrgJetRnd,
    kTrgLast
  };

  enum Ass_t {
    kAssHad = 0,
    kAssProt,
    kAssHadJetExc,
    kAssProtJetExc,
    kAssHadHadExc,
    kAssProtHadExc,
    kAssLast
  };

  enum Ev_t {
    kEvSame = 0,
    kEvMix,
    kEvLast
  };

  class AliHistCorr : public TNamed {
  public:
    AliHistCorr(TString name, TList *outputList = 0x0);
    ~AliHistCorr();

    void Trigger(Float_t phi, Float_t eta, Float_t weight = 1.) { fHistStat->Fill(1., weight); fHistCorrTrgEtaPhi->Fill(phi, eta, weight); }
    void Ass(Float_t phi, Float_t eta, Float_t weight = 1.) { 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 *fHistStat;

    TH1F *fHistCorrPhi;
    TH2F *fHistCorrPhi2;
    TH2F *fHistCorrEtaPhi;
    TH2F *fHistCorrAvgEtaPhi;
    TH2F *fHistCorrTrgEtaPhi;
    TH2F *fHistCorrAssEtaPhi;

    AliHistCorr(const AliHistCorr &rhs);
    AliHistCorr& operator=(const AliHistCorr &rhs);

    ClassDef(AliHistCorr, 1);
  };

  AliHistCorr*& GetHistCorr(CorrType_t corr, Class_t cl, Ev_t ev) { return fHistCorr[kEvLast*(kClLast*corr + cl) + ev]; }
  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 fEventPlaneAngle; //!
  Float_t fEventPlaneAngleCheck; //!
  Float_t fEventPlaneAngle3; //!

  TObjArray *fPrimTrackArrayAss; //!
  TObjArray *fPrimTrackArrayTrg; //!
  TClonesArray *fPrimConstrainedTrackArray; //!
  TClonesArray *fJetArray; //!

  AliEventPoolManager *fPoolMgr[kAssProt + 1]; //!
  AliEventPool *fPool[kAssProt + 1]; //!

  AliHistCorr **fHistCorr; //! [kCorrLast*kEvLast*kClLast]; //!

  Bool_t DetectTriggers();
  void   MarkTrigger(Trigger_t trg) { fTriggerMask |= (1 << trg); }
  Bool_t IsTrigger(Trigger_t trg) const { return (fTriggerMask & (1 << trg)); }

  Bool_t DetectClasses();
  void   MarkClass(Class_t cl) { fClassMask |= (1 << cl); }
  Bool_t IsClass(Class_t cl) const { return (fClassMask & (1 << cl)); }

  Bool_t PrepareEvent();
  Bool_t CleanUpEvent();

  Float_t GetCentrality() const { return fCentrality; }
  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.)); }

  AliVTrack* GetLeadingTrack(AliAODJet *jet) const;

  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);

  Bool_t AcceptTrigger(AliVTrack *trg);
  Bool_t AcceptTrigger(AliAODJet *trg);
  Bool_t AcceptAssoc(AliVTrack *trk);
  Bool_t IsProton(AliVTrack *trk);
  Bool_t AcceptAngleToEvPlane(Float_t phi, Float_t psi);
  Bool_t AcceptTwoTracks(AliVParticle *trgPart, AliVParticle *assPart);

  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.);

  Bool_t Correlate(Trg_t trg, Ass_t ass, Class_t cl, Ev_t ev,
		   TCollection *trgArray, TCollection *assArray, Float_t weight = 1.);

  // output objects
  TList *fOutputList;		//! list of output objects

  // histogram management
  TH1  *fHist[kHistLast];	//! pointers to histogram
  const char *fShortTaskId;	//! short identifier for the task

  TH1*&  GetHistogram(Hist_t hist, const Int_t idx = 0) { return fHist[hist + idx]; }

  TH1*   AddHistogram(Hist_t hist, const char *hid, TString title,
                      Int_t xbins, Float_t xmin, Float_t xmax, Int_t binType = 1);
  TH2*   AddHistogram(Hist_t hist, const char *hid, TString title,
                      Int_t xbins, Float_t xmin, Float_t xmax,
                      Int_t ybins, Float_t ymin, Float_t ymax, Int_t binType = 1);
  TH3*   AddHistogram(Hist_t hist, const char *hid, TString title,
                      Int_t xbins, Float_t xmin, Float_t xmax,
                      Int_t ybins, Float_t ymin, Float_t ymax,
                      Int_t zbins, Float_t zmin, Float_t zmax, Int_t binType = 1);

  void    FillH1(Hist_t hist, Float_t x, Float_t weight = 1., Int_t idx = 0)
  { GetHistogram(hist, idx)->Fill(x, weight); }
  void    FillH2(Hist_t hist, Float_t x, Float_t y, Float_t weight = 1., Int_t idx = 0)
  { ((TH2*) GetHistogram(hist, idx))->Fill(x, y, weight); }
  void    FillH3(Hist_t hist, Float_t x, Float_t y, Float_t z, Float_t weight = 1., Int_t idx = 0)
  { ((TH3*) GetHistogram(hist, idx))->Fill(x, y, z, weight); }

  const char* fkCorrTypeName[kCorrLast]; //!
  const char* fkClassName[kClLast]; //!
  const char* fkEvName[kEvLast]; //!

  // task configuration
  static const Int_t fgkStringLength = 100; // max length for the jet branch name
  char fJetBranchName[fgkStringLength];     // jet branch name

  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;

  Float_t fTrgPartPtMin;
  Float_t fTrgPartPtMax;
  Float_t fTrgJetPtMin;
  Float_t fTrgJetPtMax;
  Float_t fTrgJetLeadTrkPtMin;
  Float_t fAssPartPtMin;
  Float_t fAssPartPtMax;
  Float_t fTrgAngleToEvPlane;

  TF1 *fTrgJetPhiModCent;
  TF1 *fTrgJetPhiModSemi;
  TF1 *fTrgHadPhiModCent;
  TF1 *fTrgHadPhiModSemi;

  // not implemented
  AliAnalysisTaskJetProtonCorr(const AliAnalysisTaskJetProtonCorr &rhs);
  AliAnalysisTaskJetProtonCorr& operator=(const AliAnalysisTaskJetProtonCorr &rhs);

  ClassDef(AliAnalysisTaskJetProtonCorr, 1);
};
Commit	Line	Data
23536a91	1	#include "TH1.h"
	2	#include "TH2.h"
	3	#include "TH3.h"
	4
	5	#include "AliLog.h"
	6
	7	#include "AliAnalysisTaskSE.h"
a4c7ef28	8	#include "AliESDtrackCuts.h"
23536a91	9
	10	#define ID(x) x, #x
	11	#define LAB(x) x + 1, #x
	12
ebdf1dbb	13	class TF1;
23536a91	14	class TList;
23536a91	15	class TClonesArray;
ebdf1dbb	16	class AliOADBContainer;
ebdf1dbb	17	class AliTOFPIDParams;
23536a91	18	class AliVParticle;
	19	class AliVTrack;
	20	class AliPIDResponse;
	21	class AliEventPoolManager;
	22	class AliEventPool;
ebdf1dbb	23	class AliEventplane;
23536a91	24
	25	class AliAnalysisTaskJetProtonCorr :
	26	public AliAnalysisTaskSE
	27	{
	28	public:
	29	AliAnalysisTaskJetProtonCorr(const char *name = "jets_trg_trd");
	30	~AliAnalysisTaskJetProtonCorr();
	31
	32	// analysis operations
	33	virtual void UserCreateOutputObjects();
	34	virtual Bool_t Notify();
	35	virtual void UserExec(Option_t *option);
	36	virtual void Terminate(const Option_t *option);
	37
ebdf1dbb	38	void SetParamsTOF();
ebdf1dbb	39
23536a91	40	// task configuration
2751fb9a	41	void SetJetBranchName(const char* const branchName) { strncpy(fJetBranchName, branchName, fgkStringLength-1); }
23536a91	42	const char* GetJetBranchName() const { return fJetBranchName; }
	43
	44	void SetPtThrPart(Float_t minPt, Float_t maxPt) { fTrgPartPtMin = minPt; fTrgPartPtMax = maxPt; }
	45	Float_t GetPtMinPart() const { return fTrgPartPtMin; }
	46	Float_t GetPtMaxPart() const { return fTrgPartPtMax; }
	47	void SetPtThrJet(Float_t minPt, Float_t maxPt) { fTrgJetPtMin = minPt; fTrgJetPtMax = maxPt; }
	48	Float_t GetPtMinJet() const { return fTrgJetPtMin; }
	49	Float_t GetPtMaxJet() const { return fTrgJetPtMax; }
	50	void SetPtThrAss(Float_t minPt, Float_t maxPt) { fAssPartPtMin = minPt; fAssPartPtMax = maxPt; }
	51	Float_t GetPtMinAss() const { return fAssPartPtMin; }
	52	Float_t GetPtMaxAss() const { return fAssPartPtMax; }
	53
a4c7ef28	54	void SetTrackCutsAss(AliESDtrackCuts cuts) { *fCutsPrimAss = cuts; }
	55	void SetTrackCutsTrg(AliESDtrackCuts cuts) { *fCutsPrimTrg = cuts; }
	56	void SetTrackCutsTrgConstrain(AliESDtrackCuts cuts) { *fCutsPrimTrgConstrain = cuts; }
	57
	58	void SetUseEvplaneV0(Bool_t usev0 = kTRUE) { fUseEvplaneV0 = usev0; }
	59	Bool_t GetUseEvplaneV0() const { return fUseEvplaneV0; }
	60
3082e8ab	61	void PrintTask(Option_t *option, Int_t indent) const;
	62
	63	static Double_t TOFsignal(Double_t x, Double_t par)
	64	{
	65	Double_t norm = par[0];
	66	Double_t mean = par[1];
	67	Double_t sigma = par[2];
	68	Double_t tail = par[3];
	69
	70	if (x[0] <= (tail + mean))
	71	return norm * TMath::Gaus(x[0], mean, sigma);
	72	else
	73	return norm * TMath::Gaus(tail + mean, mean, sigma) * TMath::Exp(-tail * (x[0] - tail - mean) / (sigma * sigma));
	74	}
	75
23536a91	76	// histograms
	77	enum Hist_t {
	78	kHistStat = 0,
ebdf1dbb	79	kHistVertexNctb,
ebdf1dbb	80	kHistVertexZ,
23536a91	81	kHistCentrality,
	82	kHistCentralityUsed,
	83	kHistCentralityCheck,
	84	kHistCentralityCheckUsed,
ebdf1dbb	85	kHistCentralityVsMult,
3082e8ab	86	kHistSignalTPC,
	87	kHistSignalTOF,
	88	kHistBetaTOF,
	89	kHistDeltaTPC,
	90	kHistDeltaTPCSemi,
	91	kHistDeltaTOF,
	92	kHistDeltaTOFSemi,
ebdf1dbb	93	// kHistExpSigmaTOFe,
	94	// kHistExpSigmaTOFmu,
	95	// kHistExpSigmaTOFpi,
	96	// kHistExpSigmaTOFk,
	97	// kHistExpSigmaTOFp,
	98	// kHistExpSigmaTOFd,
	99	// kHistExpSigmaTOFeSemi,
	100	// kHistExpSigmaTOFmuSemi,
	101	// kHistExpSigmaTOFpiSemi,
	102	// kHistExpSigmaTOFkSemi,
	103	// kHistExpSigmaTOFpSemi,
	104	// kHistExpSigmaTOFdSemi,
	105	// kHistCmpSigmaTOFe,
	106	// kHistCmpSigmaTOFmu,
	107	// kHistCmpSigmaTOFpi,
	108	// kHistCmpSigmaTOFk,
	109	// kHistCmpSigmaTOFp,
	110	// kHistCmpSigmaTOFd,
	111	// kHistCmpSigmaTOFeSemi,
	112	// kHistCmpSigmaTOFmuSemi,
	113	// kHistCmpSigmaTOFpiSemi,
	114	// kHistCmpSigmaTOFkSemi,
	115	// kHistCmpSigmaTOFpSemi,
	116	// kHistCmpSigmaTOFdSemi,
3082e8ab	117	kHistNsigmaTPCe,
	118	kHistNsigmaTPCmu,
	119	kHistNsigmaTPCpi,
	120	kHistNsigmaTPCk,
	121	kHistNsigmaTPCp,
	122	kHistNsigmaTPCd,
	123	kHistNsigmaTPCe_e,
	124	kHistNsigmaTOFe,
	125	kHistNsigmaTOFmu,
	126	kHistNsigmaTOFpi,
	127	kHistNsigmaTOFk,
	128	kHistNsigmaTOFp,
	129	kHistNsigmaTOFd,
	130	kHistNsigmaTOFmismatch,
3082e8ab	131	kHistDeltaTOFe,
	132	kHistDeltaTOFmu,
	133	kHistDeltaTOFpi,
	134	kHistDeltaTOFk,
	135	kHistDeltaTOFp,
	136	kHistDeltaTOFd,
ebdf1dbb	137
3082e8ab	138	kHistNsigmaTPCeSemi,
	139	kHistNsigmaTPCmuSemi,
	140	kHistNsigmaTPCpiSemi,
	141	kHistNsigmaTPCkSemi,
	142	kHistNsigmaTPCpSemi,
	143	kHistNsigmaTPCdSemi,
	144	kHistNsigmaTPCe_eSemi,
	145	kHistNsigmaTOFeSemi,
	146	kHistNsigmaTOFmuSemi,
	147	kHistNsigmaTOFpiSemi,
	148	kHistNsigmaTOFkSemi,
	149	kHistNsigmaTOFpSemi,
	150	kHistNsigmaTOFdSemi,
	151	kHistNsigmaTOFmismatchSemi,
3082e8ab	152	kHistDeltaTOFeSemi,
	153	kHistDeltaTOFmuSemi,
	154	kHistDeltaTOFpiSemi,
	155	kHistDeltaTOFkSemi,
	156	kHistDeltaTOFpSemi,
	157	kHistDeltaTOFdSemi,
ebdf1dbb	158
23536a91	159	kHistNsigmaTPCTOF,
3082e8ab	160	kHistNsigmaTPCTOFPt,
	161	kHistNsigmaTPCTOFUsed,
	162	kHistNsigmaTPCTOFUsedCentral,
	163	kHistNsigmaTPCTOFUsedSemiCentral,
	164	kHistNsigmaTPCTOFUsedPt,
	165	kHistNsigmaTPCTOFUsedPtCentral,
	166	kHistNsigmaTPCTOFUsedPtSemiCentral,
ebdf1dbb	167
23536a91	168	kHistEvPlane,
23536a91	169	kHistEvPlaneUsed,
3082e8ab	170	kHistEvPlaneCheck,
3082e8ab	171	kHistEvPlaneCheckUsed,
a4c7ef28	172	kHistEvPlane3,
3082e8ab	173	kHistEvPlaneCorr,
ebdf1dbb	174	kHistEvPlaneCorrNoTrgJets,
ebdf1dbb	175	kHistEvPlaneCorrNoTrgJetsTrgd,
3082e8ab	176	kHistJetPtCentral,
3082e8ab	177	kHistJetPtSemi,
23536a91	178	kHistEtaPhiTrgHad,
	179	kHistEtaPhiTrgJet,
	180	kHistEtaPhiAssHad,
	181	kHistEtaPhiAssProt,
ebdf1dbb	182	kHistPhiTrgJetEvPlane,
	183	kHistPhiTrgHadEvPlane,
	184	kHistPhiAssHadEvPlane,
	185	kHistPhiAssHadVsEvPlane,
	186	kHistPhiAssProtEvPlane,
a4c7ef28	187	kHistPhiTrgJetEvPlane3,
	188	kHistPhiTrgHadEvPlane3,
	189	kHistPhiAssHadEvPlane3,
	190	kHistPhiAssProtEvPlane3,
23536a91	191	kHistLast
	192	};
	193
	194	// statistics
	195	enum Stat_t {
	196	kStatSeen = 1,
	197	kStatTrg,
ebdf1dbb	198	kStatVtx,
23536a91	199	kStatCent,
	200	kStatEvPlane,
	201	kStatPID,
3082e8ab	202	kStatUsed,
23536a91	203	kStatEvCuts,
3082e8ab	204	kStatCentral,
3082e8ab	205	kStatSemiCentral,
23536a91	206	kStatLast
	207	};
	208
	209	// trigger conditions
3082e8ab	210	enum Trigger_t {
23536a91	211	kTriggerMB = 0,
	212	kTriggerInt,
	213	kTriggerLast
3082e8ab	214	};
23536a91	215
	216	// classification
	217	enum CorrType_t {
	218	kCorrHadHad = 0,
	219	kCorrHadProt,
	220	kCorrJetHad,
	221	kCorrJetProt,
ebdf1dbb	222
	223	kCorrRndJetHad,
	224	kCorrRndJetProt,
	225	kCorrRndHadHad,
	226	kCorrRndHadProt,
	227
	228	kCorrRndJetExcHad,
	229	kCorrRndJetExcProt,
	230	kCorrRndHadExcHad,
	231	kCorrRndHadExcProt,
	232
23536a91	233	kCorrLast
	234	};
	235
	236	enum Class_t {
	237	kClCentral = 0,
	238	kClSemiCentral,
2751fb9a	239	// kClDijet,
23536a91	240	kClLast
	241	};
	242
	243	enum Trg_t {
	244	kTrgHad = 0,
	245	kTrgJet,
ebdf1dbb	246	kTrgHadRnd,
ebdf1dbb	247	kTrgJetRnd,
23536a91	248	kTrgLast
	249	};
	250
	251	enum Ass_t {
ebdf1dbb	252	kAssHad = 0,
23536a91	253	kAssProt,
ebdf1dbb	254	kAssHadJetExc,
	255	kAssProtJetExc,
	256	kAssHadHadExc,
	257	kAssProtHadExc,
23536a91	258	kAssLast
	259	};
	260
	261	enum Ev_t {
	262	kEvSame = 0,
	263	kEvMix,
	264	kEvLast
	265	};
	266
	267	class AliHistCorr : public TNamed {
	268	public:
	269	AliHistCorr(TString name, TList *outputList = 0x0);
	270	~AliHistCorr();
	271
ebdf1dbb	272	void Trigger(Float_t phi, Float_t eta, Float_t weight = 1.) { fHistStat->Fill(1., weight); fHistCorrTrgEtaPhi->Fill(phi, eta, weight); }
ebdf1dbb	273	void Ass(Float_t phi, Float_t eta, Float_t weight = 1.) { fHistCorrAssEtaPhi->Fill(phi, eta, weight); }
23536a91	274	void Fill(AliVParticle trgPart, AliVParticle assPart, Float_t weight = 1.);
ebdf1dbb	275	void Fill(TLorentzVector trgPart, AliVParticle assPart, Float_t weight = 1.);
ebdf1dbb	276	void Fill(TLorentzVector trgPart, TLorentzVector assPart, Float_t weight = 1.);
23536a91	277
	278	protected:
	279	TList *fOutputList;
	280
	281	TH1F *fHistStat;
	282
	283	TH1F *fHistCorrPhi;
	284	TH2F *fHistCorrPhi2;
	285	TH2F *fHistCorrEtaPhi;
ebdf1dbb	286	TH2F *fHistCorrAvgEtaPhi;
	287	TH2F *fHistCorrTrgEtaPhi;
	288	TH2F *fHistCorrAssEtaPhi;
23536a91	289
	290	AliHistCorr(const AliHistCorr &rhs);
	291	AliHistCorr& operator=(const AliHistCorr &rhs);
	292
	293	ClassDef(AliHistCorr, 1);
	294	};
	295
	296	AliHistCorr& GetHistCorr(CorrType_t corr, Class_t cl, Ev_t ev) { return fHistCorr[kEvLast(kClLast*corr + cl) + ev]; }
2751fb9a	297	AliEventPoolManager*& GetPoolMgr(Ass_t ass) { return fPoolMgr[ass]; }
2751fb9a	298	AliEventPool*& GetPool(Ass_t ass) { return fPool[ass]; }
23536a91	299
	300	protected:
	301	AliMCEvent *fMCEvent; //!
	302	AliESDEvent *fESDEvent; //!
	303	AliAODEvent *fAODEvent; //!
	304
ebdf1dbb	305	Int_t fRunNumber; //! current run number
	306	AliOADBContainer *fOADBContainerTOF; //! container for OADB entry with TOF parameters
	307	AliTOFPIDParams *fParamsTOF; //! TOF parametrization
	308
	309	AliEventplane *fEventplane; //! pointer to the event plane
	310
23536a91	311	UInt_t fTriggerMask; //! internal representation of trigger conditions
	312	UInt_t fClassMask; //! internal representation of event classes
	313	Float_t fCentrality; //!
	314	Float_t fCentralityCheck; //!
	315	Float_t fZvtx; //!
	316	AliPIDResponse *fPIDResponse; //!
ebdf1dbb	317	Float_t fEventPlaneAngle; //!
ebdf1dbb	318	Float_t fEventPlaneAngleCheck; //!
a4c7ef28	319	Float_t fEventPlaneAngle3; //!
	320
	321	TObjArray *fPrimTrackArrayAss; //!
	322	TObjArray *fPrimTrackArrayTrg; //!
	323	TClonesArray *fPrimConstrainedTrackArray; //!
23536a91	324	TClonesArray *fJetArray; //!
23536a91	325
2751fb9a	326	AliEventPoolManager *fPoolMgr[kAssProt + 1]; //!
2751fb9a	327	AliEventPool *fPool[kAssProt + 1]; //!
23536a91	328
	329	AliHistCorr *fHistCorr; //! [kCorrLastkEvLast*kClLast]; //!
	330
	331	Bool_t DetectTriggers();
	332	void MarkTrigger(Trigger_t trg) { fTriggerMask \|= (1 << trg); }
	333	Bool_t IsTrigger(Trigger_t trg) const { return (fTriggerMask & (1 << trg)); }
	334
	335	Bool_t DetectClasses();
	336	void MarkClass(Class_t cl) { fClassMask \|= (1 << cl); }
	337	Bool_t IsClass(Class_t cl) const { return (fClassMask & (1 << cl)); }
	338
	339	Bool_t PrepareEvent();
	340	Bool_t CleanUpEvent();
	341
	342	Float_t GetCentrality() const { return fCentrality; }
ebdf1dbb	343	Float_t GetEventPlaneAngle() const { return fEventPlaneAngle; }
23536a91	344	AliPIDResponse* GetPID() const { return fPIDResponse; }
	345	Bool_t IsCentral() { return ((fCentrality >= 0.) && (fCentrality <= 10.)); }
	346	Bool_t IsSemiCentral() { return ((fCentrality >= 30.) && (fCentrality <= 50.)); }
	347
3082e8ab	348	AliVTrack* GetLeadingTrack(AliAODJet *jet) const;
	349
	350	Float_t GetDPhiStar(Float_t phi1, Float_t pt1, Float_t charge1,
	351	Float_t phi2, Float_t pt2, Float_t charge2,
	352	Float_t radius, Float_t bSign);
	353
23536a91	354	Bool_t AcceptTrigger(AliVTrack *trg);
23536a91	355	Bool_t AcceptTrigger(AliAODJet *trg);
3082e8ab	356	Bool_t AcceptAssoc(AliVTrack *trk);
23536a91	357	Bool_t IsProton(AliVTrack *trk);
3082e8ab	358	Bool_t AcceptAngleToEvPlane(Float_t phi, Float_t psi);
3082e8ab	359	Bool_t AcceptTwoTracks(AliVParticle trgPart, AliVParticle assPart);
23536a91	360
	361	TObjArray* CloneTracks(TObjArray *tracks) const;
	362
ebdf1dbb	363	Bool_t GenerateRandom(TCollection trgJetArray, TCollection trgHadArray,
	364	TCollection assHadJetArray, TCollection assProtJetArray,
	365	TCollection assHadHadArray, TCollection assProtHadArray,
	366	Float_t pFraction = .5);
	367
23536a91	368	Bool_t Correlate(CorrType_t corr, Class_t cl, Ev_t ev,
	369	TCollection trgArray, TCollection assArray, Float_t weight = 1.);
	370
	371	Bool_t Correlate(Trg_t trg, Ass_t ass, Class_t cl, Ev_t ev,
	372	TCollection trgArray, TCollection assArray, Float_t weight = 1.);
	373
	374	// output objects
	375	TList *fOutputList; //! list of output objects
	376
	377	// histogram management
	378	TH1 *fHist[kHistLast]; //! pointers to histogram
	379	const char *fShortTaskId; //! short identifier for the task
	380
	381	TH1*& GetHistogram(Hist_t hist, const Int_t idx = 0) { return fHist[hist + idx]; }
	382
	383	TH1* AddHistogram(Hist_t hist, const char *hid, TString title,
	384	Int_t xbins, Float_t xmin, Float_t xmax, Int_t binType = 1);
	385	TH2* AddHistogram(Hist_t hist, const char *hid, TString title,
	386	Int_t xbins, Float_t xmin, Float_t xmax,
	387	Int_t ybins, Float_t ymin, Float_t ymax, Int_t binType = 1);
	388	TH3* AddHistogram(Hist_t hist, const char *hid, TString title,
	389	Int_t xbins, Float_t xmin, Float_t xmax,
	390	Int_t ybins, Float_t ymin, Float_t ymax,
	391	Int_t zbins, Float_t zmin, Float_t zmax, Int_t binType = 1);
	392
	393	void FillH1(Hist_t hist, Float_t x, Float_t weight = 1., Int_t idx = 0)
	394	{ GetHistogram(hist, idx)->Fill(x, weight); }
	395	void FillH2(Hist_t hist, Float_t x, Float_t y, Float_t weight = 1., Int_t idx = 0)
	396	{ ((TH2*) GetHistogram(hist, idx))->Fill(x, y, weight); }
	397	void FillH3(Hist_t hist, Float_t x, Float_t y, Float_t z, Float_t weight = 1., Int_t idx = 0)
	398	{ ((TH3*) GetHistogram(hist, idx))->Fill(x, y, z, weight); }
	399
	400	const char* fkCorrTypeName[kCorrLast]; //!
	401	const char* fkClassName[kClLast]; //!
	402	const char* fkEvName[kEvLast]; //!
	403
	404	// task configuration
	405	static const Int_t fgkStringLength = 100; // max length for the jet branch name
	406	char fJetBranchName[fgkStringLength]; // jet branch name
	407
3082e8ab	408	Bool_t fUseStandardCuts;
a4c7ef28	409	Bool_t fUseEvplaneV0;
3082e8ab	410
a4c7ef28	411	AliESDtrackCuts *fCutsPrimTrg; // track cuts for primary particles (trigger)
	412	AliESDtrackCuts *fCutsPrimTrgConstrain; // track cuts for primary particles (trigger)
	413	AliESDtrackCuts *fCutsPrimAss; // track cuts for primary particles (associate)
3082e8ab	414	Float_t fCutsTwoTrackEff;
23536a91	415
	416	Float_t fTrgPartPtMin;
	417	Float_t fTrgPartPtMax;
	418	Float_t fTrgJetPtMin;
	419	Float_t fTrgJetPtMax;
3082e8ab	420	Float_t fTrgJetLeadTrkPtMin;
23536a91	421	Float_t fAssPartPtMin;
23536a91	422	Float_t fAssPartPtMax;
3082e8ab	423	Float_t fTrgAngleToEvPlane;
23536a91	424
ebdf1dbb	425	TF1 *fTrgJetPhiModCent;
	426	TF1 *fTrgJetPhiModSemi;
	427	TF1 *fTrgHadPhiModCent;
	428	TF1 *fTrgHadPhiModSemi;
	429
23536a91	430	// not implemented
	431	AliAnalysisTaskJetProtonCorr(const AliAnalysisTaskJetProtonCorr &rhs);
	432	AliAnalysisTaskJetProtonCorr& operator=(const AliAnalysisTaskJetProtonCorr &rhs);
	433
	434	ClassDef(AliAnalysisTaskJetProtonCorr, 1);
	435	};