AliAnalysisTaskChargedJetsHadronCF.h

Go to the documentation of this file.

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

// 

class THn;

class AliAnalysisTaskChargedJetsHadronCF : public AliAnalysisTaskEmcalJet {
 public:

  AliAnalysisTaskChargedJetsHadronCF();
  AliAnalysisTaskChargedJetsHadronCF(const char *name);
  virtual ~AliAnalysisTaskChargedJetsHadronCF();

  void                        UserCreateOutputObjects();
  void                        Terminate(Option_t *option);

  // ######### SETTERS/GETTERS
  void                        ActivateJetMatching(const char* matchArray, Double_t maxDistance, Double_t minSharedFraction, Double_t matchMinPt, Double_t matchMaxPt, Int_t nLeading)
  {
    fJetMatchingMaxDistance = maxDistance;
    fJetMatchingArrayName = matchArray;
    fJetMatchingMinSharedFraction = minSharedFraction;
    fJetMatchingMinPt = matchMinPt;
    fJetMatchingMaxPt = matchMaxPt;
    fJetMatchingUseOnlyNLeading = nLeading; // currently only 1,2, or 0 (all) possible
  }

  void                        SetNumberOfCentralityBins(Int_t val)   { fNumberOfCentralityBins = val; }
  void                        SetJetParticleArrayName(const char* name)   { fJetParticleArrayName = name; }
  void                        SetTrackParticleArrayName(const char* name) { fTrackParticleArrayName = name; }

  void                        SetJetOutputMode(Int_t mode) {fJetOutputMode = mode;}
  void                        SetPythiaExtractionMode(Int_t mode) {fPythiaExtractionMode = mode;}

  void                        SetEventCriteriumBackground(Double_t minValue, Double_t maxValue)   {fEventCriteriumMinBackground = minValue; fEventCriteriumMaxBackground = maxValue;}
  void                        SetEventCriteriumLeadingJets(Double_t leading, Double_t subleading, Double_t dphi) {fEventCriteriumMinLeadingJetPt = leading; fEventCriteriumMinSubleadingJetPt = subleading; fEventCriteriumMinJetDeltaPhi = dphi;}
  void                        SetEventCriteriumSelection(Int_t type);

  void                        ActivateJetExtraction(Double_t percentage, Double_t minPt, Double_t maxPt) {fExtractionPercentage = percentage; fExtractionMinPt = minPt; fExtractionMaxPt = maxPt;}
  void                        ActivateEventExtraction(Double_t percentage, Double_t minJetPt, Double_t maxJetPt) {fEventExtractionPercentage = percentage; fEventExtractionMinJetPt = minJetPt; fEventExtractionMaxJetPt = maxJetPt;}

 protected:
  void                        ExecOnce();
  Bool_t                      Run();

  // ######### META FUNCTIONS
  void                        BinLogAxis(const THn *h, Int_t axisNumber);
  void                        AddJetToTree(AliEmcalJet* jet);
  void                        AddEventToTree();
  void                        AddJetToOutputArray(AliEmcalJet* jet);
  void                        AddTrackToOutputArray(AliVTrack* track);
  void                        FillHistogramsTracks(AliVTrack* track);
  void                        FillHistogramsJets(AliEmcalJet* jet);
  void                        FillHistogramsJetConstituents(AliEmcalJet* jet);
  Bool_t                      IsJetSelected(AliEmcalJet* jet);
  Bool_t                      IsEventCriteriumFulfilled();

  AliJetContainer            *fJetsCont;                                
  AliTrackContainer          *fTracksCont;                              
  TTree*                      fJetsTree;                                
  void*                       fJetsTreeBuffer;                          
  Double_t                    fExtractionPercentage;                    
  Double_t                    fExtractionMinPt;                         
  Double_t                    fExtractionMaxPt;                         
  Double_t                    fEventExtractionPercentage;               
  Double_t                    fEventExtractionMinJetPt;                 
  Double_t                    fEventExtractionMaxJetPt;                 
  
  Int_t                       fNumberOfCentralityBins;                  
  TClonesArray               *fJetsOutput;                              
  TClonesArray               *fTracksOutput;                            
  TString                     fJetParticleArrayName;                    
  TString                     fTrackParticleArrayName;                  
  TClonesArray               *fJetMatchingArray;                        
  TString                     fJetMatchingArrayName;                    
  Double_t                    fJetMatchingMaxDistance;                  
  Double_t                    fJetMatchingMinSharedFraction;            
  Double_t                    fJetMatchingMinPt;                        
  Double_t                    fJetMatchingMaxPt;                        
  Int_t                       fJetMatchingUseOnlyNLeading;              
  std::vector<AliEmcalJet*>   fMatchedJets;                             
  std::vector<AliEmcalJet*>   fMatchedJetsReference;                    
  TRandom3*                   fRandom;                                  


  // Criteria for the selection of jets that are passed to the correlation task
  Int_t                       fJetOutputMode;                           
  Double_t                    fMinFakeFactorPercentage;                 
  Double_t                    fMaxFakeFactorPercentage;                 
  Int_t                       fPythiaExtractionMode;                    
  Int_t                       fEventCriteriumMode;                      
  Double_t                    fEventCriteriumMinBackground;             
  Double_t                    fEventCriteriumMaxBackground;             
  Double_t                    fEventCriteriumMinLeadingJetPt;           
  Double_t                    fEventCriteriumMinSubleadingJetPt;        
  Double_t                    fEventCriteriumMinJetDeltaPhi;            

  // Event properties
  AliEmcalJet*                fLeadingJet;                              
  AliEmcalJet*                fSubleadingJet;                           
  AliEmcalJet*                fInitialPartonMatchedJet1;                
  AliEmcalJet*                fInitialPartonMatchedJet2;                
  Int_t                       fAcceptedJets;                            
  Int_t                       fAcceptedTracks;                          

  // ######### 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");

  // ######### HELPER FUNCTIONS
  Bool_t                      IsTrackInCone(AliVParticle* track, Double_t eta, Double_t phi, Double_t radius);
  Double_t                    CalculateFakeFactor(AliEmcalJet* jet);
  void                        GetInitialCollisionJets();
  void                        GetMatchingJets();

  void                        GetLeadingJets(const char* opt, AliEmcalJet*& jetLeading, AliEmcalJet*& jetSubLeading);
  void                        CalculateEventProperties();


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

  ClassDef(AliAnalysisTaskChargedJetsHadronCF, 7) // Charged jet+h analysis support task
};


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

// 
class AliBasicJetConstituent : public TObject
{
  public:
    AliBasicJetConstituent() : fEta(0), fPhi(0), fpT(0), fCharge(0), fPID(0) {}
    AliBasicJetConstituent(Float_t eta, Float_t phi, Float_t pt, Short_t charge, Short_t pid)
    : fEta(eta), fPhi(phi), fpT(pt), fCharge(charge), fPID(pid)
    {
    }
    ~AliBasicJetConstituent();

    Bool_t   IsEqual(const TObject* obj) { return (obj->GetUniqueID() == GetUniqueID()); }
    Double_t Pt()       { return fpT; }
    Double_t Phi()      { return fPhi; }
    Double_t Eta()      { return fEta; }
    Short_t  Charge()   { return fCharge; }
    Short_t  PID()      { return fPID; }

  private:
    Float_t fEta;      
    Float_t fPhi;      
    Float_t fpT;       
    Short_t fCharge;   
    Short_t fPID;      
  ClassDef( AliBasicJetConstituent, 2); // very basic jet constituent object
};

//###############################################################################################################################################3
// 
class AliBasicJet : public TObject
{
  public:
    AliBasicJet() : fEta(0), fPhi(0), fpT(0), fTruepT(0), fCharge(0), fRadius(0), fArea(0), fPDGCode(0), fBackgroundDensity(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, Float_t partid, Float_t bgrd, Long64_t id, Short_t cent)
    : fEta(eta), fPhi(phi), fpT(pt), fCharge(charge), fRadius(radius), fArea(area), fPDGCode(partid), fBackgroundDensity(bgrd), fEventID(id), fCentrality(cent), fConstituents()
    {}
    ~AliBasicJet();

    // Basic jet properties
    Bool_t                    IsEqual(const TObject* obj) { return (obj->GetUniqueID() == GetUniqueID()); }
    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                     PDGCode() { return fPDGCode; }
    Double_t                  BackgroundDensity() { return fBackgroundDensity; }
    Long64_t                  EventID() { return fEventID; }
    Short_t                   Centrality() { return fCentrality; }
    Int_t                     GetNumbersOfConstituents() { return fConstituents.size(); }

    // 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, Short_t pid=0)
    {
      AliBasicJetConstituent c (eta, phi, pt, charge, pid);
      AddJetConstituent(&c);
    }
    void                      AddJetConstituent(AliBasicJetConstituent* constituent) {fConstituents.push_back(*constituent); }
    void                      SetTruePt(Double_t val)  {fTruepT = val;}


  private:
    Float_t   fEta;      
    Float_t   fPhi;      
    Float_t   fpT;       
    Float_t   fTruepT;   
    Short_t   fCharge;   
    Float_t   fRadius;   
    Float_t   fArea;     
    Int_t     fPDGCode;  
    Float_t   fBackgroundDensity; 
    Long64_t  fEventID;  
    Short_t   fCentrality; 

    std::vector<AliBasicJetConstituent> fConstituents; 

  ClassDef( AliBasicJet, 4); // very basic jet object
};
#endif