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 <iosfwd>

#include <AliAnalysisTaskSE.h>
#include <AliVCluster.h>

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

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

  static const std::map <std::string, AliVCluster::VCluUserDefEnergy_t> fgkClusterEnergyTypeMap; 

  static const std::map <std::string, AliEmcalTrackSelection::ETrackFilterType_t> fgkTrackFilterTypeMap; 

  AliEmcalCorrectionTask();
  AliEmcalCorrectionTask(const char * name);
  // Implemented using copy-and-swap mechanism
  AliEmcalCorrectionTask(const AliEmcalCorrectionTask & task);
  AliEmcalCorrectionTask &operator=(AliEmcalCorrectionTask other);
  friend void swap(AliEmcalCorrectionTask & first, AliEmcalCorrectionTask & second);
  AliEmcalCorrectionTask(AliEmcalCorrectionTask && other);
  virtual ~AliEmcalCorrectionTask();

  // YAML
  void Initialize();
  // YAML options
  void SetUserConfigurationFilename(std::string name) { fUserConfigurationFilename = name; }
  void SetDefaultConfigurationFilename(std::string name) { fDefaultConfigurationFilename = name; }
  // Print the actual configuration string
  std::ostream & PrintConfigurationString(std::ostream & in, bool userConfig = false) const;
  // Write configuration to file
  bool WriteConfigurationFile(std::string filename, bool userConfig = false) const;
  // Compare configurations
  bool CompareToStoredConfiguration(std::string filename, bool userConfig = false) const;

  // Options
  // Printing
  friend std::ostream & operator<<(std::ostream &in, const AliEmcalCorrectionTask &myTask);
  void Print(Option_t* opt = "") const;
  std::ostream & Print(std::ostream &in) const;
  std::string toString(bool includeYAMLConfigurationInfo = false) const;
  // Set
  void                        SetForceBeamType(BeamType f)                          { fForceBeamType     = f                              ; }
  void                        SetNeedEmcalGeometry(Bool_t b)                        { fNeedEmcalGeom     = b                              ; }
  // Centrality options
  void                        SetUseNewCentralityEstimation(Bool_t b)               { fUseNewCentralityEstimation = b                     ; }
  void                        SetCentralityEstimator(const char * c)                { fCentEst           = c                              ; }
  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)                   { return AliEmcalContainerUtils::AddContainer<AliParticleContainer>(n, fParticleCollArray); }
  AliTrackContainer          *AddTrackContainer(const char *n)                      { return AliEmcalContainerUtils::AddContainer<AliTrackContainer>(n, fParticleCollArray); }
  AliMCParticleContainer     *AddMCParticleContainer(const char *n)                 { return AliEmcalContainerUtils::AddContainer<AliMCParticleContainer>(n, fParticleCollArray); }
  AliClusterContainer        *AddClusterContainer(const char *n)                    { return AliEmcalContainerUtils::AddContainer<AliClusterContainer>(n, fClusterCollArray); }
  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         { return AliEmcalContainerUtils::GetContainer<AliParticleContainer>(i, fParticleCollArray); }
  AliParticleContainer       *GetParticleContainer(const char* name)  const         { return AliEmcalContainerUtils::GetContainer<AliParticleContainer>(name, fParticleCollArray); }
  AliClusterContainer        *GetClusterContainer(Int_t i=0)          const         { return AliEmcalContainerUtils::GetContainer<AliClusterContainer>(i, fClusterCollArray); }
  AliClusterContainer        *GetClusterContainer(const char* name)   const         { return AliEmcalContainerUtils::GetContainer<AliClusterContainer>(name, fClusterCollArray); }
  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;

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

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

  // Add Task
  static AliEmcalCorrectionTask* AddTaskEmcalCorrectionTask(TString suffix = "");

 private:
  // 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, AliEmcalContainerUtils::InputObject_t objectType);
  // YAML configuration utilities
  std::string GetInputFieldNameFromInputObjectType(AliEmcalContainerUtils::InputObject_t inputObjectType);
  bool CheckPossibleNamesForComponentName(std::string & name, std::set <std::string> & possibleComponents);
  // General utilities
  BeamType GetBeamType() const;
  void PrintRequestedContainersInformation(AliEmcalContainerUtils::InputObject_t inputObjectType, std::ostream & stream) const;

  // Retrieve objects in event
  Bool_t RetrieveEventObjects();

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

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

  // Input objects (Cells, Clusters, Tracks) functions
  void CreateInputObjects(AliEmcalContainerUtils::InputObject_t inputObjectType);
  void AddContainersToComponent(AliEmcalCorrectionComponent * component, AliEmcalContainerUtils::InputObject_t inputObjectType, bool checkObjectExists = false);
  
#if !(defined(__CINT__) || defined(__MAKECINT__))
  // Hidden from CINT since it cannot handle YAML objects well
  // Input objects 
  void SetupContainersFromInputNodes(AliEmcalContainerUtils::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(AliEmcalContainerUtils::InputObject_t inputObjectType, std::string containerName, YAML::Node & userNode, YAML::Node & defaultNode);
  AliEmcalContainer * AddContainer(AliEmcalContainerUtils::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;                      
  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, 4); // 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 */