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__))
  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();

  // 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 Initialize();

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

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

  void                        SetUseNewCentralityEstimation(Bool_t b)               { fUseNewCentralityEstimation = b                     ; }

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

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

  // Determine branch name using the "usedefault" pattern
  static std::string DetermineUseDefaultName(InputObject_t contType, bool esdMode, bool returnObjectType = false);

  // Get the proper event based on whether embedding is enabled or not
  static AliVEvent * GetEvent(AliVEvent * inputEvent, bool isEmbedding = 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 InitializeConfiguration();
  void RetrieveExecutionOrder(std::vector <std::string> & componentsToAdd);
  void InitializeComponents();

  void SetCellsObjectInCellContainerBasedOnProperties(AliEmcalCorrectionCellContainer * cellContainer);
  void CheckForContainerArray(AliEmcalContainer * cont, InputObject_t objectType);

  std::string GetInputFieldNameFromInputObjectType(InputObject_t inputObjectType);
  void CreateInputObjects(InputObject_t inputObjectType);
  void AddContainersToComponent(AliEmcalCorrectionComponent * component, InputObject_t inputObjectType);
#if !(defined(__CINT__) || defined(__MAKECINT__))
  void SetupContainersFromInputNodes(InputObject_t inputObjectType, YAML::Node & userInputObjectNode, YAML::Node & defaultInputObjectNode, std::set <std::string> & requestedContainers);
  void GetNodeForInputObjects(YAML::Node & inputNode, YAML::Node & nodeToRetrieveFrom, std::string & inputObjectName, bool requiredProperty);

  void SetupCellsInfo(std::string containerName, YAML::Node & userNode, YAML::Node & defaultNode);
  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);
#endif

  Bool_t                      RetrieveEventObjects();
  void                        ExecOnceComponents();
  void                        UserCreateOutputObjectsComponents();

  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;                      
  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, 2); // 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 */