AliAnalysisTaskJetExtractor.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKJETEXTRACTOR_H
#define ALIANALYSISTASKJETEXTRACTOR_H

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

class THn;
class AliAODVertex;
class AliBasicJet;
class AliBasicJetConstituent;

//###############################################################################################################################################3

// 
class AliAnalysisTaskJetExtractor : public AliAnalysisTaskEmcalJet {
 public:

  AliAnalysisTaskJetExtractor();
  AliAnalysisTaskJetExtractor(const char *name);
  virtual ~AliAnalysisTaskJetExtractor();
  void                        UserCreateOutputObjects();
  void                        Terminate(Option_t *option);

  // ################## SETTERS
  void                        SetExtractionCuts(Double_t percentage, Double_t minPt, Double_t maxPt, Int_t minCent = -1, Int_t maxCent = -1)
  {
    fExtractionPercentage = percentage;
    fExtractionCutMinPt = minPt;
    fExtractionCutMaxPt = maxPt;
    fExtractionCutMinCent = minCent;
    fExtractionCutMaxCent = maxCent;
  }

  void                        SetHadronMatchingRadius(Double_t val) { fHadronMatchingRadius = val; }
  void                        SetInitialCollisionMatchingRadius(Double_t val)     { fInitialCollisionMatchingRadius = val; }
  void                        SetTruthParticleArrayName(const char* val)     { fTruthParticleArrayName = val; }
  void                        SetSecondaryVertexMaxChi2(Double_t val   )     { fSecondaryVertexMaxChi2 = val; }
  void                        SetSecondaryVertexMaxDispersion(Double_t val)  { fSecondaryVertexMaxDispersion = val; }
  void                        SetAddPIDSignal(Bool_t val)  { fAddPIDSignal = val; }

  void                        SetExtractionCutListPIDHM(const char* val)
  { 
    fExtractionListPIDsHM.clear();
    TString tmpStr = val;
    TObjArray* tmpArr = tmpStr.Tokenize(",");
    for (Int_t i=0; i<tmpArr->GetEntries(); i++)
    {
      Int_t val = atoi((static_cast<TObjString*>(tmpArr->At(i)))->GetString().Data());
      fExtractionListPIDsHM.push_back(val);
    }
    fExtractionCutUseHM = kTRUE;
    fExtractionCutUseIC = kFALSE;
  }

  void                        SetExtractionCutListPIDIC(const char* val)
  { 
    fExtractionListPIDsIC.clear();
    TString tmpStr = val;
    TObjArray* tmpArr = tmpStr.Tokenize(",");
    for (Int_t i=0; i<tmpArr->GetEntries(); i++)
    {
      Int_t val = atoi((static_cast<TObjString*>(tmpArr->At(i)))->GetString().Data());
      fExtractionListPIDsIC.push_back(val);
    }
    fExtractionCutUseIC = kTRUE;
    fExtractionCutUseHM = kFALSE;
  }
  // ##################

 protected:
  Bool_t                      CreateControlHistograms();
  void                        ExecOnce();
  Bool_t                      Run();
  // ##################
  Bool_t                      IsJetSelected(AliEmcalJet* jet);
  void                        AddJetToTree(AliEmcalJet* jet);
  // ##################
  void                        FillEventControlHistograms();
  void                        FillJetControlHistograms(AliEmcalJet* jet);
  // ##################
  void                        CalculateEventProperties();
  void                        CalculateInitialCollisionJets();
  void                        GetLeadingJets(const char* opt, AliEmcalJet*& jetLeading, AliEmcalJet*& jetSubLeading);

  void                        CalculateJetProperties(AliEmcalJet* jet);
  void                        CalculateJetType(AliEmcalJet* jet, Int_t& typeIC, Int_t& typeHM);
  Double_t                    GetTrackImpactParameter(const AliVVertex* vtx, AliAODTrack* track);
  void                        AddSecondaryVertices(const AliVVertex* vtx, AliEmcalJet* jet, AliBasicJet& basicJet);
  void                        AddPIDInformation(AliVParticle* particle, AliBasicJetConstituent& constituent);


  // ################## BASIC EVENT VARIABLES
  AliJetContainer            *fJetsCont;                                
  AliTrackContainer          *fTracksCont;                              
  TTree*                      fJetsTree;                                
  void*                       fJetsTreeBuffer;                          
  TRandom3*                   fRandom;                                  

  // ################## CURRENT PROPERTIES
  Int_t                       fCurrentNJetsInEvents;                    
  Int_t                       fCurrentJetTypeHM;                        
  Int_t                       fCurrentJetTypeIC;                        
  AliEmcalJet*                fCurrentLeadingJet;                       
  AliEmcalJet*                fCurrentSubleadingJet;                    
  AliEmcalJet*                fCurrentInitialParton1;                   
  AliEmcalJet*                fCurrentInitialParton2;                   
  Int_t                       fCurrentInitialParton1Type;               
  Int_t                       fCurrentInitialParton2Type;               
  Bool_t                      fFoundIC;                                 

  // ################## CUTS
  Int_t                       fExtractionCutMinCent;                    
  Int_t                       fExtractionCutMaxCent;                    
  Bool_t                      fExtractionCutUseIC;                      
  Bool_t                      fExtractionCutUseHM;                      
  Double_t                    fExtractionCutMinPt;                      
  Double_t                    fExtractionCutMaxPt;                      
  Double_t                    fExtractionPercentage;                    
  std::vector<Int_t>          fExtractionListPIDsHM;                    
  std::vector<Int_t>          fExtractionListPIDsIC;                    


  Double_t                    fHadronMatchingRadius;                    
  Double_t                    fInitialCollisionMatchingRadius;          
  TString                     fTruthParticleArrayName;                  
  Double_t                    fSecondaryVertexMaxChi2;                  
  Double_t                    fSecondaryVertexMaxDispersion;            
  Bool_t                      fAddPIDSignal;                            


  // ######### HISTOGRAM 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

// 
class AliBasicPID
{
  public:
    AliBasicPID() : fSignalITS(0), fSignalTPC(0), fSignalTOF(0), fSignalTRD(0), fTruthPID(9), fRecoPID(9)  {}
    AliBasicPID(Float_t its, Float_t tpc, Float_t tof, Float_t trd, Short_t truthPID, Short_t recoPID)
    : fSignalITS(its), fSignalTPC(tpc), fSignalTOF(tof), fSignalTRD(trd), fTruthPID(truthPID), fRecoPID(recoPID)
    {
    }
    ~AliBasicPID();

    Float_t SignalITS()        { return fSignalITS; }
    Float_t SignalTPC()        { return fSignalTPC; }
    Float_t SignalTOF()        { return fSignalTOF; }
    Float_t SignalTRD()        { return fSignalTRD; }
    Short_t TruthPID()         { return fTruthPID; }
    Short_t RecoPID()          { return fRecoPID; }

  private:
    Float_t fSignalITS;      
    Float_t fSignalTPC;      
    Float_t fSignalTOF;      
    Float_t fSignalTRD;      
    Short_t fTruthPID;       
    Short_t fRecoPID;        
};

//###############################################################################################################################################3

// 
class AliBasicJetConstituent
{
  public:
    AliBasicJetConstituent() : fEta(0), fPhi(0), fpT(0), fCharge(0), fVx(0), fVy(0), fVz(0), fImpactParameter(0), fPID(0) {}
    AliBasicJetConstituent(Float_t eta, Float_t phi, Float_t pt, Short_t charge, Float_t vx, Float_t vy, Float_t vz, Float_t z)
    : fEta(eta), fPhi(phi), fpT(pt), fCharge(charge), fVx(vx), fVy(vy), fVz(vz), fImpactParameter(z), fPID(0)
    {
    }
    ~AliBasicJetConstituent();

    Float_t Pt()        { return fpT; }
    Float_t Phi()       { return fPhi; }
    Float_t Eta()       { return fEta; }
    Short_t Charge()    { return fCharge; }

    Float_t Vx()        { return fVx; }
    Float_t Vy()        { return fVy; }
    Float_t Vz()        { return fVz; }

    Float_t ImpactParameter() { return fImpactParameter; }
    AliBasicPID* PID()  { return &fPID.at(0); }

    void SetPIDSignal(Float_t its, Float_t tpc, Float_t tof, Float_t trd, Short_t truthPID, Short_t recoPID)
    { 
      if(fPID.size()) fPID.clear();
      AliBasicPID* newPID = new AliBasicPID(its,tpc,tof,trd,truthPID,recoPID);
      fPID.push_back(*newPID);
    }

  private:
    Float_t fEta;      
    Float_t fPhi;      
    Float_t fpT;       
    Short_t fCharge;   

    Float_t fVx;       
    Float_t fVy;       
    Float_t fVz;       

    Float_t fImpactParameter; 
    std::vector<AliBasicPID> fPID; 
};

//###############################################################################################################################################3

// 
class AliBasicJetSecondaryVertex
{
  public:
    AliBasicJetSecondaryVertex() : fVx(0), fVy(0), fVz(0), fChi2(0), fDispersion(0) {}
    AliBasicJetSecondaryVertex(Float_t vx, Float_t vy, Float_t vz, Float_t chi2, Float_t dispersion)
    : fVx(vx), fVy(vy), fVz(vz), fChi2(chi2), fDispersion(dispersion)
    {
    }
    ~AliBasicJetSecondaryVertex();

    Float_t Vx()        { return fVx; }
    Float_t Vy()        { return fVy; }
    Float_t Vz()        { return fVz; }

    Float_t Chi2()      { return fChi2; }
    Float_t Dispersion(){ return fDispersion; }
  private:

    Float_t fVx;         
    Float_t fVy;         
    Float_t fVz;         
    Float_t fChi2;       
    Float_t fDispersion; 
};

//###############################################################################################################################################3
// 
class AliBasicJet
{
  public:
    AliBasicJet() : fEta(0), fPhi(0), fpT(0), fTruepT(0), fCharge(0), fRadius(0), fArea(0), fMotherInitialCollision(0), fMotherHadronMatching(0), fBackgroundDensity(0), fMagneticField(0), fVertexX(0), fVertexY(0), fVertexZ(0), fEventID(0), fCentrality(0), fConstituents() {}
    AliBasicJet(Float_t eta, Float_t phi, Float_t pt, Short_t charge, Float_t radius, Float_t area, Int_t partidIC, Int_t partidHM, Float_t bgrd, Float_t magfield, Float_t vtxX, Float_t vtxY, Float_t vtxZ, Long64_t id, Short_t cent)
    : fEta(eta), fPhi(phi), fpT(pt), fCharge(charge), fRadius(radius), fArea(area), fMotherInitialCollision(partidIC), fMotherHadronMatching(partidHM), fBackgroundDensity(bgrd), fMagneticField(magfield), fVertexX(vtxX), fVertexY(vtxY), fVertexZ(vtxZ), fEventID(id), fCentrality(cent), fConstituents()
    {}
    ~AliBasicJet();

    // Basic jet properties
    Double_t                  Pt()       { return fpT; }
    Double_t                  TruePt()  { return fTruepT; }
    Double_t                  Phi()      { return fPhi; }
    Double_t                  Eta()      { return fEta; }
    Short_t                   Charge()   { return fCharge; }
    Double_t                  Radius() { return fRadius; }
    Double_t                  Area() { return fArea; }
    Int_t                     MotherInitialCollision() { return fMotherInitialCollision; }
    Int_t                     MotherHadronMatching() { return fMotherHadronMatching; }
    Double_t                  BackgroundDensity() { return fBackgroundDensity; }
    Double_t                  MagneticField() { return fMagneticField; }
    Double_t                  VertexX() { return fVertexX; }
    Double_t                  VertexY() { return fVertexY; }
    Double_t                  VertexZ() { return fVertexZ; }
    Long64_t                  EventID() { return fEventID; }
    Short_t                   Centrality() { return fCentrality; }
    Int_t                     GetNumbersOfConstituents() { return fConstituents.size(); }
    Int_t                     GetNumbersOfSecVertices() { return fSecondaryVertices.size(); }
    void                      SetTruePt(Double_t val)  {fTruepT = val;}

    // Basic constituent functions
    AliBasicJetConstituent*   GetJetConstituent(Int_t index) { return &fConstituents[index]; }
    void                      AddJetConstituent(Float_t eta, Float_t phi, Float_t pt, Short_t charge, Float_t vx=0, Float_t vy=0, Float_t vz=0, Float_t z=0)
    {
      AliBasicJetConstituent c (eta, phi, pt, charge, vx, vy, vz, z);
      AddJetConstituent(&c);
    }
    void                      AddJetConstituent(AliBasicJetConstituent* constituent) {fConstituents.push_back(*constituent); }

    // Basic secondary vertex functions
    AliBasicJetSecondaryVertex* GetSecondaryVertex(Int_t index) { return &fSecondaryVertices[index]; }
    void                      AddSecondaryVertex(Float_t vx, Float_t vy, Float_t vz, Float_t chi2=0, Float_t dispersion=0)
    {
      AliBasicJetSecondaryVertex vtx (vx, vy, vz, chi2, dispersion);
      AddSecondaryVertex(&vtx);
    }
    void                      AddSecondaryVertex(AliBasicJetSecondaryVertex* vtx) {fSecondaryVertices.push_back(*vtx);}

  private:
    Float_t   fEta;      
    Float_t   fPhi;      
    Float_t   fpT;       
    Float_t   fTruepT;   
    Short_t   fCharge;   
    Float_t   fRadius;   
    Float_t   fArea;     
    Int_t     fMotherInitialCollision;  
    Int_t     fMotherHadronMatching;    
    Float_t   fBackgroundDensity; 
    Float_t   fMagneticField; 
    Float_t   fVertexX; 
    Float_t   fVertexY; 
    Float_t   fVertexZ; 
    Long64_t  fEventID;  
    Short_t   fCentrality; 

    std::vector<AliBasicJetSecondaryVertex> fSecondaryVertices; 
    std::vector<AliBasicJetConstituent> fConstituents; 

};


#endif