AliEmcalCorrectionTask.h

Go to the documentation of this file.

#ifndef ALIEMCALCORRECTIONTASK_H
#define ALIEMCALCORRECTIONTASK_H

// CINT can't handle the yaml header!
#if !(defined(__CINT__) || defined(__MAKECINT__))
#include <yaml-cpp/yaml.h>
#endif

class AliEmcalCorrectionCellContainer;
class AliEmcalCorrectionComponent;
class AliEMCALGeometry;
class AliVEvent;

#include "AliAnalysisTaskSE.h"
#include "AliParticleContainer.h"
#include "AliMCParticleContainer.h"
#include "AliTrackContainer.h"
#include "AliClusterContainer.h"
#include "AliVCluster.h"
#include "AliEmcalTrackSelection.h"

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

  enum InputObject_t {
    kNoDefinedInputObject = -1,    
    kCaloCells = 0,                
    kCluster = 1,                  
    kTrack = 2,                    
  };

#if !(defined(__CINT__) || defined(__MAKECINT__))
  // Hidden from CINT since it cannot handle these maps well
  std::map <std::string, AliVCluster::VCluUserDefEnergy_t> clusterEnergyTypeMap = {
    {"kNonLinCorr", AliVCluster::kNonLinCorr },
    {"kHadCorr", AliVCluster::kHadCorr },
    {"kUserDefEnergy1", AliVCluster::kUserDefEnergy1 },
    {"kUserDefEnergy2", AliVCluster::kUserDefEnergy2 }
  };

  std::map <std::string, AliEmcalTrackSelection::ETrackFilterType_t> trackFilterTypeMap = {
    {"kNoTrackFilter", AliEmcalTrackSelection::kNoTrackFilter },
    {"kCustomTrackFilter", AliEmcalTrackSelection::kCustomTrackFilter },
    {"kHybridTracks",  AliEmcalTrackSelection::kHybridTracks },
    {"kTPCOnlyTracks", AliEmcalTrackSelection::kTPCOnlyTracks }
  };
#endif

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

  // YAML
  void Initialize();
  // YAML options
  void SetUserConfigurationFilename(std::string name) { fUserConfigurationFilename = name; }
  void SetDefaultConfigurationFilename(std::string name) { fDefaultConfigurationFilename = name; }
  // Write configuration to file
  bool WriteConfigurationFile(std::string filename, bool userConfig = false);

  // Options
  // Get
  const TString &             GetRunPeriod()                                  const { return fRunPeriod; }
  // Set
  void                        SetForceBeamType(BeamType f)                          { fForceBeamType     = f                              ; }
  void                        SetRunPeriod(const char* runPeriod)                   { fRunPeriod = runPeriod; fRunPeriod.ToLower(); }
  // Centrality options
  void                        SetUseNewCentralityEstimation(Bool_t b)               { fUseNewCentralityEstimation = b                     ; }
  virtual void                SetNCentBins(Int_t n)                                 { fNcentBins         = n                              ; }
  void                        SetCentRange(Double_t min, Double_t max)              { fMinCent           = min  ; fMaxCent = max          ; }

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

  // 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)                       ; } 
  // Cells
  AliEmcalCorrectionCellContainer *GetCellContainer(const std::string & cellsContainerName) const;

  // Utility functions
  static std::string DetermineUseDefaultName(InputObject_t contType, bool esdMode, bool returnObjectType = false);
  static AliVEvent * GetEvent(AliVEvent * inputEvent, bool isEmbedding = false);

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

  // Aditional steering functions
  virtual Bool_t Run();
  virtual void ExecOnce();

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

  // Utility functions
  // File utilities
  static inline bool DoesFileExist(const std::string & filename);
  void SetupConfigurationFilePath(std::string & filename, bool userFile = false);
  // Cell utilities
  void SetCellsObjectInCellContainerBasedOnProperties(AliEmcalCorrectionCellContainer * cellContainer);
  // Container utilities
  void CheckForContainerArray(AliEmcalContainer * cont, InputObject_t objectType);
  // YAML configuration utilities
  std::string GetInputFieldNameFromInputObjectType(InputObject_t inputObjectType);
  bool CheckPossibleNamesForComponentName(std::string & name, std::set <std::string> & possibleComponents);
  // General utilities
  BeamType GetBeamType();

  // Retrieve objects in event
  Bool_t RetrieveEventObjects();

  // Execute component functions
  void ExecOnceComponents();
  void UserCreateOutputObjectsComponents();

  // Initialization functions
  void DetermineComponentsToExecute(std::vector <std::string> & componentsToExecute);
  void InitializeConfiguration();
  void CheckForUnmatchedUserSettings();
  void InitializeComponents();

  // Input objects (Cells, Clusters, Tracks) functions
  void CreateInputObjects(InputObject_t inputObjectType);
  void AddContainersToComponent(AliEmcalCorrectionComponent * component, InputObject_t inputObjectType);
  
#if !(defined(__CINT__) || defined(__MAKECINT__))
  // Hidden from CINT since it cannot handle YAML objects well
  // Input objects 
  void SetupContainersFromInputNodes(InputObject_t inputObjectType, YAML::Node & userInputObjectNode, YAML::Node & defaultInputObjectNode, std::set <std::string> & requestedContainers);
  // Cells
  void SetupCellsInfo(std::string containerName, YAML::Node & userNode, YAML::Node & defaultNode);
  // Containers
  void SetupContainer(InputObject_t inputObjectType, std::string containerName, YAML::Node & userNode, YAML::Node & defaultNode);
  AliEmcalContainer * AddContainer(InputObject_t contType, std::string & containerName, YAML::Node & userNode, YAML::Node & defaultNode);

  // Utilities
  // YAML node dependent input objects utilties
  void GetNodeForInputObjects(YAML::Node & inputNode, YAML::Node & nodeToRetrieveFrom, std::string & inputObjectName, bool requiredProperty);
  // YAML node dependent initialization utlitiles
  void GetPropertyNamesFromNode(const std::string & componentName, const YAML::Node & node, std::set <std::string> & propertyNames, const bool nodeRequired);
#endif

#if !(defined(__CINT__) || defined(__MAKECINT__))
  // Hidden from CINT since it cannot handle YAML objects well
  YAML::Node                  fUserConfiguration;          
  YAML::Node                  fDefaultConfiguration;       
#endif

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

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

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

  bool                        fIsEsd;                      
  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;              
  Bool_t                      fNeedEmcalGeom;              
  AliEMCALGeometry           *fGeom;                       

  TObjArray                   fParticleCollArray;          
  TObjArray                   fClusterCollArray;           
  std::vector <AliEmcalCorrectionCellContainer *> fCellCollArray; 
  
  TList *                     fOutput;                     

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

class AliEmcalCorrectionCellContainer {
 public:
  AliEmcalCorrectionCellContainer():
    fBranchName(""),
    fName(""),
    fIsEmbedding(""),
    fCells(0)
  {}
  AliEmcalCorrectionCellContainer(std::string branchName, std::string name, std::string branchToCopyName, bool isEmbedded):
    fBranchName(branchName),
    fName(name),
    fIsEmbedding(isEmbedded),
    fCells(0)
  {}
  virtual ~AliEmcalCorrectionCellContainer() {}

  std::string GetBranchName() const { return fBranchName; }
  std::string GetName() const { return fName; }
  bool GetIsEmbedding() const { return fIsEmbedding; }
  AliVCaloCells * GetCells() const { return fCells; }

  void SetBranchName(std::string branchName) { fBranchName = branchName; }
  void SetName(std::string name ) { fName = name; }
  void SetIsEmbedding(bool isEmbedded) { fIsEmbedding = isEmbedded; }
  void SetCells(AliVCaloCells * cells) { fCells = cells; }

 protected:
  std::string fBranchName;                        
  std::string fName;                              
  bool fIsEmbedding;                              
  AliVCaloCells *fCells;                          

  ClassDef(AliEmcalCorrectionCellContainer, 1); // EMCal correction cell container
};

#endif /* ALIEMCALCORRECTIONTASK_H */