AliAnalysisTaskJetExtractor.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKJETEXTRACTOR_H
#define ALIANALYSISTASKJETEXTRACTOR_H

/* Copyright(c) 1998-2018, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */


//###############################################################################################################################################3
class AliRDHFJetsCutsVertex;
class AliEmcalJetTree;
class AliHFJetsTaggingVertex;

// 
class AliAnalysisTaskJetExtractor : public AliAnalysisTaskEmcalJet {
 public:

  AliAnalysisTaskJetExtractor();
  AliAnalysisTaskJetExtractor(const char *name);
  virtual ~AliAnalysisTaskJetExtractor();
  void                        UserCreateOutputObjects();
  void                        Terminate(Option_t *option);
  AliEmcalJetTree*            GetJetTree() {return fJetTree;}

  void                        ActivateTrueJetMatching(const char* arrayName, const char* rhoName, const char* partArrayName = "mcparticles") 
                                {fTruthJetsArrayName = arrayName; fTruthJetsRhoName = rhoName; fTruthParticleArrayName = partArrayName;}
  void                        SetHadronMatchingRadius(Double_t val)               { fHadronMatchingRadius  = val; }
  void                        SetTrueJetMatchingRadius(Double_t val)              { fTrueJetMatchingRadius = val; }
  void                        SetSecondaryVertexMaxChi2(Double_t val   )          { fSecondaryVertexMaxChi2 = val; }
  void                        SetSecondaryVertexMaxDispersion(Double_t val)       { fSecondaryVertexMaxDispersion = val; }
  void                        SetCalculateSecondaryVertices(Bool_t val)           { fCalculateSecondaryVertices = val; }
  void                        SetVertexerCuts(AliRDHFJetsCutsVertex* val)         { fVertexerCuts = val; }
  void                        SetSetEmcalJetFlavour(Bool_t val)                   { fSetEmcalJetFlavour = val; }

 protected:
  Bool_t                      CreateControlHistograms();
  void                        ExecOnce();
  Bool_t                      Run();
  void                        FillTrackControlHistograms(AliVTrack* track);
  void                        FillEventControlHistograms();
  void                        FillJetControlHistograms(AliEmcalJet* jet);
  void                        AddPIDInformation(AliVParticle* particle, Float_t& sigITS, Float_t& sigTPC, Float_t& sigTOF, Float_t& sigTRD, Short_t& recoPID, Short_t& truePID);
  Bool_t                      IsTrackInCone(AliVParticle* track, Double_t eta, Double_t phi, Double_t radius);
  void                        GetJetTruePt(AliEmcalJet* jet, Double_t& matchedJetPt, Double_t& truePtFraction);
  void                        GetJetType(AliEmcalJet* jet, Int_t& typeHM, Int_t& typePM, Int_t& typeIC);
  Bool_t                      IsStrangeJet(AliEmcalJet* jet);

  void                        GetTrackImpactParameters(const AliVVertex* vtx, AliAODTrack* track, Float_t& d0, Float_t& d0cov, Float_t& z0, Float_t& z0cov);
  void                        ReconstructSecondaryVertices(const AliVVertex* primVtx, const AliEmcalJet* jet, std::vector<Float_t>& secVtx_X, std::vector<Float_t>& secVtx_Y, std::vector<Float_t>& secVtx_Z,
                                  std::vector<Float_t>& secVtx_Mass, std::vector<Float_t>& secVtx_Lxy, std::vector<Float_t>& secVtx_SigmaLxy, std::vector<Float_t>& secVtx_Chi2, std::vector<Float_t>& secVtx_Dispersion);

  AliEmcalJetTree*            fJetTree;
  AliHFJetsTaggingVertex*     fVtxTagger;                               
  Double_t                    fHadronMatchingRadius;                    
  Double_t                    fTrueJetMatchingRadius;                   
  Double_t                    fSecondaryVertexMaxChi2;                  
  Double_t                    fSecondaryVertexMaxDispersion;            
  Bool_t                      fCalculateSecondaryVertices;              
  AliRDHFJetsCutsVertex*      fVertexerCuts;                            
  Bool_t                      fSetEmcalJetFlavour;                      



  // ################## BASIC EVENT VARIABLES
  AliJetContainer            *fJetsCont;                                
  AliTrackContainer          *fTracksCont;                              
  TClonesArray*               fTruthParticleArray;                      
  TString                     fTruthJetsArrayName;                      
  TString                     fTruthJetsRhoName;                        
  TString                     fTruthParticleArrayName;                  

  // ################## HISTOGRAM HELPER FUNCTIONS
  void                        FillHistogram(const char * key, Double_t x);
  void                        FillHistogram(const char * key, Double_t x, Double_t y);
  void                        FillHistogram(const char * key, Double_t x, Double_t y, Double_t add);
  void                        FillHistogram3D(const char * key, Double_t x, Double_t y, Double_t z, Double_t add = 0);
  template <class T> T*       AddHistogram1D(const char* name = "CustomHistogram", const char* title = "NO_TITLE", const char* options = "", Int_t xBins = 100, Double_t xMin = 0.0, Double_t xMax = 20.0, const char* xTitle = "x axis", const char* yTitle = "y axis");
  template <class T> T*       AddHistogram2D(const char* name = "CustomHistogram", const char* title = "NO_TITLE", const char* options = "", Int_t xBins = 100, Double_t xMin = 0.0, Double_t xMax = 20.0, Int_t yBins = 100, Double_t yMin = 0.0, Double_t yMax = 20.0,  const char* xTitle = "x axis", const char* yTitle = "y axis", const char* zTitle = "z axis");
  template <class T> T*       AddHistogram3D(const char* name = "CustomHistogram", const char* title = "NO_TITLE", const char* options = "", Int_t xBins = 100, Double_t xMin = 0.0, Double_t xMax = 20.0, Int_t yBins = 100, Double_t yMin = 0.0, Double_t yMax = 20.0, Int_t zBins = 100, Double_t zMin = 0.0, Double_t zMax = 20.0, const char* xTitle = "x axis", const char* yTitle = "y axis", const char* zTitle = "z axis");



 private:
  AliAnalysisTaskJetExtractor(const AliAnalysisTaskJetExtractor&);            // not implemented
  AliAnalysisTaskJetExtractor &operator=(const AliAnalysisTaskJetExtractor&); // not implemented

  ClassDef(AliAnalysisTaskJetExtractor, 1) // Jet extraction task
};


//###############################################################################################################################################3
static std::vector<Float_t> DEFAULT_VECTOR_FLOAT;
static std::vector<Short_t> DEFAULT_VECTOR_SHORT;
const Int_t kMaxNumConstituents = 500;
// 
class AliEmcalJetTree : public TNamed
{
  public:
    AliEmcalJetTree();
    AliEmcalJetTree(const char* name);

    // ############ SETTERS
    void            AddExtractionPercentage(Float_t minPt, Float_t maxPt, Float_t percentage)
    {
      fExtractionPercentagePtBins.push_back(minPt);
      fExtractionPercentagePtBins.push_back(maxPt);
      fExtractionPercentages.push_back(percentage);
    }

    void            AddExtractionJetTypeHM(Int_t type) {fExtractionJetTypes_HM.push_back(type);}
    void            AddExtractionJetTypePM(Int_t type) {fExtractionJetTypes_PM.push_back(type);}

    void            ResetExtractionPercentages() {fExtractionPercentages.clear(); fExtractionPercentagePtBins.clear();}

    void            SetSaveEventProperties(Bool_t val) {fSaveEventProperties = val; fInitialized = kFALSE;}
    void            SetSaveConstituents(Bool_t val) {fSaveConstituents = val; fInitialized = kFALSE;}
    void            SetSaveConstituentsIP(Bool_t val) {fSaveConstituentsIP = val; fInitialized = kFALSE;}
    void            SetSaveConstituentPID(Bool_t val) {fSaveConstituentPID = val; fInitialized = kFALSE;}
    void            SetSaveJetShapes(Bool_t val) {fSaveJetShapes = val; fInitialized = kFALSE;}
    void            SetSaveMCInformation(Bool_t val) {fSaveMCInformation = val; fInitialized = kFALSE;}
    void            SetSaveSecondaryVertices(Bool_t val) {fSaveSecondaryVertices = val; fInitialized = kFALSE;}

    void            InitializeTree();

    // ############ GETTERS
    Bool_t          GetSaveEventProperties() {return fSaveEventProperties;}
    Bool_t          GetSaveConstituents() {return fSaveConstituents;}
    Bool_t          GetSaveConstituentsIP() {return fSaveConstituentsIP;}
    Bool_t          GetSaveConstituentPID() {return fSaveConstituentPID;}
    Bool_t          GetSaveJetShapes() {return fSaveJetShapes;}
    Bool_t          GetSaveMCInformation() {return fSaveMCInformation;}
    Bool_t          GetSaveSecondaryVertices() {return fSaveSecondaryVertices;}

    std::vector<Float_t> GetExtractionPercentagePtBins() {return fExtractionPercentagePtBins;}
    std::vector<Float_t> GetExtractionPercentages() {return fExtractionPercentages;}

    TTree*          GetTreePointer() {return fJetTree;}

    // ######################################
    Bool_t          AddJetToTree(AliEmcalJet* jet, Float_t bgrdDensity = 0, Float_t vertexX = 0, Float_t vertexY = 0, Float_t vertexZ = 0, Float_t centrality = 0, Long64_t eventID = 0, Float_t magField = 0,
      AliTrackContainer* trackCont = 0, Int_t motherParton = 0, Int_t motherHadron = 0, Int_t partonInitialCollision = 0, Float_t matchedPt = 0, Float_t truePtFraction = 0, Float_t ptHard = 0,
      std::vector<Float_t>& trackPID_ITS = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& trackPID_TPC = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& trackPID_TOF = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& trackPID_TRD = DEFAULT_VECTOR_FLOAT, std::vector<Short_t>& trackPID_Reco = DEFAULT_VECTOR_SHORT, std::vector<Short_t>& trackPID_Truth = DEFAULT_VECTOR_SHORT,
      std::vector<Float_t>& trackIP_d0 = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& trackIP_z0 = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& trackIP_d0cov = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& trackIP_z0cov = DEFAULT_VECTOR_FLOAT,
      std::vector<Float_t>& secVtx_X = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_Y = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_Z = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_Mass = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_Lxy = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_SigmaLxy = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_Chi2 = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& secVtx_Dispersion = DEFAULT_VECTOR_FLOAT)
    {
      return AddJetToTree(jet, bgrdDensity, vertexX, vertexY, vertexZ, centrality, eventID, magField, trackCont, motherParton, motherHadron, partonInitialCollision, matchedPt, truePtFraction, ptHard,
        trackPID_ITS.data(), trackPID_TPC.data(), trackPID_TOF.data(), trackPID_TRD.data(), trackPID_Reco.data(), trackPID_Truth.data(),
        trackIP_d0.data(), trackIP_z0.data(), trackIP_d0cov.data(), trackIP_z0cov.data(),
        secVtx_X.size(), secVtx_X.data(), secVtx_Y.data(), secVtx_Z.data(), secVtx_Mass.data(), secVtx_Lxy.data(), secVtx_SigmaLxy.data(), secVtx_Chi2.data(), secVtx_Dispersion.data());
    }
    Bool_t          AddJetToTree(AliEmcalJet* jet, Float_t bgrdDensity, Float_t vertexX, Float_t vertexY, Float_t vertexZ, Float_t centrality, Long64_t eventID, Float_t magField,
      AliTrackContainer* trackCont, Int_t motherParton, Int_t motherHadron, Int_t partonInitialCollision, Float_t matchedPt, Float_t truePtFraction, Float_t ptHard,
      Float_t* trackPID_ITS, Float_t* trackPID_TPC, Float_t* trackPID_TOF, Float_t* trackPID_TRD, Short_t* trackPID_Reco, Short_t* trackPID_Truth,
      Float_t* trackIP_d0, Float_t* trackIP_z0, Float_t* trackIP_d0cov, Float_t* trackIP_z0cov,
      Int_t numSecVertices, Float_t* secVtx_X, Float_t* secVtx_Y, Float_t* secVtx_Z, Float_t* secVtx_Mass, Float_t* secVtx_Lxy, Float_t* secVtx_SigmaLxy, Float_t* secVtx_Chi2, Float_t* secVtx_Dispersion);
    // ######################################

  private:
    TTree*          fJetTree;                             
    Bool_t          fInitialized;                         

    // Save flags
    Bool_t          fSaveEventProperties;                 
    Bool_t          fSaveConstituents;                    
    Bool_t          fSaveConstituentsIP;                  
    Bool_t          fSaveConstituentPID;                  
    Bool_t          fSaveJetShapes;                       
    Bool_t          fSaveMCInformation;                   
    Bool_t          fSaveSecondaryVertices;               

    // Option flags
    std::vector<Float_t> fExtractionPercentages;          
    std::vector<Float_t> fExtractionPercentagePtBins;     
    std::vector<Int_t>   fExtractionJetTypes_HM;          
    std::vector<Int_t>   fExtractionJetTypes_PM;          

    // Buffers that will be added to the tree
    Float_t         fBuffer_JetPt;                        
    Float_t         fBuffer_JetEta;                       
    Float_t         fBuffer_JetPhi;                       
    Float_t         fBuffer_JetArea;                      
    Int_t           fBuffer_NumConstituents;              

    Float_t         fBuffer_Event_BackgroundDensity;      
    Float_t         fBuffer_Event_Vertex_X;               
    Float_t         fBuffer_Event_Vertex_Y;               
    Float_t         fBuffer_Event_Vertex_Z;               
    Float_t         fBuffer_Event_Centrality;             
    Long64_t        fBuffer_Event_ID;                     
    Float_t         fBuffer_Event_MagneticField;          
    Float_t         fBuffer_Event_PtHard;                 

    Float_t*        fBuffer_Const_Pt;                     
    Float_t*        fBuffer_Const_Eta;                    
    Float_t*        fBuffer_Const_Phi;                    
    Float_t*        fBuffer_Const_Charge;                 
    Float_t*        fBuffer_Const_ProdVtx_X;              
    Float_t*        fBuffer_Const_ProdVtx_Y;              
    Float_t*        fBuffer_Const_ProdVtx_Z;              

    Float_t         fBuffer_Shape_Mass;                   

    Int_t           fBuffer_Jet_MC_MotherParton;          
    Int_t           fBuffer_Jet_MC_MotherHadron;          
    Int_t           fBuffer_Jet_MC_MotherIC;              
    Float_t         fBuffer_Jet_MC_MatchedPt;             
    Float_t         fBuffer_Jet_MC_TruePtFraction;        

    Int_t           fBuffer_NumSecVertices;


    ClassDef(AliEmcalJetTree, 1) // Jet tree class
};

#endif