[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 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 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,
      kHistEvPlaneCheck,
      kHistEvPlaneCheckUsed,
      kHistEvPlane3,
      kHistEvPlaneCorr,
      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 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 *fHistStat;

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

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

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

  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;

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