[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,

      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
23536a91	210	kHistEvPlane,
23536a91	211	kHistEvPlaneUsed,
3082e8ab	212	kHistEvPlaneCheck,
3082e8ab	213	kHistEvPlaneCheckUsed,
a4c7ef28	214	kHistEvPlane3,
3082e8ab	215	kHistEvPlaneCorr,
ebdf1dbb	216	kHistEvPlaneCorrNoTrgJets,
ebdf1dbb	217	kHistEvPlaneCorrNoTrgJetsTrgd,
3082e8ab	218	kHistJetPtCentral,
3082e8ab	219	kHistJetPtSemi,
23536a91	220	kHistEtaPhiTrgHad,
	221	kHistEtaPhiTrgJet,
	222	kHistEtaPhiAssHad,
	223	kHistEtaPhiAssProt,
ebdf1dbb	224	kHistPhiTrgJetEvPlane,
ebdf1dbb	225	kHistPhiTrgHadEvPlane,
687dfd6b	226	kHistPhiRndTrgJetEvPlane,
687dfd6b	227	kHistPhiRndTrgHadEvPlane,
ebdf1dbb	228	kHistPhiAssHadEvPlane,
	229	kHistPhiAssHadVsEvPlane,
	230	kHistPhiAssProtEvPlane,
a4c7ef28	231	kHistPhiTrgJetEvPlane3,
	232	kHistPhiTrgHadEvPlane3,
	233	kHistPhiAssHadEvPlane3,
	234	kHistPhiAssProtEvPlane3,
23536a91	235	kHistLast
	236	};
	237
	238	// statistics
	239	enum Stat_t {
	240	kStatSeen = 1,
	241	kStatTrg,
ebdf1dbb	242	kStatVtx,
23536a91	243	kStatCent,
	244	kStatEvPlane,
	245	kStatPID,
3082e8ab	246	kStatUsed,
23536a91	247	kStatEvCuts,
3082e8ab	248	kStatCentral,
3082e8ab	249	kStatSemiCentral,
23536a91	250	kStatLast
	251	};
	252
	253	// trigger conditions
3082e8ab	254	enum Trigger_t {
23536a91	255	kTriggerMB = 0,
	256	kTriggerInt,
	257	kTriggerLast
3082e8ab	258	};
23536a91	259
	260	// classification
	261	enum CorrType_t {
	262	kCorrHadHad = 0,
	263	kCorrHadProt,
	264	kCorrJetHad,
	265	kCorrJetProt,
ebdf1dbb	266
ebdf1dbb	267	kCorrRndHadHad,
ebdf1dbb	268	kCorrRndHadProt,
3fa79056	269	kCorrRndJetHad,
3fa79056	270	kCorrRndJetProt,
ebdf1dbb	271
ebdf1dbb	272	kCorrRndHadExcHad,
ebdf1dbb	273	kCorrRndHadExcProt,
3fa79056	274	kCorrRndJetExcHad,
3fa79056	275	kCorrRndJetExcProt,
ebdf1dbb	276
23536a91	277	kCorrLast
	278	};
	279
	280	enum Class_t {
	281	kClCentral = 0,
	282	kClSemiCentral,
2751fb9a	283	// kClDijet,
23536a91	284	kClLast
	285	};
	286
	287	enum Trg_t {
	288	kTrgHad = 0,
	289	kTrgJet,
ebdf1dbb	290	kTrgHadRnd,
ebdf1dbb	291	kTrgJetRnd,
23536a91	292	kTrgLast
	293	};
	294
	295	enum Ass_t {
ebdf1dbb	296	kAssHad = 0,
23536a91	297	kAssProt,
ebdf1dbb	298	kAssHadJetExc,
	299	kAssProtJetExc,
	300	kAssHadHadExc,
	301	kAssProtHadExc,
23536a91	302	kAssLast
	303	};
	304
	305	enum Ev_t {
	306	kEvSame = 0,
	307	kEvMix,
	308	kEvLast
	309	};
	310
0ba09863	311	class AliPartCorr : public AliVParticle {
	312	public:
	313	AliPartCorr(Float_t eta = 0., Float_t phi = 0., Float_t pt = 0., Float_t charge = 0) :
	314	fPt(pt), fEta(eta), fPhi(phi), fCharge(charge) {}
	315	AliPartCorr(const AliVParticle &rhs) :
	316	fPt(rhs.Pt()), fEta(rhs.Eta()), fPhi(rhs.Phi()), fCharge(rhs.Charge()) {}
	317	virtual ~AliPartCorr() {}
	318
	319	// kinematics
	320	virtual Double_t Px() const { AliFatal("not implemented"); return 0; }
	321	virtual Double_t Py() const { AliFatal("not implemented"); return 0; }
	322	virtual Double_t Pz() const { AliFatal("not implemented"); return 0; }
	323	virtual Double_t Pt() const { return fPt; }
	324	virtual Double_t P() const { AliFatal("not implemented"); return 0; }
	325	virtual Bool_t PxPyPz(Double_t[3]) const { AliFatal("not implemented"); return 0; }
	326
	327	virtual Double_t Xv() const { AliFatal("not implemented"); return 0; }
	328	virtual Double_t Yv() const { AliFatal("not implemented"); return 0; }
	329	virtual Double_t Zv() const { AliFatal("not implemented"); return 0; }
	330	virtual Bool_t XvYvZv(Double_t[3]) const { AliFatal("not implemented"); return 0; }
	331
	332	virtual Double_t OneOverPt() const { AliFatal("not implemented"); return 0; }
	333	virtual Double_t Phi() const { return fPhi; }
	334	virtual Double_t Theta() const { AliFatal("not implemented"); return 0; }
	335
	336	virtual Double_t E() const { AliFatal("not implemented"); return 0; }
	337	virtual Double_t M() const { AliFatal("not implemented"); return 0; }
	338
	339	virtual Double_t Eta() const { return fEta; }
	340	virtual Double_t Y() const { AliFatal("not implemented"); return 0; }
	341
	342	virtual Short_t Charge() const { return fCharge; }
	343	virtual Int_t GetLabel() const { AliFatal("not implemented"); return 0; }
	344
	345	virtual Int_t PdgCode() const { AliFatal("not implemented"); return 0; }
	346	virtual const Double_t *PID() const { AliFatal("not implemented"); return 0; }
	347
	348	protected:
	349	Float_t fPt;
	350	Float_t fEta;
	351	Float_t fPhi;
	352	Short_t fCharge;
	353
	354	ClassDef(AliPartCorr, 1);
	355	};
	356
23536a91	357	class AliHistCorr : public TNamed {
	358	public:
	359	AliHistCorr(TString name, TList *outputList = 0x0);
	360	~AliHistCorr();
	361
0ba09863	362	void Trigger(Float_t phi, Float_t eta, Float_t weight = 1.) {
	363	fHistStat->Fill(1., weight);
	364	if (fHistCorrTrgEtaPhi)
	365	fHistCorrTrgEtaPhi->Fill(phi, eta, weight);
	366	}
	367	void Ass(Float_t phi, Float_t eta, Float_t weight = 1.) {
	368	if (fHistCorrAssEtaPhi)
	369	fHistCorrAssEtaPhi->Fill(phi, eta, weight);
	370	}
23536a91	371	void Fill(AliVParticle trgPart, AliVParticle assPart, Float_t weight = 1.);
ebdf1dbb	372	void Fill(TLorentzVector trgPart, AliVParticle assPart, Float_t weight = 1.);
ebdf1dbb	373	void Fill(TLorentzVector trgPart, TLorentzVector assPart, Float_t weight = 1.);
23536a91	374
	375	protected:
	376	TList *fOutputList;
	377
	378	TH1F *fHistStat;
	379
	380	TH1F *fHistCorrPhi;
	381	TH2F *fHistCorrPhi2;
	382	TH2F *fHistCorrEtaPhi;
ebdf1dbb	383	TH2F *fHistCorrAvgEtaPhi;
	384	TH2F *fHistCorrTrgEtaPhi;
	385	TH2F *fHistCorrAssEtaPhi;
23536a91	386
09fd5f9f	387	const Float_t fHistDphiLo;
	388	const Int_t fHistDphiNbins;
	389	const Int_t fHistDetaNbins;
	390
23536a91	391	AliHistCorr(const AliHistCorr &rhs);
	392	AliHistCorr& operator=(const AliHistCorr &rhs);
	393
	394	ClassDef(AliHistCorr, 1);
	395	};
	396
	397	AliHistCorr& GetHistCorr(CorrType_t corr, Class_t cl, Ev_t ev) { return fHistCorr[kEvLast(kClLast*corr + cl) + ev]; }
2751fb9a	398	AliEventPoolManager*& GetPoolMgr(Ass_t ass) { return fPoolMgr[ass]; }
2751fb9a	399	AliEventPool*& GetPool(Ass_t ass) { return fPool[ass]; }
23536a91	400
	401	protected:
	402	AliMCEvent *fMCEvent; //!
	403	AliESDEvent *fESDEvent; //!
	404	AliAODEvent *fAODEvent; //!
	405
ebdf1dbb	406	Int_t fRunNumber; //! current run number
	407	AliOADBContainer *fOADBContainerTOF; //! container for OADB entry with TOF parameters
	408	AliTOFPIDParams *fParamsTOF; //! TOF parametrization
	409
	410	AliEventplane *fEventplane; //! pointer to the event plane
	411
23536a91	412	UInt_t fTriggerMask; //! internal representation of trigger conditions
	413	UInt_t fClassMask; //! internal representation of event classes
	414	Float_t fCentrality; //!
	415	Float_t fCentralityCheck; //!
	416	Float_t fZvtx; //!
	417	AliPIDResponse *fPIDResponse; //!
ebdf1dbb	418	Float_t fEventPlaneAngle; //!
ebdf1dbb	419	Float_t fEventPlaneAngleCheck; //!
a4c7ef28	420	Float_t fEventPlaneAngle3; //!
	421
	422	TObjArray *fPrimTrackArrayAss; //!
	423	TObjArray *fPrimTrackArrayTrg; //!
	424	TClonesArray *fPrimConstrainedTrackArray; //!
23536a91	425	TClonesArray *fJetArray; //!
23536a91	426
2751fb9a	427	AliEventPoolManager *fPoolMgr[kAssProt + 1]; //!
2751fb9a	428	AliEventPool *fPool[kAssProt + 1]; //!
23536a91	429
	430	AliHistCorr *fHistCorr; //! [kCorrLastkEvLast*kClLast]; //!
	431
d57e2346	432	Int_t fErrorMsg; //! remaining number of error messages to be printed
d57e2346	433
23536a91	434	Bool_t DetectTriggers();
	435	void MarkTrigger(Trigger_t trg) { fTriggerMask \|= (1 << trg); }
	436	Bool_t IsTrigger(Trigger_t trg) const { return (fTriggerMask & (1 << trg)); }
	437
	438	Bool_t DetectClasses();
	439	void MarkClass(Class_t cl) { fClassMask \|= (1 << cl); }
	440	Bool_t IsClass(Class_t cl) const { return (fClassMask & (1 << cl)); }
	441
	442	Bool_t PrepareEvent();
	443	Bool_t CleanUpEvent();
	444
	445	Float_t GetCentrality() const { return fCentrality; }
ebdf1dbb	446	Float_t GetEventPlaneAngle() const { return fEventPlaneAngle; }
23536a91	447	AliPIDResponse* GetPID() const { return fPIDResponse; }
d57e2346	448	Bool_t IsCentral() const { return ((fCentrality >= 0.) && (fCentrality <= 10.)); }
d57e2346	449	Bool_t IsSemiCentral() const { return ((fCentrality >= 30.) && (fCentrality <= 50.)); }
23536a91	450
d57e2346	451	AliVTrack* GetLeadingTrack(const AliAODJet *jet) const;
3082e8ab	452
	453	Float_t GetDPhiStar(Float_t phi1, Float_t pt1, Float_t charge1,
	454	Float_t phi2, Float_t pt2, Float_t charge2,
d57e2346	455	Float_t radius, Float_t bSign) const;
3082e8ab	456
d57e2346	457	Bool_t AcceptTrigger(const AliVTrack *trg);
	458	Bool_t AcceptTrigger(const AliAODJet *trg);
	459	Bool_t AcceptAssoc(const AliVTrack *trk) const;
	460	Bool_t IsProton(const AliVTrack *trk) const;
	461	Bool_t AcceptAngleToEvPlane(Float_t phi, Float_t psi) const;
	462	Bool_t AcceptTwoTracks(const AliVParticle trgPart, const AliVParticle assPart) const;
23536a91	463
	464	TObjArray* CloneTracks(TObjArray *tracks) const;
	465
ebdf1dbb	466	Bool_t GenerateRandom(TCollection trgJetArray, TCollection trgHadArray,
	467	TCollection assHadJetArray, TCollection assProtJetArray,
	468	TCollection assHadHadArray, TCollection assProtHadArray,
	469	Float_t pFraction = .5);
	470
23536a91	471	Bool_t Correlate(CorrType_t corr, Class_t cl, Ev_t ev,
	472	TCollection trgArray, TCollection assArray, Float_t weight = 1.);
	473
	474	Bool_t Correlate(Trg_t trg, Ass_t ass, Class_t cl, Ev_t ev,
	475	TCollection trgArray, TCollection assArray, Float_t weight = 1.);
	476
	477	// output objects
	478	TList *fOutputList; //! list of output objects
	479
	480	// histogram management
	481	TH1 *fHist[kHistLast]; //! pointers to histogram
	482	const char *fShortTaskId; //! short identifier for the task
	483
	484	TH1*& GetHistogram(Hist_t hist, const Int_t idx = 0) { return fHist[hist + idx]; }
	485
	486	TH1* AddHistogram(Hist_t hist, const char *hid, TString title,
	487	Int_t xbins, Float_t xmin, Float_t xmax, Int_t binType = 1);
	488	TH2* AddHistogram(Hist_t hist, const char *hid, TString title,
	489	Int_t xbins, Float_t xmin, Float_t xmax,
	490	Int_t ybins, Float_t ymin, Float_t ymax, Int_t binType = 1);
	491	TH3* AddHistogram(Hist_t hist, const char *hid, TString title,
	492	Int_t xbins, Float_t xmin, Float_t xmax,
	493	Int_t ybins, Float_t ymin, Float_t ymax,
	494	Int_t zbins, Float_t zmin, Float_t zmax, Int_t binType = 1);
	495
	496	void FillH1(Hist_t hist, Float_t x, Float_t weight = 1., Int_t idx = 0)
	497	{ GetHistogram(hist, idx)->Fill(x, weight); }
	498	void FillH2(Hist_t hist, Float_t x, Float_t y, Float_t weight = 1., Int_t idx = 0)
	499	{ ((TH2*) GetHistogram(hist, idx))->Fill(x, y, weight); }
	500	void FillH3(Hist_t hist, Float_t x, Float_t y, Float_t z, Float_t weight = 1., Int_t idx = 0)
	501	{ ((TH3*) GetHistogram(hist, idx))->Fill(x, y, z, weight); }
	502
	503	const char* fkCorrTypeName[kCorrLast]; //!
	504	const char* fkClassName[kClLast]; //!
	505	const char* fkEvName[kEvLast]; //!
	506
	507	// task configuration
	508	static const Int_t fgkStringLength = 100; // max length for the jet branch name
	509	char fJetBranchName[fgkStringLength]; // jet branch name
	510
09fd5f9f	511	const Bool_t fUseStandardCuts;
a4c7ef28	512	Bool_t fUseEvplaneV0;
3082e8ab	513
a4c7ef28	514	AliESDtrackCuts *fCutsPrimTrg; // track cuts for primary particles (trigger)
	515	AliESDtrackCuts *fCutsPrimTrgConstrain; // track cuts for primary particles (trigger)
	516	AliESDtrackCuts *fCutsPrimAss; // track cuts for primary particles (associate)
3082e8ab	517	Float_t fCutsTwoTrackEff;
23536a91	518
d57e2346	519	UInt_t fAssFilterMask;
687dfd6b	520	Bool_t fRequirePID;
d57e2346	521	Float_t fTrgJetEtaMax;
d57e2346	522	Float_t fHadEtaMax;
23536a91	523	Float_t fTrgPartPtMin;
	524	Float_t fTrgPartPtMax;
	525	Float_t fTrgJetPtMin;
	526	Float_t fTrgJetPtMax;
3082e8ab	527	Float_t fTrgJetLeadTrkPtMin;
d57e2346	528	Float_t fTrgJetLeadTrkPtMax;
d57e2346	529	Float_t fTrgJetAreaMin;
23536a91	530	Float_t fAssPartPtMin;
23536a91	531	Float_t fAssPartPtMax;
3082e8ab	532	Float_t fTrgAngleToEvPlane;
23536a91	533
687dfd6b	534	Float_t fToyMeanNoPart;
	535	Float_t fToyRadius;
	536	Float_t fToySmearPhi;
	537
ebdf1dbb	538	TF1 *fTrgJetPhiModCent;
	539	TF1 *fTrgJetPhiModSemi;
	540	TF1 *fTrgHadPhiModCent;
	541	TF1 *fTrgHadPhiModSemi;
	542
23536a91	543	// not implemented
	544	AliAnalysisTaskJetProtonCorr(const AliAnalysisTaskJetProtonCorr &rhs);
	545	AliAnalysisTaskJetProtonCorr& operator=(const AliAnalysisTaskJetProtonCorr &rhs);
	546
	547	ClassDef(AliAnalysisTaskJetProtonCorr, 1);
	548	};