AliEmcalCorrectionTask.h

Go to the documentation of this file.

#ifndef ALIEMCALCORRECTIONTASK_H
#define ALIEMCALCORRECTIONTASK_H



#if !(defined(__CINT__) || defined(__MAKECINT__))
#include <yaml-cpp/yaml.h>
#endif

#include "AliAnalysisTaskSE.h"
#include <Rtypes.h>

// Base component
class AliEmcalCorrectionComponent;
// Geometry
class AliEMCALGeometry;

#include "AliParticleContainer.h"
#include "AliMCParticleContainer.h"
#include "AliTrackContainer.h"
#include "AliClusterContainer.h"

class AliEmcalCorrectionTask : public AliAnalysisTaskSE {
 public:
  enum BeamType {
    kNA       = -1,
    kpp       = 0, 
    kAA       = 1, 
    kpA       = 2  
  };

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

  // Methods from AliAnalysisTaskSE
  void UserCreateOutputObjects();
  void UserExec(Option_t * option);
  Bool_t UserNotify();

  // Functions that can be overloaded by users
  virtual void ExecOnce();
  virtual Bool_t Run();

  // Options
  void SetUserConfigurationFilename(std::string name) { fUserConfigurationFilename = name; }
  void SetDefaultConfigurationFilename(std::string name) { fDefaultConfigurationFilename = name; }

  void InitializeConfiguration();

  // Containers and cells
  AliParticleContainer       *AddParticleContainer(const char *n);
  AliTrackContainer          *AddTrackContainer(const char *n);
  AliMCParticleContainer     *AddMCParticleContainer(const char *n);
  AliClusterContainer        *AddClusterContainer(const char *n);
  void                        AdoptParticleContainer(AliParticleContainer* cont)    { fParticleCollArray.Add(cont)                        ; }
  void                        AdoptTrackContainer(AliTrackContainer* cont)          { AdoptParticleContainer(cont)                        ; }
  void                        AdoptMCParticleContainer(AliMCParticleContainer* cont){ AdoptParticleContainer(cont)                        ; }
  void                        AdoptClusterContainer(AliClusterContainer* cont)      { fClusterCollArray.Add(cont)                         ; }
  AliParticleContainer       *GetParticleContainer(Int_t i=0)         const;
  AliParticleContainer       *GetParticleContainer(const char* name)  const;
  AliClusterContainer        *GetClusterContainer(Int_t i=0)          const;
  AliClusterContainer        *GetClusterContainer(const char* name)   const;
  AliMCParticleContainer     *GetMCParticleContainer(Int_t i=0)               const { return dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(i))   ; }
  AliMCParticleContainer     *GetMCParticleContainer(const char* name)        const { return dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(name)); }
  AliTrackContainer          *GetTrackContainer(Int_t i=0)                    const { return dynamic_cast<AliTrackContainer*>(GetParticleContainer(i))        ; }
  AliTrackContainer          *GetTrackContainer(const char* name)             const { return dynamic_cast<AliTrackContainer*>(GetParticleContainer(name))     ; }
  void                        RemoveParticleContainer(Int_t i=0)                    { fParticleCollArray.RemoveAt(i)                      ; } 
  void                        RemoveClusterContainer(Int_t i=0)                     { fClusterCollArray.RemoveAt(i)                       ; } 
  void                        SetCaloCellsName(const char* name)                    { fCaloCellsName = name; }

  void                        SetForceBeamType(BeamType f)                          { fForceBeamType     = f                              ; }
  void                        SetRunPeriod(const char* runPeriod)                   { fRunPeriod = runPeriod; fRunPeriod.ToLower(); }
  const TString &             GetRunPeriod()                                  const { return fRunPeriod; }

  void                        SetCreateNewObjectBranches(bool flag)                 { fCreateNewObjectBranches = flag; }
  void                        SetUseNewCentralityEstimation(Bool_t b)               { fUseNewCentralityEstimation = b                     ; }

  const std::vector<AliEmcalCorrectionComponent *> & CorrectionComponents() { return fCorrectionComponents; }

  bool WriteConfigurationFile(std::string filename, bool userConfig = false);

 private:
  AliEmcalCorrectionTask(const AliEmcalCorrectionTask &);             // Not implemented
  AliEmcalCorrectionTask &operator=(const AliEmcalCorrectionTask &);  // Not implemented

  static inline bool doesFileExist(const std::string & filename);
  void SetupConfigurationFilePath(std::string & filename, bool userFile = false);

  void RetrieveExecutionOrder(std::vector <std::string> & componentsToAdd);
  void InitializeComponents();

  void                        CreateNewObjectBranches();
  void                        CopyBranchesToNewObjects();
  void                        CopyClusters(TClonesArray *orig, TClonesArray *dest);
  void                        CleanupCreatedBranches();

  Bool_t                      RetrieveEventObjects();
  void                        ExecOnceComponents();

  BeamType                    GetBeamType();

#if !(defined(__CINT__) || defined(__MAKECINT__))
  YAML::Node              fUserConfiguration;             
  YAML::Node              fDefaultConfiguration;          
#endif

  std::string             fUserConfigurationString;       
  std::string             fDefaultConfigurationString;    

  std::string fUserConfigurationFilename;                 
  std::string fDefaultConfigurationFilename;              

  std::vector <AliEmcalCorrectionComponent *> fCorrectionComponents; 
  bool fConfigurationInitialized;                         

  bool                        fIsEsd;                      
  bool                        fCreateNewObjectBranches;    
  std::string                 fCreatedClusterBranchName;   
  std::string                 fCreatedTrackBranchName;     
  TString                     fRunPeriod;                  
  bool                        fEventInitialized;           
  Double_t                    fCent;                       
  Int_t                       fCentBin;                    
  Double_t                    fMinCent;                    
  Double_t                    fMaxCent;                    
  Int_t                       fNcentBins;                  
  TString                     fCentEst;                    
  Bool_t                      fUseNewCentralityEstimation; 
  Double_t                    fVertex[3];                  
  Int_t                       fNVertCont;                  
  BeamType                    fBeamType;                   
  BeamType                    fForceBeamType;              
  TString                     fCaloCellsName;              
  Bool_t                      fNeedEmcalGeom;              
  AliEMCALGeometry           *fGeom;                       

  TObjArray                   fParticleCollArray;         
  TObjArray                   fClusterCollArray;          
  AliVCaloCells               *fCaloCells;                
  AliVCaloCells               *fCaloCellsFromInputEvent;  
  
  TList * fOutput;                                        

  ClassDef(AliEmcalCorrectionTask, 1); // EMCal correction task
};

#endif /* ALIEMCALCORRECTIONTASK_H */