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;

//###############################################################################################################################################3
// 
class AliChargedJetsHadronCFCuts
{
 public:
  AliChargedJetsHadronCFCuts() {;}
  AliChargedJetsHadronCFCuts(const char* cutName, const char* outputName, Double_t minPt, Double_t maxPt, Double_t minCent, Double_t maxCent, Double_t lowerOffset, Double_t offset2D, Double_t slope2D)
  {
    fCutName = cutName;
    fOutputName = outputName;
    fPtMin = minPt;
    fPtMax = maxPt;
    fCentMin = minCent;
    fCentMax = maxCent;

    fCutLowerPercentageOffset = lowerOffset;
    fCut2DOffset = offset2D;
    fCut2DSlope = slope2D;

    fAcceptedJets = 0;
    fArrayIndex = -1;
  }
  Bool_t IsCutFulfilled(Double_t pt, Double_t mcPt, Double_t cent, Double_t ptRatio)
  {
    // Simple kinematic cuts
    if(pt < fPtMin || pt >= fPtMax)
      return kFALSE;
    if(cent < fCentMin || cent >= fCentMax)
      return kFALSE;

    // Lower MC percentage cut
    if(ptRatio < fCutLowerPercentageOffset)
      return kFALSE;

    // Value of the 2D cut line. We cut everything above that
    Double_t cutLineValue = fCut2DSlope*mcPt + fCut2DOffset;
    if(ptRatio > cutLineValue)
      return kFALSE;

    return kTRUE;
  }

  ~AliChargedJetsHadronCFCuts();
  TString     fCutName;                              
  TString     fOutputName;                           
  Double_t    fPtMin;                                
  Double_t    fPtMax;                                
  Double_t    fCentMin;                              
  Double_t    fCentMax;                              

  Double_t    fCutLowerPercentageOffset;             
  Double_t    fCut2DOffset;                          
  Double_t    fCut2DSlope;                           

  Int_t       fAcceptedJets;                         
  Int_t       fArrayIndex;                           
};

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

// 
class AliAnalysisTaskChargedJetsHadronCF : public AliAnalysisTaskEmcalJet {
 public:

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

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

  // ######### SETTERS/GETTERS
  void                        ActivateJetEmbedding(const char* embArray, const char* embTrackArray, Double_t maxDistance, Int_t numMatchedJets)
  {
    fJetEmbeddingMaxDistance      = maxDistance;
    fJetEmbeddingArrayName        = embArray;
    fJetEmbeddingTrackArrayName   = embTrackArray;
    fJetEmbeddingNumMatchedJets   = numMatchedJets;
  }
  void                        ActivateJetVetoInEmbedding(const char* vetoArray, Double_t jetVetoMinPt, Double_t jetVetoMaxPt, Bool_t jetVetoJetByJet)
  {
    fJetVetoArrayName = vetoArray;
    fJetVetoMinPt     = jetVetoMinPt;
    fJetVetoMaxPt     = jetVetoMaxPt;
    fJetVetoJetByJet  = jetVetoJetByJet;
  }
  void                        AddJetEmbeddingCut(const char* cutName, const char* outputName, Double_t minPt, Double_t maxPt, Double_t minCent, Double_t maxCent, Double_t lowerOffset, Double_t offset2D, Double_t slope2D)
  {
    AliChargedJetsHadronCFCuts tmpCut(cutName, outputName, minPt, maxPt, minCent, maxCent, lowerOffset, offset2D, slope2D);
    fJetEmbeddingCuts.push_back(tmpCut);
  }

  void                        SetUsePerTrackMCPercentage(Bool_t val)   { fJetEmbeddingUsePerTrackMCPercentage = val; }
  void                        SetUseBgrdForMCPercentage(Bool_t val)   { fJetEmbeddingUseBgrdForMCPercentage = val; }
  void                        SetConstPtFilterBit(Int_t val)   { fConstPtFilterBit = val; }
  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                        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, const char* cutName);
  Bool_t                      IsJetSelected(AliEmcalJet* jet);

  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                       fConstPtFilterBit;                        
  Int_t                       fNumberOfCentralityBins;                  
  std::vector<TClonesArray*>  fJetsOutput;                              
  TClonesArray               *fTracksOutput;                            
  TString                     fJetParticleArrayName;                    
  TString                     fTrackParticleArrayName;                  
  TClonesArray               *fJetEmbeddingArray;                       
  TString                     fJetEmbeddingArrayName;                   
  TString                     fJetEmbeddingTrackArrayName;              
  Double_t                    fJetEmbeddingMaxDistance;                 
  Int_t                       fJetEmbeddingNumMatchedJets;              
  Bool_t                      fJetEmbeddingUsePerTrackMCPercentage;     
  Bool_t                      fJetEmbeddingUseBgrdForMCPercentage;      
  std::vector<AliChargedJetsHadronCFCuts> fJetEmbeddingCuts;            

  TClonesArray               *fJetVetoArray;                            
  TString                     fJetVetoArrayName;                        
  Double_t                    fJetVetoMinPt;                            
  Double_t                    fJetVetoMaxPt;                            
  Bool_t                      fJetVetoJetByJet;                         
  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;                           
  Int_t                       fPythiaExtractionMode;                    

  // 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
  void                        GetTrackMCRatios(AliEmcalJet* jet, AliEmcalJet* mcJet, Double_t& trackRatio, Double_t& ptRatio);
  Bool_t                      IsJetVetoed(AliEmcalJet* jet);
  AliEmcalJet*                GetReferenceJet(AliEmcalJet* jet);
  Bool_t                      IsTrackInCone(AliVParticle* track, Double_t eta, Double_t phi, Double_t radius);
  void                        GetInitialCollisionJets();
  void                        GetMatchingJets();

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


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

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


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

// 
class AliBasicJetConstituent
{
  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();

    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;      
};

//###############################################################################################################################################3
// 
class AliBasicJet
{
  public:
    AliBasicJet() : fEta(0), fPhi(0), fpT(0), fTruepT(0), fCharge(0), fRadius(0), fArea(0), fPDGCode(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, Float_t partid, 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), fPDGCode(partid), 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                     PDGCode() { return fPDGCode; }
    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(); }

    // 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; 
    Float_t   fMagneticField; 
    Float_t   fVertexX; 
    Float_t   fVertexY; 
    Float_t   fVertexZ; 
    Long64_t  fEventID;  
    Short_t   fCentrality; 

    std::vector<AliBasicJetConstituent> fConstituents; 

};


#endif