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 AliBasicParticle;
class AliAODPid;

//###############################################################################################################################################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, Double_t jetVetoPt)
  {
    fCutName = cutName;
    fOutputName = outputName;
    fPtMin = minPt;
    fPtMax = maxPt;
    fCentMin = minCent;
    fCentMax = maxCent;

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

    fJetVetoPt = jetVetoPt;

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

    // jet veto
    if(vetoPt >= fJetVetoPt)
      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    fJetVetoPt;                            

  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                        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, Double_t jetVetoPt)
  {
    AliChargedJetsHadronCFCuts tmpCut(cutName, outputName, minPt, maxPt, minCent, maxCent, lowerOffset, offset2D, slope2D, jetVetoPt);
    fJetEmbeddingCuts.push_back(tmpCut);
  }

  void                        SetJetVetoArrayName(const char* name)   { fJetVetoArrayName = name; }
  void                        SetJetVetoJetByJet(Bool_t val)          { fJetVetoJetByJet = val; }
  void                        SetUsePerTrackMCPercentage(Bool_t val)   { fJetEmbeddingUsePerTrackMCPercentage = val; }
  void                        SetUseBgrdForMCPercentage(Bool_t val)   { fJetEmbeddingUseBgrdForMCPercentage = val; }
  void                        SetCreateEmbeddingPtPlotPerCut(Bool_t val)   { fJetEmbeddingCreatePtPlotPerCut = 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                        ActivateEventExtraction(Double_t percentage, Double_t minJetPt, Double_t maxJetPt) {fEventExtractionPercentage = percentage; fEventExtractionMinJetPt = minJetPt; fEventExtractionMaxJetPt = maxJetPt;}
  void                        SetTrackExtractionPercentagePower(Double_t val)   { fTrackExtractionPercentagePower = val; }

  void                        SetNumRandomConesPerEvent(Int_t val)   { fNumRandomConesPerEvent = val; }

  void                        SetUseConstituents(Bool_t data, Bool_t mc)   { fUseDataConstituents = data; fUseMCConstituents = mc;}

  void                        SetRemoveEventOutliers(Bool_t val)   { fRemoveEventOutliers = val; }


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

  // ######### META FUNCTIONS
  void                        BinLogAxis(const THn *h, Int_t axisNumber);
  void                        AddEventToTree();
  void                        AddJetToOutputArray(AliEmcalJet* jet, Int_t arrayIndex, Int_t& jetsAlreadyInArray);
  void                        AddTrackToOutputArray(AliVTrack* track);
  void                        AddTrackToTree(AliVTrack* track);
  void                        FillHistogramsTracks(AliVTrack* track);
  void                        FillHistogramsJets(AliEmcalJet* jet, const char* cutName);
  Bool_t                      IsJetSelected(AliEmcalJet* jet);

  AliJetContainer            *fJetsCont;                                
  AliTrackContainer          *fTracksCont;                              
  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;      
  Bool_t                      fJetEmbeddingCreatePtPlotPerCut;          
  std::vector<AliChargedJetsHadronCFCuts> fJetEmbeddingCuts;            

  TClonesArray               *fJetVetoArray;                            
  TString                     fJetVetoArrayName;                        
  Bool_t                      fJetVetoJetByJet;                         
  std::vector<AliEmcalJet*>   fMatchedJets;                             
  std::vector<AliEmcalJet*>   fMatchedJetsReference;                    
  TRandom3*                   fRandom;                                  
  TTree*                      fTracksTree;                              
  AliBasicParticle*           fTreeBufferTrack;                         
  AliAODPid*                  fTreeBufferPID;                           
  Int_t                       fTreeBufferPDG;                           
  Double_t                    fTrackExtractionPercentagePower;          
  Int_t                       fNumRandomConesPerEvent;                  

  Bool_t                      fUseDataConstituents;                     
  Bool_t                      fUseMCConstituents;                       
  Bool_t                      fRemoveEventOutliers;                     

  // Criteria for the selection of jets that are passed to the correlation task
  Int_t                       fJetOutputMode;                           

  // 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                        CalculateJetType(AliEmcalJet* jet, Int_t& typeIC, Int_t& typeHM);
  void                        GetTrackMCRatios(AliEmcalJet* jet, AliEmcalJet* mcJet, Double_t& trackRatio, Double_t& ptRatio);
  AliEmcalJet*                GetVetoJet(AliEmcalJet* jet);
  AliEmcalJet*                GetLeadingVetoJet();

  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, 12) // Charged jet+h analysis support task
};



#endif