AliAnalysisTaskEmcalEmbeddingHelper.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKEMCALEMBEDDINGHELPER_H
#define ALIANALYSISTASKEMCALEMBEDDINGHELPER_H

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

class TString;
class TChain;
class TFile;
class AliVEvent;
class AliVHeader;
class AliGenPythiaEventHeader;
class AliEmcalList;

#include <iosfwd>
#include <vector>
#include <string>

#include <AliAnalysisTaskSE.h>
#include "AliEventCuts.h"
#include "AliYAMLConfiguration.h"
#include "THistManager.h"

class AliAnalysisTaskEmcalEmbeddingHelper : public AliAnalysisTaskSE {
 public:

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

  void      UserExec(Option_t *option)                           ;
  void      UserCreateOutputObjects()                            ;
  void      Terminate(Option_t *option)                          ;
  /* @} */

  static const AliAnalysisTaskEmcalEmbeddingHelper* GetInstance() { return fgInstance       ; }

  AliVEvent* GetExternalEvent()                             const { return fExternalEvent   ; }

  bool Initialize(bool removeDummyTask = false);

  // Get
  Int_t GetPtHardBin()                                      const { return fPtHardBin; }
  Int_t GetNPtHardBins()                                    const { return fNPtHardBins; }
  TString GetTreeName()                                     const { return fTreeName; }
  Bool_t GetRandomEventNumberAccess()                       const { return fRandomEventNumberAccess; }
  Bool_t GetRandomFileAccess()                              const { return fRandomFileAccess; }
  TString GetFilePattern()                                  const { return fFilePattern; }
  TString GetInputFilename()                                const { return fInputFilename; }
  Int_t GetStartingFileIndex()                              const { return fFilenameIndex; }
  TString GetFileListFilename()                             const { return fFileListFilename; }
  bool GetCreateHistos()                                    const { return fCreateHisto; }

  // Set
  void SetPtHardBin(Int_t n)                                      { fPtHardBin           = n; }
  void SetNPtHardBins(Int_t n)                                    { fNPtHardBins         = n; }
  void SetESD(const char * treeName = "esdTree")                  { fTreeName     = treeName; }
  void SetAOD(const char * treeName = "aodTree")                  { fTreeName     = treeName; }
  void SetRandomEventNumberAccess(Bool_t b)                       { fRandomEventNumberAccess = b; }
  void SetRandomFileAccess(Bool_t b)                              { fRandomFileAccess = b; }
  void SetFilePattern(const char * pattern)                       { fFilePattern = pattern; }
  void SetInputFilename(const char * filename)                    { fInputFilename = filename; }
  void SetStartingFileIndex(Int_t n)                              { fFilenameIndex = n; }
  void SetFileListFilename(const char * filename)                 { fFileListFilename = filename; }
  void SetCreateHistos(bool b)                                    { fCreateHisto = b; }
  void SetConfigurationPath(const char * path)                    { fConfigurationPath = path; }
  /* @} */

  bool GetUseInternalEventSelection()                       const { return fUseInternalEventSelection; }
  void SetUseInternalEventSelection(bool b = true)                { fUseInternalEventSelection = b; }
  bool EmbeddedEventUsed()                                  const { return fEmbeddedEventUsed; }
  bool GetUseManualInternalEventSelection()                 const { return fUseManualInternalEventCuts; }
  void SetUseManualInternalEventCuts(bool b = true)               { fUseManualInternalEventCuts = b; }
  const AliEventCuts * GetInternalEventCuts()               const { return (fUseInternalEventSelection ? &fInternalEventCuts : nullptr); }
  AliEventCuts * GetInternalEventCuts();
  void SetCentralityRange(double min, double max)                 { fCentMin = min; fCentMax = max; }
  /* @} */

  UInt_t GetTriggerMask()                                   const { return fTriggerMask; }
  bool GetMCRejectOutliers()                                const { return fMCRejectOutliers; }
  Double_t GetPtHardJetPtRejectionFactor()                  const { return fPtHardJetPtRejectionFactor; }
  Double_t GetZVertexCut()                                  const { return fZVertexCut; }
  Double_t GetMaxVertexDistance()                           const { return fMaxVertexDist; }

  void SetTriggerMask(UInt_t triggerMask)                         { fTriggerMask = triggerMask; }
  void SetMCRejectOutliers(bool reject = true)                    { fMCRejectOutliers = reject; }
  void SetPtHardJetPtRejectionFactor(double factor)               { fPtHardJetPtRejectionFactor = factor; }
  void SetZVertexCut(Double_t zVertex)                            { fZVertexCut = zVertex; }
  void SetMaxVertexDistance(Double_t distance)                    { fMaxVertexDist = distance; }
  /* @} */

  AliVHeader * GetEventHeader()                             const { return fExternalHeader; }
  AliGenPythiaEventHeader * GetPythiaHeader()               const { return fPythiaHeader; }
  double GetPythiaXSection()                                const { return fPythiaCrossSection; }
  int GetPythiaTrials()                                     const { return fPythiaTrials; }
  double GetPythiaPtHard()                                  const { return fPythiaPtHard; }
  /* @} */

  bool GetAutoConfigurePtHardBins()                         const { return fAutoConfigurePtHardBins; }
  std::string GetAutoConfigureBasePath()                    const { return fAutoConfigureBasePath; }
  std::string GetAutoConfigureTrainTypePath()               const { return fAutoConfigureTrainTypePath; }
  std::string GetAutoConfigureIdentifier()                  const { return fAutoConfigureIdentifier; }

  void SetAutoConfigurePtHardBins(bool configure = true)          { fAutoConfigurePtHardBins = configure; }
  void SetAutoConfigureBasePath(std::string path)                 { fAutoConfigureBasePath = path; }
  void SetAutoConfigureTrainTypePath(std::string path)            { fAutoConfigureTrainTypePath = path; }
  void SetAutoConfigureIdentifier(std::string path)               { fAutoConfigureIdentifier = path; }
  /* @} */

  static AliAnalysisTaskEmcalEmbeddingHelper * AddTaskEmcalEmbeddingHelper();
  static AliAnalysisTaskEmcalEmbeddingHelper* ConfigureEmcalEmbeddingHelperOnLEGOTrain();

  // Printing
  friend std::ostream & operator<<(std::ostream &in, const AliAnalysisTaskEmcalEmbeddingHelper &myTask);
  void Print(Option_t* opt = "") const;
  std::ostream & Print(std::ostream &in) const;
  std::string toString(bool includeFileList = false) const;
  /* @} */

  AliVEvent* InputEvent()                                   const { return GetExternalEvent(); }
  /* @} */

 protected:
  void            RetrieveTaskPropertiesFromYAMLConfig();
  bool            GetFilenames()        ;
  void            DeterminePythiaXSecFilename();
  bool            IsRunInRunlist(const std::string & path) const;
  bool            InitializeYamlConfig();
  bool            AutoConfigurePtHardBins();
  std::string     GenerateUniqueFileListFilename() const;
  std::string     RemoveTrailingSlashes(std::string filename) const;
  void            DetermineFirstFileToEmbed();
  void            SetupEmbedding()      ;
  Bool_t          SetupInputFiles()     ;
  std::string     ConstructFullPythiaXSecFilename(std::string inputFilename, const std::string & pythiaFilename, bool testIfExists) const;
  Bool_t          GetNextEntry()        ;
  void            SetEmbeddedEventProperties();
  void            RecordEmbeddedEventProperties();
  Bool_t          IsEventSelected()     ;
  Bool_t          CheckIsEmbeddedEventSelected();
  Bool_t          InitEvent()           ;
  void            InitTree()            ;
  bool            PythiaInfoFromCrossSectionFile(std::string filename);
  // Helper functions
  bool            IsFileAccessible() const;
  void            ConnectToAliEn() const;
  // LEGO Train utility
  void            RemoveDummyTask() const;

  UInt_t                                        fTriggerMask;       
  bool                                          fMCRejectOutliers;  
  Double_t                                      fPtHardJetPtRejectionFactor; 
  Double_t                                      fZVertexCut;        
  Double_t                                      fMaxVertexDist;     

  bool                                          fInitializedConfiguration; 
  bool                                          fInitializedNewFile; 
  bool                                          fInitializedEmbedding; 
  bool                                          fWrappedAroundTree; 

  TString                                       fTreeName         ; 
  Int_t                                         fNPtHardBins      ; 
  Int_t                                         fPtHardBin        ; 
  Bool_t                                        fRandomEventNumberAccess; 
  Bool_t                                        fRandomFileAccess ; 
  bool                                          fCreateHisto      ; 
  PWG::Tools::AliYAMLConfiguration              fYAMLConfig       ; 

  bool                                  fUseInternalEventSelection; 
  bool                                 fUseManualInternalEventCuts; 
  AliEventCuts                                  fInternalEventCuts; 
  bool                                          fEmbeddedEventUsed; 
  double                                        fCentMin          ; 
  double                                        fCentMax          ; 

  bool                                    fAutoConfigurePtHardBins; 
  std::string                               fAutoConfigureBasePath; 
  std::string                          fAutoConfigureTrainTypePath; 
  std::string                             fAutoConfigureIdentifier; 

  TString                                       fFilePattern      ; 
  TString                                       fInputFilename    ; 
  TString                                       fFileListFilename ; 
  Int_t                                         fFilenameIndex    ; 
  std::vector <std::string>                     fFilenames        ; 
  std::string                                   fConfigurationPath; 
  std::vector <std::string>                     fEmbeddedRunlist  ; 
  std::string                                  fPythiaXSecFilename; 
  std::vector <std::string>                     fPythiaCrossSectionFilenames; 
  TFile                                        *fExternalFile     ; 
  TChain                                       *fChain            ; 
  Int_t                                         fCurrentEntry     ; 
  Int_t                                         fLowerEntry       ; 
  Int_t                                         fUpperEntry       ; 
  Int_t                                         fOffset           ; 
  UInt_t                                        fMaxNumberOfFiles ; 
  UInt_t                                        fFileNumber       ; 
  THistManager                                  fHistManager      ; 
  AliEmcalList                                 *fOutput           ; 
  AliVEvent                                    *fExternalEvent    ; 
  AliVHeader                                   *fExternalHeader   ; 
  AliGenPythiaEventHeader                      *fPythiaHeader     ; 

  int                                           fPythiaTrials     ; 
  int                                           fPythiaTrialsFromFile; 
  double                                        fPythiaCrossSection; 
  double                                        fPythiaCrossSectionFromFile; 
  double                                        fPythiaPtHard     ; 

  static AliAnalysisTaskEmcalEmbeddingHelper   *fgInstance        ; 

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

  ClassDef(AliAnalysisTaskEmcalEmbeddingHelper, 10);
};
#endif