AliEmcalCorrectionComponent.h

Go to the documentation of this file.

#ifndef ALIEMCALCORRECTIONCOMPONENT_H
#define ALIEMCALCORRECTIONCOMPONENT_H

#include <map>
#include <string>

class TH1F;
#include <TNamed.h>

class AliMCEvent;
class AliEMCALRecoUtils;
class AliVCaloCells;
class AliVTrack;
class AliVCluster;
class AliVEvent;
#include <AliLog.h>
#include <AliEMCALGeometry.h>
#include "AliYAMLConfiguration.h"
#include "AliEmcalContainerUtils.h"
#include "AliParticleContainer.h"
#include "AliMCParticleContainer.h"
#include "AliTrackContainer.h"
#include "AliClusterContainer.h"
#include "AliEmcalCorrectionEventManager.h"

class AliEmcalCorrectionComponent : public TNamed {
 public:
  AliEmcalCorrectionComponent();
  AliEmcalCorrectionComponent(const char * name);
  virtual ~AliEmcalCorrectionComponent();

  // Virtual functions to be overloaded 
  virtual Bool_t Initialize();
  virtual void UserCreateOutputObjects();
  virtual void ExecOnce();
  virtual Bool_t Run();
  virtual Bool_t UserNotify();
  virtual Bool_t CheckIfRunChanged();
  
  void GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff);
  void UpdateCells();
  void GetPass();
  void FillCellQA(TH1F* h);
  Int_t InitBadChannels();

  // 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)                       ; }
  AliEMCALRecoUtils      *GetRecoUtils()  const { return fRecoUtils; }
  AliVCaloCells          *GetCaloCells()  const { return fCaloCells; }
  TList                  *GetOutputList() const { return fOutput; }
  
  void SetCaloCells(AliVCaloCells * cells) { fCaloCells = cells; }
  void SetRecoUtils(AliEMCALRecoUtils *ru) { fRecoUtils = ru; }

  void SetInputEvent(AliVEvent * event) { fEventManager.SetInputEvent(event); }
  void SetMCEvent(AliMCEvent * mcevent) { fMCEvent = mcevent; }
  void SetUsingInputEvent(bool b = true) { fEventManager.SetUseEmbeddingEvent(!b); }

  void SetEMCALGeometry(AliEMCALGeometry * geometry ) { fGeom = geometry; }
  void SetCentralityBin(Int_t bin) { fCentBin = bin; }
  void SetCentrality(Double_t cent) { fCent = cent; }
  void SetNcentralityBins(Int_t n) { fNcentBins = n; }
  void SetVertex(Double_t * vertex) { fVertex[0] = vertex[0]; fVertex[1] = vertex[1]; fVertex[2] = vertex[2]; }
  void SetIsESD(Bool_t isESD) {fEsdMode = isESD; }
  void SetCustomBadChannels(TString customBC) {fCustomBadChannelFilePath = customBC; }

  void SetYAMLConfiguration(PWG::Tools::AliYAMLConfiguration config) { fYAMLConfig = config; }

  template<typename T> bool GetProperty(std::string propertyName, T & property, bool requiredProperty = true, std::string correctionName = "");
 protected:
  PWG::Tools::AliYAMLConfiguration fYAMLConfig;           
  Bool_t                  fCreateHisto;                   
  Int_t                   fRun;                           
  TString                 fFilepass;                      
  Bool_t                  fGetPassFromFileName;           
  AliEmcalCorrectionEventManager fEventManager;           
  Bool_t                  fEsdMode;                       
  AliMCEvent             *fMCEvent;                       
  Double_t                fCent;                          
  Int_t                   fNcentBins;                     
  Int_t                   fCentBin;                       
  Int_t                   fNbins;                         
  Double_t                fMinBinPt;                      
  Double_t                fMaxBinPt;                      
  Double_t                fVertex[3];                     
  AliEMCALGeometry       *fGeom;                          
  Int_t                   fMinMCLabel;                    
  TObjArray               fClusterCollArray;              
  TObjArray               fParticleCollArray;             
  AliVCaloCells          *fCaloCells;                     
  AliEMCALRecoUtils      *fRecoUtils;                     
  TList                  *fOutput;                        
  
  TString                fBasePath;                       
  TString                fCustomBadChannelFilePath;       

 private:
  AliEmcalCorrectionComponent(const AliEmcalCorrectionComponent &);               // Not implemented
  AliEmcalCorrectionComponent &operator=(const AliEmcalCorrectionComponent &);    // Not implemented
  
  ClassDef(AliEmcalCorrectionComponent, 6); // EMCal correction component
};

template<typename T>
bool AliEmcalCorrectionComponent::GetProperty(std::string propertyName, T & property, bool requiredProperty, std::string correctionName)
{
  // Get proper correction name
  if (correctionName == "")
  {
    correctionName = GetName();
  }
  // Add the correction name as a prefix of the property
  return fYAMLConfig.GetProperty(std::vector<std::string>{correctionName, propertyName}, property, requiredProperty);
}

template<typename T> AliEmcalCorrectionComponent * createT() { return new T; }

// Factory to create and keep track of new components
class AliEmcalCorrectionComponentFactory
{
 public:
  virtual ~AliEmcalCorrectionComponentFactory() {}

  typedef std::map<std::string, AliEmcalCorrectionComponent*(*)()> map_type;

  static AliEmcalCorrectionComponent * createInstance(std::string const& s)
  {
    map_type::iterator it = getMap()->find(s);
    if(it == getMap()->end())
      return 0;
    // Initializes the function with empty arguments (?)
    return it->second();
  }

 protected:
  static map_type * getMap() {
    // We never delete the map (until program termination) because we cannot guarantee
    // correct destruction order
    if(!componentMap) { componentMap = new map_type;  }
    return componentMap;
  }

 private:
  static map_type * componentMap;
};

template<typename T>
class RegisterCorrectionComponent : public AliEmcalCorrectionComponentFactory
{ 
 public:
  RegisterCorrectionComponent(std::string const& s)
  { 
    getMap()->insert(std::make_pair(s, &createT<T>));
  }
};

#endif /* ALIEMCALCORRECTIONCOMPONENT_H */