Update

[u/mrichter/AliRoot.git] / PWGHF / hfe / AliAnalysisTaskHFEFlow.h

/**************************************************************************\r
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
*                                                                        *\r
* Author: The ALICE Off-line Project.                                    *\r
* Contributors are mentioned in the code where appropriate.              *\r
*                                                                        *\r
* Permission to use, copy, modify and distribute this software and its   *\r
* documentation strictly for non-commercial purposes is hereby granted   *\r
* without fee, provided that the above copyright notice appears in all   *\r
* copies and that both the copyright notice and this permission notice   *\r
* appear in the supporting documentation. The authors make no claims     *\r
* about the suitability of this software for any purpose. It is          *\r
* provided "as is" without express or implied warranty.                  *\r
**************************************************************************/\r
//\r
// Flow task class for the ALICE HFE group\r
//\r
//\r
#ifndef ALIANALYSISTASKHFEFLOW_H\r
#define ALIANALYSISTASKHFEFLOW_H\r
\r
\r
\r
\r
#include <AliAnalysisTaskSE.h>\r
\r
class TList;\r
class AliVTrack;\r
class AliVEvent;\r
class AliESDtrack;\r
class AliESDEvent;\r
class AliMCEvent;\r
class AliFlowTrackCuts;\r
class AliFlowCandidateTrack;\r
class AliHFEcuts;\r
class AliHFEpid;\r
class TH1D;\r
class TH2D;\r
class TProfile;\r
class TProfile2D;\r
class THnSparse;\r
class AliHFEpidQAmanager;\r
class AliFlowEvent;\r
class AliESDtrackCuts;\r
class AliHFEVZEROEventPlane;\r
class TArrayI;\r
\r
class AliAnalysisTaskHFEFlow: public AliAnalysisTaskSE {\r
  \r
public:\r
\r
  typedef enum{\r
    kElectronfromconversion = 0,\r
    kElectronfromconversionboth = 1,\r
    kElectronfrompi0 = 2,\r
    kElectronfrompi0both = 3,\r
    kElectronfromC = 4,\r
    kElectronfromB = 5,\r
    kElectronfrometa = 6,\r
    kElectronfrometaboth = 7,\r
    kElectronfromother = 8\r
  } FlowSource_t;\r
  \r
  typedef enum{\r
    kS = 0,\r
    kOp = 1\r
  } FlowSign_t;\r
\r
\r
\r
\r
  AliAnalysisTaskHFEFlow();\r
  AliAnalysisTaskHFEFlow(const char *name);\r
  AliAnalysisTaskHFEFlow(const AliAnalysisTaskHFEFlow &ref);\r
  AliAnalysisTaskHFEFlow& operator=(const AliAnalysisTaskHFEFlow &ref);\r
  virtual void Copy(TObject &o) const;\r
  virtual ~AliAnalysisTaskHFEFlow();\r
  \r
  virtual void  UserExec(Option_t */*option*/);\r
  virtual void  UserCreateOutputObjects();\r
\r
  void SetAODAnalysis(Bool_t aodAnalysis) { fAODAnalysis = aodAnalysis; };\r
  void SetUseFlagAOD(Bool_t useFlagAOD) { fUseFlagAOD = useFlagAOD; }\r
  void SetApplyCut(Bool_t applyCut) { fApplyCut = applyCut; }\r
  void SetFlags(ULong_t flags)          { fFlags = flags; }\r
  \r
  AliHFEpid *GetPID() const { return fPID; }\r
  AliHFEpidQAmanager *GetPIDQAManager() const { return fPIDqa; }\r
  AliHFEpid *GetPIDBackground() const { return fPIDBackground; }\r
  AliHFEpidQAmanager *GetPIDBackgroundQAManager() const { return fPIDBackgroundqa; }\r
\r
\r
  void SetHFECuts(AliHFEcuts * const cuts) { fHFECuts = cuts; };\r
  void SetHFEBackgroundCuts(AliESDtrackCuts * const cuts) { fHFEBackgroundCuts = cuts; };\r
  void SetSubEtaGapTPC(Bool_t  subEtaGapTPC) { fSubEtaGapTPC = subEtaGapTPC; };\r
  void SetEtaGap(Double_t  etaGap) { fEtaGap = etaGap; };\r
  void SetVZEROEventPlane(Bool_t vzeroEventPlane) { fVZEROEventPlane = vzeroEventPlane; };\r
  void SetVZEROEventPlaneA(Bool_t vzeroEventPlaneA) { fVZEROEventPlaneA = vzeroEventPlaneA; };\r
  void SetVZEROEventPlaneC(Bool_t vzeroEventPlaneC) { fVZEROEventPlaneC = vzeroEventPlaneC; };\r
  void SetHFEVZEROEventPlane(AliHFEVZEROEventPlane *hfeVZEROEventPlane) { fHFEVZEROEventPlane = hfeVZEROEventPlane; };\r
\r
  void SetNbBinsCentralityQCumulant(Int_t nbBinsCentralityQCumulant) { fNbBinsCentralityQCumulant = nbBinsCentralityQCumulant; };\r
  void SetBinCentralityLess(Int_t k, Float_t value)  { fBinCentralityLess[k] = value; };\r
  void SetNbBinsPtQCumulant(Int_t nbBinsPtQCumulant) { fNbBinsPtQCumulant = nbBinsPtQCumulant; };\r
  void SetMinPtQCumulant(Double_t minPtQCumulant) { fMinPtQCumulant = minPtQCumulant; };\r
  void SetMaxPtQCumulant(Double_t maxPtQCumulant) { fMaxPtQCumulant = maxPtQCumulant; };\r
\r
  void SetAfterBurnerOn(Bool_t afterBurnerOn)     { fAfterBurnerOn = afterBurnerOn; };\r
  void SetNonFlowNumberOfTrackClones(Int_t nonFlowNumberOfTrackClones) { fNonFlowNumberOfTrackClones = nonFlowNumberOfTrackClones; };\r
  void SetV1V2V3V4V5(Double_t v1,Double_t v2,Double_t v3,Double_t v4,Double_t v5) {fV1 = v1; fV2 = v2; fV3 = v3; fV4 = v4; fV5 = v5; };\r
  void SetMaxNumberOfIterations(Int_t maxNumberOfIterations) { fMaxNumberOfIterations = maxNumberOfIterations; };\r
  void SetPrecisionPhi(Double_t precisionPhi) { fPrecisionPhi = precisionPhi;};\r
  void SetUseMCReactionPlane(Bool_t useMCReactionPlane) { fUseMCReactionPlane = useMCReactionPlane;};\r
  void SetMCPID(Bool_t mcPID) { fMCPID = mcPID;};\r
  void SetNoPID(Bool_t noPID) { fNoPID = noPID;};\r
\r
  void SetDebugLevel(Int_t debugLevel) { fDebugLevel = debugLevel;};\r
\r
  Int_t GetNbBinsCentralityQCumulant() const { return  fNbBinsCentralityQCumulant; };\r
  Double_t GetBinCentralityLess(Int_t k) const { return fBinCentralityLess[k]; };\r
  \r
  AliFlowCandidateTrack *MakeTrack( Double_t mass, Double_t pt, Double_t phi, Double_t eta) ;\r
  Double_t GetPhiAfterAddV2(Double_t phi,Double_t reactionPlaneAngle) const;\r
\r
  void  SetMaxInvmass(Double_t maxInvmass) { fMaxInvmass = maxInvmass; };\r
  void  SetMaxopening3D(Double_t maxOpening3D) { fMaxopening3D = maxOpening3D; };\r
  void  SetMaxopeningtheta(Double_t maxOpeningtheta) { fMaxopeningtheta = maxOpeningtheta; };\r
  void  SetMaxopeningphi(Double_t maxOpeningphi) { fMaxopeningphi = maxOpeningphi; };\r
\r
  Int_t    LookAtNonHFE(Int_t iTrack1, AliVTrack *track1, AliVEvent *fESD, AliMCEvent *mcEvent,Int_t binct,Double_t deltaphi,Int_t source,Int_t indexmother);\r
  \r
private:\r
  TList     *fListHist;         //! TH list\r
  Bool_t    fAODAnalysis;       // AOD analysis\r
  Bool_t    fUseFlagAOD;        // Use the preselected AOD track\r
  Bool_t    fApplyCut;       // Apply the analysis cut for AOD tracks\r
  ULong_t   fFlags;             // reconstruction AOD status flags \r
  \r
  Bool_t    fVZEROEventPlane;  // Use Event Planes from VZERO\r
  Bool_t    fVZEROEventPlaneA; // Use Event Planes from VZERO A\r
  Bool_t    fVZEROEventPlaneC; // Use Event Planes from VZERO C\r
\r
  Bool_t    fSubEtaGapTPC;    // bool to fill with eta gap\r
  Double_t  fEtaGap;          // Value of the eta gap\r
\r
  Int_t     fNbBinsCentralityQCumulant;  // Number of Bins Q Cumulant\r
  Double_t  fBinCentralityLess[10];      // Centrality Bin lower value\r
  Int_t     fNbBinsPtQCumulant;          // Nbbinspt QCumulant method\r
  Double_t  fMinPtQCumulant;             // Min pt QCumulant method\r
  Double_t  fMaxPtQCumulant;             // Max pt QCumulant method\r
  Bool_t    fAfterBurnerOn;              // Add flow to all tracks\r
  Int_t     fNonFlowNumberOfTrackClones; // number of times to clone the particles (nonflow) \r
  Double_t  fV1;        // Add Flow. Must be in range [0,0.5].\r
  Double_t  fV2;        // Add Flow. Must be in range [0,0.5].\r
  Double_t  fV3;        // Add Flow. Must be in range [0,0.5].\r
  Double_t  fV4;        // Add Flow. Must be in range [0,0.5].\r
  Double_t  fV5;        // Add Flow. Must be in range [0,0.5].\r
  Int_t     fMaxNumberOfIterations; // Max number of iteration for adding v2\r
  Double_t  fPrecisionPhi;  // precision phi for adding v2\r
  Bool_t    fUseMCReactionPlane; // use MC reaction plane\r
\r
  Bool_t    fMCPID; // MC PID for electrons\r
  Bool_t    fNoPID; // No PID for checks\r
\r
  Double_t  fChi2OverNDFCut;   // Limit chi2\r
  Double_t  fMaxdca;           // Limit dca\r
  Double_t  fMaxopeningtheta;  // Limit opening angle in theta\r
  Double_t  fMaxopeningphi;    // Limit opening angle in phi\r
  Double_t  fMaxopening3D;     // Limit opening 3D\r
  Double_t  fMaxInvmass;       // Limit invariant mass\r
  \r
\r
  Int_t     fDebugLevel; // Debug Level  \r
\r
  // Cuts for FLOW PWG2\r
  AliFlowTrackCuts* fcutsRP;  // Reference particle cut\r
  AliFlowTrackCuts* fcutsPOI; // Particle Of Interest cut\r
  \r
  // Cuts for HFE\r
  AliHFEcuts *fHFECuts;           // HFE cuts\r
  AliHFEpid  *fPID;               // PID cuts \r
  AliHFEpidQAmanager *fPIDqa;     // QA Manager\r
  AliFlowEvent *fflowEvent;       //! Flow event \r
\r
  // Cuts for background study\r
  AliESDtrackCuts *fHFEBackgroundCuts;    // HFE background cuts\r
  AliHFEpid  *fPIDBackground;             // PID background cuts \r
  AliHFEpidQAmanager *fPIDBackgroundqa;   // QA Manager Background  \r
  Bool_t fAlgorithmMA;                    // algorithm MA\r
\r
  // List of tracks\r
  TArrayI *fArraytrack;                    // list of tracks\r
  Int_t fCounterPoolBackground;            // number of tracks\r
\r
  // VZERO Event plane after calibration 2010\r
  AliHFEVZEROEventPlane *fHFEVZEROEventPlane; // VZERO event plane calibrated\r
  \r
  // Histos\r
  TH2D *fHistEV;               //! Number of events\r
  \r
  // A Event plane as function of phiepa, phiepb, phiepc, phiepd centrality \r
  // a V0A, b V0C, c TPC, d V0\r
  THnSparseF *fEventPlane;     //! Event plane\r
  \r
  // B Event Plane after subtraction as function of phiep, centrality \r
  THnSparseF *fEventPlaneaftersubtraction; //! Event plane\r
\r
  // Monitoring Event plane: cos2phi, sin2phi, centrality\r
  THnSparseF *fCosSin2phiep;        //! Cos(2phi), Sin(2phi)\r
  \r
  // E Monitoring Event plane after subtraction of the track: cos, centrality, pt, eta\r
  THnSparseF *fCos2phie;  //! Monitoring\r
  THnSparseF *fSin2phie;  //! Monitoring\r
  THnSparseF *fCos2phiep;  //! Monitoring\r
  THnSparseF *fSin2phiep;  //! Monitoring\r
  THnSparseF *fSin2phiephiep;  //! Monitoring\r
\r
  // Fbis Resolution as function of cosres, cosres, cosres, centrality for three subevents (V0)\r
  // a V0A, b V0C, c TPC\r
  THnSparseF *fCosResabc; //! Res\r
  THnSparseF *fSinResabc; //! Res\r
  TProfile   *fProfileCosResab; //! Profile Res_a_b\r
  TProfile   *fProfileCosResac; //! Profile Res_a_c\r
  TProfile   *fProfileCosResbc; //! Profile Res_b_c\r
  \r
  // F Resolution as function of cosres, centrality for two subevents (TPC)\r
  THnSparseF *fCosRes; //! Res\r
  THnSparseF *fSinRes; //! Res\r
  TProfile   *fProfileCosRes; //! Profile Res\r
  \r
  // Debuging Cuts step by step all centrality together: pt, step (6)\r
  THnSparseF *fTrackingCuts; //! Tracking Cuts\r
\r
  // Before PID cut\r
  // G Maps delta phi as function of deltaphi, centrality, pt\r
  THnSparseF *fDeltaPhiMapsBeforePID; //! Delta phi\r
  // H Maps cos phi : cos, centrality, pt\r
  THnSparseF *fCosPhiMapsBeforePID; //! Cos\r
\r
  // G Maps delta phi as function of deltaphi, centrality, pt\r
  THnSparseF *fDeltaPhiMaps; //! Delta phi\r
  // H Maps cos phi : cos, centrality, pt\r
  THnSparseF *fCosPhiMaps;         //! Cos\r
  TProfile2D *fProfileCosPhiMaps;  //! Profile Cos\r
\r
  // Background study: not statistic but tagged \r
  THnSparseF *fDeltaPhiMapsTaggedPhotonic; //! Delta phi\r
  THnSparseF *fCosPhiMapsTaggedPhotonic; //! Cos\r
  THnSparseF *fDeltaPhiMapsTaggedNonPhotonic; //! Delta phi\r
  THnSparseF *fCosPhiMapsTaggedNonPhotonic; //! Cos\r
  THnSparseF *fDeltaPhiMapsTaggedPhotonicLS; //! Delta phi\r
  THnSparseF *fCosPhiMapsTaggedPhotonicLS; //! Cos\r
\r
  // Background study: centrality, pt, source\r
  THnSparseF *fMCSourceDeltaPhiMaps; //! Source MC\r
  // Background study: deltaphi, centrality, pt, minv, source\r
  THnSparseF *fOppSignDeltaPhiMaps;  //! Delta phi\r
  THnSparseF *fSameSignDeltaPhiMaps; //! Delta phi\r
  // Background study: angle, centrality, source\r
  THnSparseF *fOppSignAngle;         // ! Opening Angles\r
  THnSparseF *fSameSignAngle;        // ! Opening Angles\r
\r
  Int_t FindMother(Int_t tr, AliMCEvent *mcEvent, Int_t &indexmother);\r
  Int_t IsMotherGamma(Int_t tr, AliMCEvent* mcEvent);\r
  Int_t IsMotherPi0(Int_t tr, AliMCEvent* mcEvent);\r
  Int_t IsMotherC(Int_t tr, AliMCEvent* mcEvent);\r
  Int_t IsMotherB(Int_t tr, AliMCEvent* mcEvent);\r
  Int_t IsMotherEta(Int_t tr, AliMCEvent* mcEvent);\r
    \r
  \r
  ClassDef(AliAnalysisTaskHFEFlow, 1); // analysisclass\r
};\r
\r
#endif\r