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();
  static AliAnalysisTaskJetExtractor* AddTaskJetExtractor(TString trackArray, TString jetArray, TString rhoObject, Double_t jetRadius, TString configFile, AliRDHFJetsCutsVertex* vertexerCuts, const char* taskNameSuffix);
  void                        UserCreateOutputObjects();
  void                        Terminate(Option_t *option);
  AliEmcalJetTree*            GetJetTree() {return fJetTree;}

  void                        ActivateTrueJetMatching(const char* arrayName, const char* rhoName) 
                                {fTruthJetsArrayName = arrayName; fTruthJetsRhoName = rhoName;}
  void                        SetTrueJetRhoMassName(const char* rhoName) 
                                {fTruthJetsRhoMassName = rhoName;}
  void                        SetTrueParticleArrayName(const char* partArrayName) 
                                {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; }
  void                        SetEventPercentage(Double_t val)                    { fEventPercentage  = val; }
  void                        SetTruthLabelRange(Int_t min, Int_t max)            { fTruthMinLabel = min; fTruthMaxLabel = max; }
  void                        SetSaveTrackPDGCode(Bool_t val)                     { fSaveTrackPDGCode = val; }
  void                        SetRandomSeed(ULong_t val)                          { fRandomSeed  = val; }
  void                        SetRandomSeedCones(ULong_t val)                     { fRandomSeedCones  = val; }

  void                        SetEventCutTriggerTrack(Double_t minPt, Double_t maxPt, Int_t minLabel=-9999999, Int_t maxLabel=+9999999)
                                { fEventCut_TriggerTrackMinPt = minPt; fEventCut_TriggerTrackMaxPt = maxPt; fEventCut_TriggerTrackMinLabel = minLabel;
                                  fEventCut_TriggerTrackMaxLabel = maxLabel;}

 protected:
  Bool_t                      CreateControlHistograms();
  void                        ExecOnce();
  Bool_t                      Run();
  Bool_t                      IsTriggerTrackInEvent();
  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, Int_t& truePID);
  Bool_t                      IsTrackInCone(AliVParticle* track, Double_t eta, Double_t phi, Double_t radius);
  Double_t                    GetTrueJetPtFraction(AliEmcalJet* jet);
  Double_t                    GetMatchedTrueJetObservables(AliEmcalJet* jet, Double_t& matchedJetPt, Double_t& matchedJetMass);
  void                        GetJetType(AliEmcalJet* jet, Int_t& typeHM, Int_t& typePM, Int_t& typeIC);
  Bool_t                      IsStrangeJet(AliEmcalJet* jet);
  void                        PrintConfig();

  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;                      
  Double_t                    fEventPercentage;                         
  Int_t                       fTruthMinLabel;                           
  Int_t                       fTruthMaxLabel;                           
  Bool_t                      fSaveTrackPDGCode;                        
  ULong_t                     fRandomSeed;                              
  ULong_t                     fRandomSeedCones;                         

  // ################## EVENT CUTS
  Double_t                    fEventCut_TriggerTrackMinPt;              
  Double_t                    fEventCut_TriggerTrackMaxPt;              
  Int_t                       fEventCut_TriggerTrackMinLabel;           
  Int_t                       fEventCut_TriggerTrackMaxLabel;           

  // ################## BASIC EVENT VARIABLES
  AliJetContainer            *fJetsCont;                                
  AliParticleContainer       *fTracksCont;                              
  TClonesArray*               fTruthParticleArray;                      
  TString                     fTruthJetsArrayName;                      
  TString                     fTruthJetsRhoName;                        
  TString                     fTruthJetsRhoMassName;                    
  TString                     fTruthParticleArrayName;                  
  TRandom3*                   fRandomGenerator;                         
  TRandom3*                   fRandomGeneratorCones;                    
  Double_t                    fEventWeight;                             
  Double_t                    fImpactParameter;                         


  std::vector<Float_t>        fTriggerTracks_Pt;                         
  std::vector<Float_t>        fTriggerTracks_Eta;                        
  std::vector<Float_t>        fTriggerTracks_Phi;                        


  // ################## 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;
static std::vector<Int_t>   DEFAULT_VECTOR_INT;
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            SetSaveTriggerTracks(Bool_t val) {fSaveTriggerTracks = val;}
    void            SetTrackContainer(AliParticleContainer* cont) {fTrackContainer = cont;}
    void            SetJetContainer(AliJetContainer* cont) {fJetContainer = cont;}
    void            SetRandomGenerator(TRandom3* gen) {fRandomGenerator = gen;}

    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;}
    Bool_t          GetSaveTriggerTracks() {return fSaveTriggerTracks;}

    std::vector<Float_t> GetExtractionPercentagePtBins() {return fExtractionPercentagePtBins;}
    std::vector<Float_t> GetExtractionPercentages() {return fExtractionPercentages;}
    std::vector<Int_t> GetExtractionJetTypes_HM() {return fExtractionJetTypes_HM;}
    std::vector<Int_t> GetExtractionJetTypes_PM() {return fExtractionJetTypes_PM;}

    TTree*          GetTreePointer() {return fJetTree;}

    // ######################################
    Bool_t          AddJetToTree(AliEmcalJet* jet, Float_t vertexX = 0, Float_t vertexY = 0, Float_t vertexZ = 0, Float_t centrality = 0, Long64_t eventID = 0, Float_t magField = 0,
      Int_t motherParton = 0, Int_t motherHadron = 0, Int_t partonInitialCollision = 0, Float_t matchDistance = 0, Float_t matchedPt = 0, Float_t matchedMass = 0, Float_t truePtFraction = 0, Float_t ptHard = 0, Float_t eventWeight = 0, Float_t impactParameter = 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<Int_t>& trackPID_Truth = DEFAULT_VECTOR_INT,
      std::vector<Float_t>& triggerTrackPt = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& triggerTrackDeltaEta = DEFAULT_VECTOR_FLOAT, std::vector<Float_t>& triggerTrackDeltaPhi = DEFAULT_VECTOR_FLOAT,
      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, vertexX, vertexY, vertexZ, centrality, eventID, magField, motherParton, motherHadron, partonInitialCollision, matchDistance, matchedPt, matchedMass, truePtFraction, ptHard, eventWeight, impactParameter,
        trackPID_ITS.data(), trackPID_TPC.data(), trackPID_TOF.data(), trackPID_TRD.data(), trackPID_Reco.data(), trackPID_Truth.data(),
        triggerTrackPt.size(), triggerTrackPt.data(), triggerTrackDeltaEta.data(), triggerTrackDeltaPhi.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 vertexX, Float_t vertexY, Float_t vertexZ, Float_t centrality, Long64_t eventID, Float_t magField,
      Int_t motherParton, Int_t motherHadron, Int_t partonInitialCollision, Float_t matchDistance, Float_t matchedPt, Float_t matchedMass, Float_t truePtFraction, Float_t ptHard, Float_t eventWeight,  Float_t impactParameter,
      Float_t* trackPID_ITS, Float_t* trackPID_TPC, Float_t* trackPID_TOF, Float_t* trackPID_TRD, Short_t* trackPID_Reco, Int_t* trackPID_Truth,
      Int_t numTriggerTracks, Float_t* triggerTrackPt, Float_t* triggerTrackDeltaEta, Float_t* triggerTrackDeltaPhi,
      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;               
    Bool_t          fSaveTriggerTracks;                   

    AliParticleContainer* fTrackContainer;                
    AliJetContainer*      fJetContainer;                  
    TRandom3*             fRandomGenerator;               

    // 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_BackgroundDensityMass;  
    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_Event_Weight;                 
    Float_t         fBuffer_Event_ImpactParameter;        

    Float_t*        fBuffer_Const_Pt;                     
    Float_t*        fBuffer_Const_Eta;                    
    Float_t*        fBuffer_Const_Phi;                    
    Float_t*        fBuffer_Const_Charge;                 
    Int_t*          fBuffer_Const_Label;                  
    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_MatchDistance;         
    Float_t         fBuffer_Jet_MC_MatchedPt;             
    Float_t         fBuffer_Jet_MC_MatchedMass;           
    Float_t         fBuffer_Jet_MC_TruePtFraction;        

    Int_t           fBuffer_NumTriggerTracks;
    Int_t           fBuffer_NumSecVertices;


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

#endif