AliAnalysisTaskdPhi.h

Go to the documentation of this file.

//--------------------------------------------- 
// Class doing conversion gamma dPhi correlations
// Gamma Conversion analysis
//---------------------------------------------

#ifndef AliAnalysisTaskdPhi_cxx
#define AliAnalysisTaskdPhi_cxx

#include "AliAnalysisTaskSE.h"

#include <TAxis.h>
#include <TH3I.h>
#include <THnSparse.h>
#include <THn.h>

//#include <AliAnalysisFilter.h>
#include <iostream>
//#include <AliAnaConvCorrBase.h>
#include <AliLog.h>
#include <AliAnalysisCuts.h>
//class AliAnaConvCorrPion;
class AliConvEventCuts;
class AliConversionPhotonCuts;
class AliConversionMesonCuts;
class AliV0ReaderV1;
class TList;
class TH2I;
//class THnSparseF;

using namespace std;

class AliAnalysisTaskdPhi : public AliAnalysisTaskSE {
  
public:
  AliAnalysisTaskdPhi(const char *name="slindal_dPhi");
  virtual ~AliAnalysisTaskdPhi();
  
  virtual void   UserCreateOutputObjects();
  //virtual void   SetUpCorrObjects();
  //  virtual void   SetUpCorrAxes(AliAnaConvCorrBase * corr);
  virtual void   SetUpBins();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);
  
  TAxis& GetAxistPt()     { return fAxistPt;      }
  TAxis& GetAxiscPt()     { return fAxiscPt;      }
  TAxis& GetAxisdEta()    { return fAxisdEta;     }
  TAxis& GetAxisTrigEta() { return fAxisTrigEta;  }
  TAxis& GetAxisAssEta()  { return fAxisAssEta;   }
  TAxis& GetAxisPhi()     { return fAxisdPhi;     }
  TAxis& GetAxisZ()       { return fAxisZ;        }
  TAxis& GetAxisCent()    { return fAxisCent;     }
  TAxis& GetAxisPiMass()  { return fAxisPiM;      }
  
  void SetV0Filter(AliConvEventCuts * filterEvent, AliConversionPhotonCuts * filter) { fV0FilterEvent=filterEvent, fV0FilterPhoton = filter; }
  void AddEventFilter(TObject * filter, Bool_t high = kTRUE) { fEventFilters[high].AddLast(filter); }
  void AddV0Filter(TObject * filter, Bool_t high = kTRUE) { fV0Filters[high].AddLast(filter); }
  void AddMesonFilter(TObject * filter, Bool_t high = kTRUE) { fMesonFilters[high].AddLast(filter); }
  void AddTrackFilter(TObject * filter, Bool_t high = kTRUE) { fTrackFilters[high].AddLast(filter); }
  void SetCorrectionMap(THnF * map)  { fCorrectionMap = map; }

  void SetEventFilter(AliConvEventCuts * filter) { fEventFilter = filter; }
  void SetMesonFilter(AliConversionMesonCuts * filter) { fMesonFilter = filter; }
  void SetPhotonFilter(AliConversionPhotonCuts * filter) { fPhotonFilter = filter; }
  void SetV0Reader(AliV0ReaderV1 * reader) { fV0Reader = reader; }
  void SaveReaderHists(Bool_t save = kTRUE) { fSaveReaderHists = save; }
  AliAnalysisCuts * GetTrackCuts() const { return fTrackFilter; }
  void SetTrackFilter( AliAnalysisCuts * cuts) { if (fTrackFilter) delete fTrackFilter; fTrackFilter = cuts; }
  
protected:
  
  TClonesArray * GetConversionGammas(Bool_t isAOD);
  
private:

  //void CorrelateWithTracks(AliAODConversionParticle * particle, TObjArray tracks[], Int_t ntrackfilters, Bool_t ** lowtrackmap, Int_t nltf, Int_t const tIDs[4], Double_t dphiValues[]);
  //void FillCounters(TObjArray * particles, TObjArray tracks[], Int_t ntrackfilters, Float_t cent, Float_t vtxz);

  Double_t GetTrackCorrection(Double_t vtxz, AliVTrack * track);

  
  Float_t GetDPhi(Float_t dPhi) { 
    if ( dPhi < 3*TMath::PiOver2() && dPhi > - TMath::PiOver2() ) return dPhi;
    else return ( (dPhi>0)? dPhi - TMath::TwoPi() : dPhi + TMath::TwoPi() ); 
  }

  THnSparseF * CreateSparse(TString nameString, TString titleString, TList * axesList);
  Int_t GetBin(TAxis &axis, Double_t value);
  THnSparseF * GetMEHistogram(Int_t binz, Int_t binc, TObjArray * array);
  //  AliAnaConvCorrBase * GetCorrObject(Int_t binz, Int_t binc, TObjArray * array);
  void Process(TObjArray * gammas, TObjArray * tracks, Float_t cent, Float_t vtxz);
  void FindDeltaAODBranchName(AliVEvent * event);
  

  TList               *fHistograms;           //histograms
  THnSparseF            *fCorrSparse;
  THnSparseF            *fTrigSparse;
  THnSparseF            *fTrackSparse;
  THnSparseF            *fMassSparse;

  AliV0ReaderV1           *fV0Reader;           // V0 reader
  Bool_t              fSaveReaderHists;         // save histograms from v0 reader
  AliConvEventCuts        *fV0FilterEvent;        // additional v0 filter on top of v0 reader
  AliConversionPhotonCuts     *fV0FilterPhoton;         // additional v0 filter on top of v0 reader
  TObjArray             fV0Filters[2];          // Array of v0 filters, increasingly loose ideally.
  TObjArray             fEventFilters[2];         // Array of event filters, increasingly loose ideally.
  AliConvEventCuts        *fEventFilter;          // additional v0 filter for events only
  AliConversionPhotonCuts     *fPhotonFilter;         // additional v0 filter for photons only
  AliConversionMesonCuts      *fMesonFilter;          // additional meson filter behind fv0filter
  TObjArray             fMesonFilters[2];         // Array of Meson filters
  AliAnalysisCuts         *fTrackFilter;          // Cuts for corr tracks
  TObjArray             fTrackFilters[2];         // Array of track cuts

  TObjArray             fGammas;
  TObjArray             fTracks;
  //Int_t                 fTFBin;             // Axis for track filters

  TH2I              *hMEvents;            // event histrogam
  TH2I              *hTrackCent;          // event histrogam
  TH3F              *hTrigPt;             // trigger pt
  TH2F              *hTrackPt;            // track pt
  TH1F              *hTrigPhi;            // trigger phi

  //AliAnaConvCorrBase *        fPhotonCorr;          // photon
  //AliAnaConvCorrPion *        fPionCorr;            // pion

  TString             fDeltaAODBranchName;      // comment

  TAxis               fAxistPt;           // comment
  TAxis               fAxiscPt;           // comment
  TAxis               fAxisdEta;            // comment
  TAxis               fAxisTrigEta;         // comment
  TAxis               fAxisAssEta;          // comment
  TAxis               fAxisdPhi;            // comment
  TAxis               fAxisCent;            // comment
  TAxis               fAxisZ;             // comment
  TAxis               fAxisPiM;           // comment
  TAxis               fAxisTrackFilters;        // comment
  TAxis               fAxisV0Filters;         // comment
  TAxis               fAxisMesonFilters;        // comment
  Bool_t              fkTrackAxis;          // on or off
  Bool_t              fkV0Axis;             // on or off
  Bool_t              fkPionAxis;           // on or off

  TList               fAxesList;            // dphi axes list
  TList               fTrigAxesList;          // Trigger axes list
  TList               fTrackAxesList;         // Trackociated particles axes list
  TList               fMassAxesList;          // Mass vs pt sparse

  Bool_t              fDoPhoton;            // do photon analysis?
  THnF *              fCorrectionMap;

  
  AliAnalysisTaskdPhi(const AliAnalysisTaskdPhi&); // not implemented
  AliAnalysisTaskdPhi& operator=(const AliAnalysisTaskdPhi&); // not implemented
  
  ClassDef(AliAnalysisTaskdPhi, 11); 
};

inline THnSparseF * AliAnalysisTaskdPhi::GetMEHistogram(Int_t binz, Int_t binc, TObjArray * array) {
  if(binz < 0 || binz > fAxisZ.GetNbins()) {
    cout << "error out of z axis range: " << binz << endl; 
    return NULL;
  }  
  if(binc < 0 || binc >= fAxisCent.GetNbins()) {
    cout << "error out of centraliy axis range: " << binc << endl; 
    return NULL;
  }  
  
  TObjArray * arrayc = static_cast<TObjArray*>(array->At(binc));
  THnSparseF * histogram = static_cast<THnSparseF*>(arrayc->At(binz));
  return histogram;
}


// inline AliAnaConvCorrBase * AliAnalysisTaskdPhi::GetCorrObject(Int_t binz, Int_t binc, TObjArray * array) {
//   ///Get correlation object
//   if(binc < 0 || binz < 0) {
//    AliError("We have a bad bin!!!");
//    return NULL;
//  }

//   TObjArray * arrayc = static_cast<TObjArray*>(array->At(binc));
//   AliAnaConvCorrBase * corrmaker = static_cast<AliAnaConvCorrBase*>(arrayc->At(binz));
//   return corrmaker;
// }

inline Int_t AliAnalysisTaskdPhi::GetBin(TAxis & axis, Double_t value) {
  //Return bin - 1 if within range, else return -1
  Int_t bin = axis.FindFixBin(value);
  bin = (bin > 0 && bin <= axis.GetNbins()) ? bin -1 : -1;
  return bin;
}

#endif