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

#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 AliOADBContainer;
class AliTOFPIDParams;
class AliVTrack;
class AliPIDResponse;
class AliEventPoolManager;
class AliEventPool;
class AliEventplane;
class TSpline;

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* 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 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 SetEventPlaneResSpline(TSpline *spline) { fSplineEventPlaneRes = spline; }
  const TSpline *GetEventPlaneResSpline() const { return fSplineEventPlaneRes; }

  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,

      kHistNevMix,

      kHistEvPlane,
      kHistEvPlaneRes,
      kHistEvPlaneUsed,
      kHistEvPlaneCheck,
      kHistEvPlaneCheckUsed,
      kHistEvPlane3,
      kHistEvPlaneCorr,
      kHistEvPlaneCross,
      kHistEvPlaneCorrNoTrgJets,
      kHistEvPlaneCorrNoTrgJetsTrgd,
      kHistJetPtCentral,
      kHistJetPtSemi,
      kHistEtaPhiTrgHad,
      kHistEtaPhiTrgJet,
      kHistEtaPhiAssHad,
      kHistEtaPhiAssProt,
      kHistPhiTrgJetEvPlane,
      kHistPhiTrgHadEvPlane,
      kHistPhiRndTrgJetEvPlane,
      kHistPhiRndTrgHadEvPlane,
      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,

    kCorrRndHadHad,
    kCorrRndHadProt,
    kCorrRndJetHad,
    kCorrRndJetProt,

    kCorrRndHadExcHad,
    kCorrRndHadExcProt,
    kCorrRndJetExcHad,
    kCorrRndJetExcProt,

    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 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 phi, Float_t eta, Float_t qpt, Float_t weight) {
      fHistStat->Fill(1., weight);
      if (fHistCorrTrgEtaPhi)
	fHistCorrTrgEtaPhi->Fill(phi, eta, weight);
      if (fHistCorrTrgEtaPhiQpt)
	fHistCorrTrgEtaPhiQpt->Fill(phi, eta, qpt, weight);
    }
    void Ass(Float_t phi, Float_t eta, Float_t qpt, Float_t weight) {
      if (fHistCorrAssEtaPhi)
	fHistCorrAssEtaPhi->Fill(phi, eta, weight);
      if (fHistCorrAssEtaPhiQpt)
	fHistCorrAssEtaPhiQpt->Fill(phi, eta, qpt, 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;
    TH3F *fHistCorrTrgEtaPhiQpt;
    TH3F *fHistCorrAssEtaPhiQpt;

    const Float_t fHistDphiLo;
    const Int_t   fHistDphiNbins;
    const Int_t   fHistDetaNbins;

    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 fEventPlaneRes; //!
  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]; //!

  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 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() const { return ((fCentrality >= 0.) && (fCentrality <= 10.)); }
  Bool_t IsSemiCentral() const { return ((fCentrality >= 30.) && (fCentrality <= 50.)); }

  AliVTrack* GetLeadingTrack(const 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) const;

  Bool_t AcceptTrigger(AliVTrack *trg);
  Bool_t AcceptTrigger(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;

  Float_t GetPhiRel2(AliVParticle *part) 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.);

  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

  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;

  Float_t fTrgJetV2Cent;
  Float_t fTrgJetV2Semi;
  Float_t fTrgHadV2Cent;
  Float_t fTrgHadV2Semi;

  TSpline *fSplineEventPlaneRes;

  // 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"
d57e2346	4	#include "TF1.h"
23536a91	5
	6	#include "AliLog.h"
	7
0ba09863	8	#include "AliVParticle.h"
23536a91	9	#include "AliAnalysisTaskSE.h"
a4c7ef28	10	#include "AliESDtrackCuts.h"
23536a91	11
	12	#define ID(x) x, #x
	13	#define LAB(x) x + 1, #x
	14
	15	class TList;
	16	class TClonesArray;
ebdf1dbb	17	class AliOADBContainer;
ebdf1dbb	18	class AliTOFPIDParams;
23536a91	19	class AliVTrack;
	20	class AliPIDResponse;
	21	class AliEventPoolManager;
	22	class AliEventPool;
ebdf1dbb	23	class AliEventplane;
af846fc0	24	class TSpline;
23536a91	25
	26	class AliAnalysisTaskJetProtonCorr :
	27	public AliAnalysisTaskSE
	28	{
	29	public:
	30	AliAnalysisTaskJetProtonCorr(const char *name = "jets_trg_trd");
	31	~AliAnalysisTaskJetProtonCorr();
	32
	33	// analysis operations
	34	virtual void UserCreateOutputObjects();
	35	virtual Bool_t Notify();
	36	virtual void UserExec(Option_t *option);
	37	virtual void Terminate(const Option_t *option);
	38
ebdf1dbb	39	void SetParamsTOF();
ebdf1dbb	40
23536a91	41	// task configuration
d57e2346	42	void SetJetBranchName(const char* branchName) { strncpy(fJetBranchName, branchName, fgkStringLength-1); }
23536a91	43	const char* GetJetBranchName() const { return fJetBranchName; }
	44
	45	void SetPtThrPart(Float_t minPt, Float_t maxPt) { fTrgPartPtMin = minPt; fTrgPartPtMax = maxPt; }
	46	Float_t GetPtMinPart() const { return fTrgPartPtMin; }
	47	Float_t GetPtMaxPart() const { return fTrgPartPtMax; }
	48	void SetPtThrJet(Float_t minPt, Float_t maxPt) { fTrgJetPtMin = minPt; fTrgJetPtMax = maxPt; }
	49	Float_t GetPtMinJet() const { return fTrgJetPtMin; }
	50	Float_t GetPtMaxJet() const { return fTrgJetPtMax; }
	51	void SetPtThrAss(Float_t minPt, Float_t maxPt) { fAssPartPtMin = minPt; fAssPartPtMax = maxPt; }
	52	Float_t GetPtMinAss() const { return fAssPartPtMin; }
	53	Float_t GetPtMaxAss() const { return fAssPartPtMax; }
	54
09fd5f9f	55	void SetTwoTrackCut(Float_t cut) { fCutsTwoTrackEff = cut; }
	56	Float_t GetTwoTrackCut() const { return fCutsTwoTrackEff; }
	57
d57e2346	58	void SetTrackCutsAss(const AliESDtrackCuts &cuts) { *fCutsPrimAss = cuts; }
	59	void SetTrackCutsTrg(const AliESDtrackCuts &cuts) { *fCutsPrimTrg = cuts; }
	60	void SetTrackCutsTrgConstrain(const AliESDtrackCuts &cuts) { *fCutsPrimTrgConstrain = cuts; }
a4c7ef28	61
09fd5f9f	62	void SetTrgJetEtaMax(Float_t etamax) { fTrgJetEtaMax = etamax; }
	63	Float_t GetTrgJetEtaMax() const { return fTrgJetEtaMax; }
	64	void SetHadEtaMax(Float_t etamax) { fHadEtaMax = etamax; }
	65	Float_t GetHadEtaMax() const { return fHadEtaMax; }
	66
a4c7ef28	67	void SetUseEvplaneV0(Bool_t usev0 = kTRUE) { fUseEvplaneV0 = usev0; }
	68	Bool_t GetUseEvplaneV0() const { return fUseEvplaneV0; }
	69
d57e2346	70	void SetJetV2(Float_t v2Cent, Float_t v2Semi) {
	71	fTrgJetPhiModCent->SetParameter(0, v2Cent);
	72	fTrgJetPhiModSemi->SetParameter(0, v2Semi);
	73	}
	74	void SetHadV2(Float_t v2Cent, Float_t v2Semi) {
	75	fTrgHadPhiModCent->SetParameter(0, v2Cent);
	76	fTrgHadPhiModSemi->SetParameter(0, v2Semi);
	77	}
	78
	79	void SetLeadingTrackPtMin(Float_t pt) { fTrgJetLeadTrkPtMin = pt; }
	80	void SetLeadingTrackPtMax(Float_t pt) { fTrgJetLeadTrkPtMax = pt; }
	81
	82	void SetJetAreaMin(Float_t area) { fTrgJetAreaMin = area; }
687dfd6b	83	Float_t GetJetAreaMin() const { return fTrgJetAreaMin; }
	84
	85	void SetRequirePID(Bool_t req = kTRUE) { fRequirePID = req; }
	86	Bool_t GetRequirePID() const { return fRequirePID; }
d57e2346	87
	88	void SetFilterMask(Int_t mask) { fAssFilterMask = mask; }
	89	Int_t GetFilterMask() const { return fAssFilterMask; }
	90
	91	void SetErrorCount(Int_t cnt) { fErrorMsg = cnt; }
	92	Int_t GetErrorCount() const { return fErrorMsg; }
	93
09fd5f9f	94	void SetTrgAngleToEvPlane(Float_t angle) { fTrgAngleToEvPlane = angle; }
	95	Float_t GetTrgAngleToEvPlane() const { return fTrgAngleToEvPlane; }
	96
	97	void SetToyMeanNoPart(Float_t mean) { fToyMeanNoPart = mean; }
	98	Float_t GetToyMeanNoPart() const { return fToyMeanNoPart; }
	99	void SetToyRadius(Float_t radius) { fToyRadius = radius; }
	100	Float_t GetToyRadius() const { return fToyRadius; }
	101	void SetToySmearPhi(Float_t sigma) { fToySmearPhi = sigma; }
	102	Float_t GetToySmearPhi() const { return fToySmearPhi; }
	103
af846fc0	104	void SetEventPlaneResSpline(TSpline *spline) { fSplineEventPlaneRes = spline; }
	105	const TSpline *GetEventPlaneResSpline() const { return fSplineEventPlaneRes; }
	106
3082e8ab	107	void PrintTask(Option_t *option, Int_t indent) const;
	108
	109	static Double_t TOFsignal(Double_t x, Double_t par)
	110	{
	111	Double_t norm = par[0];
	112	Double_t mean = par[1];
	113	Double_t sigma = par[2];
	114	Double_t tail = par[3];
	115
	116	if (x[0] <= (tail + mean))
	117	return norm * TMath::Gaus(x[0], mean, sigma);
	118	else
	119	return norm * TMath::Gaus(tail + mean, mean, sigma) * TMath::Exp(-tail * (x[0] - tail - mean) / (sigma * sigma));
	120	}
	121
23536a91	122	// histograms
	123	enum Hist_t {
	124	kHistStat = 0,
ebdf1dbb	125	kHistVertexNctb,
ebdf1dbb	126	kHistVertexZ,
23536a91	127	kHistCentrality,
	128	kHistCentralityUsed,
	129	kHistCentralityCheck,
	130	kHistCentralityCheckUsed,
ebdf1dbb	131	kHistCentralityVsMult,
3082e8ab	132	kHistSignalTPC,
	133	kHistSignalTOF,
	134	kHistBetaTOF,
	135	kHistDeltaTPC,
	136	kHistDeltaTPCSemi,
	137	kHistDeltaTOF,
	138	kHistDeltaTOFSemi,
ebdf1dbb	139	// kHistExpSigmaTOFe,
	140	// kHistExpSigmaTOFmu,
	141	// kHistExpSigmaTOFpi,
	142	// kHistExpSigmaTOFk,
	143	// kHistExpSigmaTOFp,
	144	// kHistExpSigmaTOFd,
	145	// kHistExpSigmaTOFeSemi,
	146	// kHistExpSigmaTOFmuSemi,
	147	// kHistExpSigmaTOFpiSemi,
	148	// kHistExpSigmaTOFkSemi,
	149	// kHistExpSigmaTOFpSemi,
	150	// kHistExpSigmaTOFdSemi,
	151	// kHistCmpSigmaTOFe,
	152	// kHistCmpSigmaTOFmu,
	153	// kHistCmpSigmaTOFpi,
	154	// kHistCmpSigmaTOFk,
	155	// kHistCmpSigmaTOFp,
	156	// kHistCmpSigmaTOFd,
	157	// kHistCmpSigmaTOFeSemi,
	158	// kHistCmpSigmaTOFmuSemi,
	159	// kHistCmpSigmaTOFpiSemi,
	160	// kHistCmpSigmaTOFkSemi,
	161	// kHistCmpSigmaTOFpSemi,
	162	// kHistCmpSigmaTOFdSemi,
3082e8ab	163	kHistNsigmaTPCe,
	164	kHistNsigmaTPCmu,
	165	kHistNsigmaTPCpi,
	166	kHistNsigmaTPCk,
	167	kHistNsigmaTPCp,
	168	kHistNsigmaTPCd,
	169	kHistNsigmaTPCe_e,
	170	kHistNsigmaTOFe,
	171	kHistNsigmaTOFmu,
	172	kHistNsigmaTOFpi,
	173	kHistNsigmaTOFk,
	174	kHistNsigmaTOFp,
	175	kHistNsigmaTOFd,
	176	kHistNsigmaTOFmismatch,
3082e8ab	177	kHistDeltaTOFe,
	178	kHistDeltaTOFmu,
	179	kHistDeltaTOFpi,
	180	kHistDeltaTOFk,
	181	kHistDeltaTOFp,
	182	kHistDeltaTOFd,
ebdf1dbb	183
3082e8ab	184	kHistNsigmaTPCeSemi,
	185	kHistNsigmaTPCmuSemi,
	186	kHistNsigmaTPCpiSemi,
	187	kHistNsigmaTPCkSemi,
	188	kHistNsigmaTPCpSemi,
	189	kHistNsigmaTPCdSemi,
	190	kHistNsigmaTPCe_eSemi,
	191	kHistNsigmaTOFeSemi,
	192	kHistNsigmaTOFmuSemi,
	193	kHistNsigmaTOFpiSemi,
	194	kHistNsigmaTOFkSemi,
	195	kHistNsigmaTOFpSemi,
	196	kHistNsigmaTOFdSemi,
	197	kHistNsigmaTOFmismatchSemi,
3082e8ab	198	kHistDeltaTOFeSemi,
	199	kHistDeltaTOFmuSemi,
	200	kHistDeltaTOFpiSemi,
	201	kHistDeltaTOFkSemi,
	202	kHistDeltaTOFpSemi,
	203	kHistDeltaTOFdSemi,
ebdf1dbb	204
23536a91	205	kHistNsigmaTPCTOF,
3082e8ab	206	kHistNsigmaTPCTOFPt,
	207	kHistNsigmaTPCTOFUsed,
	208	kHistNsigmaTPCTOFUsedCentral,
	209	kHistNsigmaTPCTOFUsedSemiCentral,
	210	kHistNsigmaTPCTOFUsedPt,
	211	kHistNsigmaTPCTOFUsedPtCentral,
	212	kHistNsigmaTPCTOFUsedPtSemiCentral,
ebdf1dbb	213
579a71d2	214	kHistNsigmaTPCTOFUsedCentralMCe,
	215	kHistNsigmaTPCTOFUsedCentralMCmu,
	216	kHistNsigmaTPCTOFUsedCentralMCpi,
	217	kHistNsigmaTPCTOFUsedCentralMCk,
	218	kHistNsigmaTPCTOFUsedCentralMCp,
	219	kHistNsigmaTPCTOFUsedCentralMCd,
	220
	221	kHistNsigmaTPCTOFUsedSemiCentralMCe,
	222	kHistNsigmaTPCTOFUsedSemiCentralMCmu,
	223	kHistNsigmaTPCTOFUsedSemiCentralMCpi,
	224	kHistNsigmaTPCTOFUsedSemiCentralMCk,
	225	kHistNsigmaTPCTOFUsedSemiCentralMCp,
	226	kHistNsigmaTPCTOFUsedSemiCentralMCd,
	227
af846fc0	228	kHistNevMix,
af846fc0	229
23536a91	230	kHistEvPlane,
af846fc0	231	kHistEvPlaneRes,
23536a91	232	kHistEvPlaneUsed,
3082e8ab	233	kHistEvPlaneCheck,
3082e8ab	234	kHistEvPlaneCheckUsed,
a4c7ef28	235	kHistEvPlane3,
3082e8ab	236	kHistEvPlaneCorr,
af846fc0	237	kHistEvPlaneCross,
ebdf1dbb	238	kHistEvPlaneCorrNoTrgJets,
ebdf1dbb	239	kHistEvPlaneCorrNoTrgJetsTrgd,
3082e8ab	240	kHistJetPtCentral,
3082e8ab	241	kHistJetPtSemi,
23536a91	242	kHistEtaPhiTrgHad,
	243	kHistEtaPhiTrgJet,
	244	kHistEtaPhiAssHad,
	245	kHistEtaPhiAssProt,
ebdf1dbb	246	kHistPhiTrgJetEvPlane,
ebdf1dbb	247	kHistPhiTrgHadEvPlane,
687dfd6b	248	kHistPhiRndTrgJetEvPlane,
687dfd6b	249	kHistPhiRndTrgHadEvPlane,
ebdf1dbb	250	kHistPhiAssHadEvPlane,
	251	kHistPhiAssHadVsEvPlane,
	252	kHistPhiAssProtEvPlane,
a4c7ef28	253	kHistPhiTrgJetEvPlane3,
	254	kHistPhiTrgHadEvPlane3,
	255	kHistPhiAssHadEvPlane3,
	256	kHistPhiAssProtEvPlane3,
23536a91	257	kHistLast
	258	};
	259
	260	// statistics
	261	enum Stat_t {
	262	kStatSeen = 1,
	263	kStatTrg,
ebdf1dbb	264	kStatVtx,
23536a91	265	kStatCent,
	266	kStatEvPlane,
	267	kStatPID,
3082e8ab	268	kStatUsed,
23536a91	269	kStatEvCuts,
3082e8ab	270	kStatCentral,
3082e8ab	271	kStatSemiCentral,
23536a91	272	kStatLast
	273	};
	274
	275	// trigger conditions
3082e8ab	276	enum Trigger_t {
23536a91	277	kTriggerMB = 0,
	278	kTriggerInt,
	279	kTriggerLast
3082e8ab	280	};
23536a91	281
	282	// classification
	283	enum CorrType_t {
	284	kCorrHadHad = 0,
	285	kCorrHadProt,
	286	kCorrJetHad,
	287	kCorrJetProt,
ebdf1dbb	288
ebdf1dbb	289	kCorrRndHadHad,
ebdf1dbb	290	kCorrRndHadProt,
3fa79056	291	kCorrRndJetHad,
3fa79056	292	kCorrRndJetProt,
ebdf1dbb	293
ebdf1dbb	294	kCorrRndHadExcHad,
ebdf1dbb	295	kCorrRndHadExcProt,
3fa79056	296	kCorrRndJetExcHad,
3fa79056	297	kCorrRndJetExcProt,
ebdf1dbb	298
23536a91	299	kCorrLast
	300	};
	301
	302	enum Class_t {
	303	kClCentral = 0,
	304	kClSemiCentral,
2751fb9a	305	// kClDijet,
23536a91	306	kClLast
	307	};
	308
	309	enum Trg_t {
	310	kTrgHad = 0,
	311	kTrgJet,
ebdf1dbb	312	kTrgHadRnd,
ebdf1dbb	313	kTrgJetRnd,
23536a91	314	kTrgLast
	315	};
	316
	317	enum Ass_t {
ebdf1dbb	318	kAssHad = 0,
23536a91	319	kAssProt,
ebdf1dbb	320	kAssHadJetExc,
	321	kAssProtJetExc,
	322	kAssHadHadExc,
	323	kAssProtHadExc,
23536a91	324	kAssLast
	325	};
	326
	327	enum Ev_t {
	328	kEvSame = 0,
	329	kEvMix,
	330	kEvLast
	331	};
	332
0ba09863	333	class AliPartCorr : public AliVParticle {
	334	public:
	335	AliPartCorr(Float_t eta = 0., Float_t phi = 0., Float_t pt = 0., Float_t charge = 0) :
	336	fPt(pt), fEta(eta), fPhi(phi), fCharge(charge) {}
	337	AliPartCorr(const AliVParticle &rhs) :
	338	fPt(rhs.Pt()), fEta(rhs.Eta()), fPhi(rhs.Phi()), fCharge(rhs.Charge()) {}
	339	virtual ~AliPartCorr() {}
	340
	341	// kinematics
	342	virtual Double_t Px() const { AliFatal("not implemented"); return 0; }
	343	virtual Double_t Py() const { AliFatal("not implemented"); return 0; }
	344	virtual Double_t Pz() const { AliFatal("not implemented"); return 0; }
	345	virtual Double_t Pt() const { return fPt; }
	346	virtual Double_t P() const { AliFatal("not implemented"); return 0; }
	347	virtual Bool_t PxPyPz(Double_t[3]) const { AliFatal("not implemented"); return 0; }
	348
	349	virtual Double_t Xv() const { AliFatal("not implemented"); return 0; }
	350	virtual Double_t Yv() const { AliFatal("not implemented"); return 0; }
	351	virtual Double_t Zv() const { AliFatal("not implemented"); return 0; }
	352	virtual Bool_t XvYvZv(Double_t[3]) const { AliFatal("not implemented"); return 0; }
	353
	354	virtual Double_t OneOverPt() const { AliFatal("not implemented"); return 0; }
	355	virtual Double_t Phi() const { return fPhi; }
	356	virtual Double_t Theta() const { AliFatal("not implemented"); return 0; }
	357
	358	virtual Double_t E() const { AliFatal("not implemented"); return 0; }
	359	virtual Double_t M() const { AliFatal("not implemented"); return 0; }
	360
	361	virtual Double_t Eta() const { return fEta; }
	362	virtual Double_t Y() const { AliFatal("not implemented"); return 0; }
	363
	364	virtual Short_t Charge() const { return fCharge; }
	365	virtual Int_t GetLabel() const { AliFatal("not implemented"); return 0; }
	366
	367	virtual Int_t PdgCode() const { AliFatal("not implemented"); return 0; }
	368	virtual const Double_t *PID() const { AliFatal("not implemented"); return 0; }
	369
	370	protected:
	371	Float_t fPt;
	372	Float_t fEta;
	373	Float_t fPhi;
	374	Short_t fCharge;
	375
	376	ClassDef(AliPartCorr, 1);
	377	};
	378
23536a91	379	class AliHistCorr : public TNamed {
	380	public:
	381	AliHistCorr(TString name, TList *outputList = 0x0);
	382	~AliHistCorr();
	383
af846fc0	384	void Trigger(Float_t phi, Float_t eta, Float_t qpt, Float_t weight) {
0ba09863	385	fHistStat->Fill(1., weight);
	386	if (fHistCorrTrgEtaPhi)
	387	fHistCorrTrgEtaPhi->Fill(phi, eta, weight);
af846fc0	388	if (fHistCorrTrgEtaPhiQpt)
af846fc0	389	fHistCorrTrgEtaPhiQpt->Fill(phi, eta, qpt, weight);
0ba09863	390	}
af846fc0	391	void Ass(Float_t phi, Float_t eta, Float_t qpt, Float_t weight) {
0ba09863	392	if (fHistCorrAssEtaPhi)
0ba09863	393	fHistCorrAssEtaPhi->Fill(phi, eta, weight);
af846fc0	394	if (fHistCorrAssEtaPhiQpt)
af846fc0	395	fHistCorrAssEtaPhiQpt->Fill(phi, eta, qpt, weight);
0ba09863	396	}
23536a91	397	void Fill(AliVParticle trgPart, AliVParticle assPart, Float_t weight = 1.);
ebdf1dbb	398	void Fill(TLorentzVector trgPart, AliVParticle assPart, Float_t weight = 1.);
ebdf1dbb	399	void Fill(TLorentzVector trgPart, TLorentzVector assPart, Float_t weight = 1.);
23536a91	400
	401	protected:
	402	TList *fOutputList;
	403
	404	TH1F *fHistStat;
	405
	406	TH1F *fHistCorrPhi;
	407	TH2F *fHistCorrPhi2;
	408	TH2F *fHistCorrEtaPhi;
ebdf1dbb	409	TH2F *fHistCorrAvgEtaPhi;
	410	TH2F *fHistCorrTrgEtaPhi;
	411	TH2F *fHistCorrAssEtaPhi;
af846fc0	412	TH3F *fHistCorrTrgEtaPhiQpt;
af846fc0	413	TH3F *fHistCorrAssEtaPhiQpt;
23536a91	414
09fd5f9f	415	const Float_t fHistDphiLo;
	416	const Int_t fHistDphiNbins;
	417	const Int_t fHistDetaNbins;
	418
23536a91	419	AliHistCorr(const AliHistCorr &rhs);
	420	AliHistCorr& operator=(const AliHistCorr &rhs);
	421
	422	ClassDef(AliHistCorr, 1);
	423	};
	424
	425	AliHistCorr& GetHistCorr(CorrType_t corr, Class_t cl, Ev_t ev) { return fHistCorr[kEvLast(kClLast*corr + cl) + ev]; }
2751fb9a	426	AliEventPoolManager*& GetPoolMgr(Ass_t ass) { return fPoolMgr[ass]; }
2751fb9a	427	AliEventPool*& GetPool(Ass_t ass) { return fPool[ass]; }
23536a91	428
	429	protected:
	430	AliMCEvent *fMCEvent; //!
	431	AliESDEvent *fESDEvent; //!
	432	AliAODEvent *fAODEvent; //!
	433
ebdf1dbb	434	Int_t fRunNumber; //! current run number
	435	AliOADBContainer *fOADBContainerTOF; //! container for OADB entry with TOF parameters
	436	AliTOFPIDParams *fParamsTOF; //! TOF parametrization
	437
	438	AliEventplane *fEventplane; //! pointer to the event plane
	439
23536a91	440	UInt_t fTriggerMask; //! internal representation of trigger conditions
	441	UInt_t fClassMask; //! internal representation of event classes
	442	Float_t fCentrality; //!
	443	Float_t fCentralityCheck; //!
	444	Float_t fZvtx; //!
	445	AliPIDResponse *fPIDResponse; //!
ebdf1dbb	446	Float_t fEventPlaneAngle; //!
af846fc0	447	Float_t fEventPlaneRes; //!
ebdf1dbb	448	Float_t fEventPlaneAngleCheck; //!
a4c7ef28	449	Float_t fEventPlaneAngle3; //!
	450
	451	TObjArray *fPrimTrackArrayAss; //!
	452	TObjArray *fPrimTrackArrayTrg; //!
	453	TClonesArray *fPrimConstrainedTrackArray; //!
23536a91	454	TClonesArray *fJetArray; //!
23536a91	455
2751fb9a	456	AliEventPoolManager *fPoolMgr[kAssProt + 1]; //!
2751fb9a	457	AliEventPool *fPool[kAssProt + 1]; //!
23536a91	458
	459	AliHistCorr *fHistCorr; //! [kCorrLastkEvLast*kClLast]; //!
	460
d57e2346	461	Int_t fErrorMsg; //! remaining number of error messages to be printed
d57e2346	462
23536a91	463	Bool_t DetectTriggers();
	464	void MarkTrigger(Trigger_t trg) { fTriggerMask \|= (1 << trg); }
	465	Bool_t IsTrigger(Trigger_t trg) const { return (fTriggerMask & (1 << trg)); }
	466
	467	Bool_t DetectClasses();
	468	void MarkClass(Class_t cl) { fClassMask \|= (1 << cl); }
	469	Bool_t IsClass(Class_t cl) const { return (fClassMask & (1 << cl)); }
	470
	471	Bool_t PrepareEvent();
	472	Bool_t CleanUpEvent();
	473
	474	Float_t GetCentrality() const { return fCentrality; }
ebdf1dbb	475	Float_t GetEventPlaneAngle() const { return fEventPlaneAngle; }
23536a91	476	AliPIDResponse* GetPID() const { return fPIDResponse; }
d57e2346	477	Bool_t IsCentral() const { return ((fCentrality >= 0.) && (fCentrality <= 10.)); }
d57e2346	478	Bool_t IsSemiCentral() const { return ((fCentrality >= 30.) && (fCentrality <= 50.)); }
23536a91	479
d57e2346	480	AliVTrack* GetLeadingTrack(const AliAODJet *jet) const;
3082e8ab	481
	482	Float_t GetDPhiStar(Float_t phi1, Float_t pt1, Float_t charge1,
	483	Float_t phi2, Float_t pt2, Float_t charge2,
d57e2346	484	Float_t radius, Float_t bSign) const;
3082e8ab	485
af846fc0	486	Bool_t AcceptTrigger(AliVTrack *trg);
af846fc0	487	Bool_t AcceptTrigger(AliAODJet *trg);
d57e2346	488	Bool_t AcceptAssoc(const AliVTrack *trk) const;
	489	Bool_t IsProton(const AliVTrack *trk) const;
	490	Bool_t AcceptAngleToEvPlane(Float_t phi, Float_t psi) const;
	491	Bool_t AcceptTwoTracks(const AliVParticle trgPart, const AliVParticle assPart) const;
23536a91	492
af846fc0	493	Float_t GetPhiRel2(AliVParticle *part) const;
af846fc0	494
23536a91	495	TObjArray* CloneTracks(TObjArray *tracks) const;
23536a91	496
ebdf1dbb	497	Bool_t GenerateRandom(TCollection trgJetArray, TCollection trgHadArray,
	498	TCollection assHadJetArray, TCollection assProtJetArray,
	499	TCollection assHadHadArray, TCollection assProtHadArray,
	500	Float_t pFraction = .5);
	501
23536a91	502	Bool_t Correlate(CorrType_t corr, Class_t cl, Ev_t ev,
	503	TCollection trgArray, TCollection assArray, Float_t weight = 1.);
	504
	505	Bool_t Correlate(Trg_t trg, Ass_t ass, Class_t cl, Ev_t ev,
	506	TCollection trgArray, TCollection assArray, Float_t weight = 1.);
	507
	508	// output objects
	509	TList *fOutputList; //! list of output objects
	510
	511	// histogram management
	512	TH1 *fHist[kHistLast]; //! pointers to histogram
	513	const char *fShortTaskId; //! short identifier for the task
	514
	515	TH1*& GetHistogram(Hist_t hist, const Int_t idx = 0) { return fHist[hist + idx]; }
	516
	517	TH1* AddHistogram(Hist_t hist, const char *hid, TString title,
	518	Int_t xbins, Float_t xmin, Float_t xmax, Int_t binType = 1);
	519	TH2* AddHistogram(Hist_t hist, const char *hid, TString title,
	520	Int_t xbins, Float_t xmin, Float_t xmax,
	521	Int_t ybins, Float_t ymin, Float_t ymax, Int_t binType = 1);
	522	TH3* AddHistogram(Hist_t hist, const char *hid, TString title,
	523	Int_t xbins, Float_t xmin, Float_t xmax,
	524	Int_t ybins, Float_t ymin, Float_t ymax,
	525	Int_t zbins, Float_t zmin, Float_t zmax, Int_t binType = 1);
	526
	527	void FillH1(Hist_t hist, Float_t x, Float_t weight = 1., Int_t idx = 0)
	528	{ GetHistogram(hist, idx)->Fill(x, weight); }
	529	void FillH2(Hist_t hist, Float_t x, Float_t y, Float_t weight = 1., Int_t idx = 0)
	530	{ ((TH2*) GetHistogram(hist, idx))->Fill(x, y, weight); }
	531	void FillH3(Hist_t hist, Float_t x, Float_t y, Float_t z, Float_t weight = 1., Int_t idx = 0)
	532	{ ((TH3*) GetHistogram(hist, idx))->Fill(x, y, z, weight); }
	533
	534	const char* fkCorrTypeName[kCorrLast]; //!
	535	const char* fkClassName[kClLast]; //!
	536	const char* fkEvName[kEvLast]; //!
	537
	538	// task configuration
	539	static const Int_t fgkStringLength = 100; // max length for the jet branch name
	540	char fJetBranchName[fgkStringLength]; // jet branch name
	541
09fd5f9f	542	const Bool_t fUseStandardCuts;
a4c7ef28	543	Bool_t fUseEvplaneV0;
3082e8ab	544
a4c7ef28	545	AliESDtrackCuts *fCutsPrimTrg; // track cuts for primary particles (trigger)
	546	AliESDtrackCuts *fCutsPrimTrgConstrain; // track cuts for primary particles (trigger)
	547	AliESDtrackCuts *fCutsPrimAss; // track cuts for primary particles (associate)
3082e8ab	548	Float_t fCutsTwoTrackEff;
23536a91	549
d57e2346	550	UInt_t fAssFilterMask;
687dfd6b	551	Bool_t fRequirePID;
d57e2346	552	Float_t fTrgJetEtaMax;
d57e2346	553	Float_t fHadEtaMax;
23536a91	554	Float_t fTrgPartPtMin;
	555	Float_t fTrgPartPtMax;
	556	Float_t fTrgJetPtMin;
	557	Float_t fTrgJetPtMax;
3082e8ab	558	Float_t fTrgJetLeadTrkPtMin;
d57e2346	559	Float_t fTrgJetLeadTrkPtMax;
d57e2346	560	Float_t fTrgJetAreaMin;
23536a91	561	Float_t fAssPartPtMin;
23536a91	562	Float_t fAssPartPtMax;
3082e8ab	563	Float_t fTrgAngleToEvPlane;
23536a91	564
687dfd6b	565	Float_t fToyMeanNoPart;
	566	Float_t fToyRadius;
	567	Float_t fToySmearPhi;
	568
ebdf1dbb	569	TF1 *fTrgJetPhiModCent;
	570	TF1 *fTrgJetPhiModSemi;
	571	TF1 *fTrgHadPhiModCent;
	572	TF1 *fTrgHadPhiModSemi;
	573
af846fc0	574	Float_t fTrgJetV2Cent;
	575	Float_t fTrgJetV2Semi;
	576	Float_t fTrgHadV2Cent;
	577	Float_t fTrgHadV2Semi;
	578
	579	TSpline *fSplineEventPlaneRes;
	580
23536a91	581	// not implemented
	582	AliAnalysisTaskJetProtonCorr(const AliAnalysisTaskJetProtonCorr &rhs);
	583	AliAnalysisTaskJetProtonCorr& operator=(const AliAnalysisTaskJetProtonCorr &rhs);
	584
	585	ClassDef(AliAnalysisTaskJetProtonCorr, 1);
	586	};