AliEmcalCorrectionComponent.h

Go to the documentation of this file.

#ifndef ALIEMCALCORRECTIONCOMPONENT_H
#define ALIEMCALCORRECTIONCOMPONENT_H

#include <map>
#include <string>

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

class TH1F;
#include <TNamed.h>

class AliMCEvent;
class AliEMCALRecoUtils;
class AliVCaloCells;
class AliVTrack;
class AliVCluster;
class AliVEvent;
#include <AliLog.h>
#include "AliEmcalContainerUtils.h"
#include "AliParticleContainer.h"
#include "AliMCParticleContainer.h"
#include "AliTrackContainer.h"
#include "AliClusterContainer.h"
#include "AliEMCALGeometry.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)                       ; }
  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; }

#if !(defined(__CINT__) || defined(__MAKECINT__))
  void SetUserConfiguration(YAML::Node & node) { fUserConfiguration = node; }
  void SetDefaultConfiguration(YAML::Node & node) { fDefaultConfiguration = node; }
  
  template<typename T> bool GetProperty(std::string propertyName, T & property, bool requiredProperty = true, std::string correctionName = "");

  template<typename T> static bool GetProperty(std::string propertyName, T & property, const YAML::Node & userConfiguration, const YAML::Node & defaultConfiguration, bool requiredProperty = true, std::string correctionName = "");
#endif
  static bool IsSharedValue(std::string & value);

 protected:

#if !(defined(__CINT__) || defined(__MAKECINT__))
  template<typename T> static bool GetPropertyFromNodes(const YAML::Node & node, const YAML::Node & sharedParametersNode, std::string propertyName, T & property, const std::string correctionName, const std::string configurationType, int nodesDeep = 0);
  template<typename T> static bool GetPropertyFromNode(const YAML::Node & node, std::string propertyName, T & property);

  template<typename T> static typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, std::string>::value && !std::is_same<T, bool>::value>::type PrintRetrievedPropertyValue(T & property, std::stringstream & tempMessage);
  template<typename T> static typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, std::string>::value || std::is_same<T, bool>::value>::type PrintRetrievedPropertyValue(T & property, std::stringstream & tempMessage);

  YAML::Node              fUserConfiguration;             
  YAML::Node              fDefaultConfiguration;          
#endif

  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;                          
  Bool_t                  fIsEmbedded;                    
  Int_t                   fMinMCLabel;                    
  TObjArray               fClusterCollArray;              
  TObjArray               fParticleCollArray;             
  AliVCaloCells          *fCaloCells;                     
  AliEMCALRecoUtils      *fRecoUtils;                     
  TList                  *fOutput;                        
  
  TString                fBasePath;                       

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

#if !(defined(__CINT__) || defined(__MAKECINT__))

template<typename T>
bool AliEmcalCorrectionComponent::GetProperty(std::string propertyName, T & property, bool requiredProperty, std::string correctionName)
{
  // Get proper correction name
  if (correctionName == "")
  {
    correctionName = GetName();
  }
  bool result = GetProperty(propertyName, property, fUserConfiguration, fDefaultConfiguration, requiredProperty, correctionName);

  return result;
}

template<typename T>
bool AliEmcalCorrectionComponent::GetProperty(std::string propertyName, T & property, const YAML::Node & userConfiguration, const YAML::Node & defaultConfiguration, bool requiredProperty, std::string correctionName)
{
  // Remove AliEmcalCorrection if in name
  std::size_t prefixStringLocation = correctionName.find("AliEmcalCorrection");
  if (prefixStringLocation != std::string::npos)
  {
    // AliEmcalCorrection is 18 characters
    correctionName.erase(prefixStringLocation, prefixStringLocation + 18);
  }

  bool setProperty = false;
  // IsNull checks is a node is empty. A node is empty if it is created.
  // IsDefined checks if the node that was requested was not actually created.
  // In this case, the user configuration node is always created. If it IsNull, then we ignore it.
  if (userConfiguration.IsNull() != true)
  {
    AliDebugClass(2, "Looking for parameter in user configuration");
    YAML::Node sharedParameters = userConfiguration["sharedParameters"];
    //std::cout << std::endl << "User Node: " << fUserConfiguration << std::endl;
    setProperty = AliEmcalCorrectionComponent::GetPropertyFromNodes(userConfiguration, sharedParameters, propertyName, property, correctionName, "user");
  }

  if (setProperty != true)
  {
    AliDebugClass(2, "Looking for parameter in default configuration");
    YAML::Node sharedParameters = defaultConfiguration["sharedParameters"];
    //std::cout << std::endl << "Default Node: " << fDefaultConfiguration << std::endl;
    setProperty = AliEmcalCorrectionComponent::GetPropertyFromNodes(defaultConfiguration, sharedParameters, propertyName, property, correctionName, "default");
  }

  if (setProperty != true && requiredProperty == true)
  {
    std::stringstream message;
    message << "Failed to retrieve property \""
        << (correctionName != "" ? correctionName + ":" : "")
        << propertyName << "\" from default config!" << std::endl;
    AliFatalClass(message.str().c_str());
  }

  // Return whether the value was actually set
  return setProperty;
}

template<typename T>
bool AliEmcalCorrectionComponent::GetPropertyFromNodes(const YAML::Node & node, const YAML::Node & sharedParametersNode, std::string propertyName, T & property, const std::string correctionName, const std::string configurationType, int nodesDeep)
{
  // Used as a buffer for printing complicated messages
  std::stringstream tempMessage;

  bool returnValue = false;
  if (nodesDeep > 2)
  {
    // Ensure that we do not go past two levels
    tempMessage.str("");
    tempMessage << "Went too many levels of recursion. Bailing out on \"" << correctionName << ":" << propertyName << "\" from " << configurationType << " config at level " << nodesDeep;
    AliDebugClass(2, TString::Format("%s", tempMessage.str().c_str()));
    return false;
  }

  // Only want to print once to ensure the user is not overwhelmed!
  if (nodesDeep == 0)
  {
    tempMessage.str("");
    tempMessage << "Retreiving property \""
          << (correctionName != "" ? correctionName + ":" : "")
          << propertyName << "\" from " << configurationType << " config at level " << nodesDeep;
    AliDebugClass(1, TString::Format("%s", tempMessage.str().c_str()));
  }

  if (node.IsDefined() == true)
  {
    //std::cout << "Node: " << node << std::endl;
    if (node[propertyName])
    {
      bool isShared = false;
      // Will contain the name of the property in the sharedParameters section that should be retrieved
      // if it is requested through the user configuration.
      std::string sharedValueName = "";
      // Necessary because it fails on vectors and other complex objects that are YAML sequences.
      if (std::is_arithmetic<T>::value || std::is_same<T, std::string>::value || std::is_same<T, bool>::value)
      {
        // Retrieve value as string to check for shared value
        sharedValueName = node[propertyName].as<std::string>();
        // Check for a shared value
        isShared = AliEmcalCorrectionComponent::IsSharedValue(sharedValueName);
      }

      tempMessage.str("");
      tempMessage << "property \"" 
            << (nodesDeep > 0 ? correctionName + ":" : "")
            << propertyName
            << "\" using " << ( isShared ? "\"sharedParameters:" + sharedValueName + "\" in " : "" )
            << "values from the " << configurationType
            << " configuration at level " << nodesDeep;

      AliDebugClass(2, TString::Format("Retrieveing %s", tempMessage.str().c_str()));

      bool retrievalResult = false;
      if (isShared == true)
      {
        retrievalResult = GetPropertyFromNode(sharedParametersNode, sharedValueName, property);
      }
      else
      {
        retrievalResult = GetPropertyFromNode(node, propertyName, property);
      }

      // Inform about the result
      if (retrievalResult == true)
      {
        // Add the retrieved value to the message (only if trivially printable)
        PrintRetrievedPropertyValue(property, tempMessage);
        AliDebugClassStream(2) << "Succeeded in retrieveing " << tempMessage.str() << std::endl;
        returnValue = true;
      }
      else
      {
        // Only fatal if we have exhausted our last option, the default
        if (configurationType == "default")
        {
          AliFatalClass(TString::Format("Failed to retrieve %s", tempMessage.str().c_str()));
        }
        else
        {
          AliDebugClass(2, TString::Format("Failed to retrieve %s", tempMessage.str().c_str()));
        }
        returnValue = false;
      }
    }
    else
    {
      // Go one node deeper using recursion
      // Must create a new node, since we took the original node by reference
      YAML::Node deeperNode = node[correctionName];
      nodesDeep++;
      AliDebugClass(2, TString::Format("Going a node deeper with \"%s\" to level %i", correctionName.c_str(), nodesDeep));
      returnValue = GetPropertyFromNodes(deeperNode, sharedParametersNode, propertyName, property, correctionName, configurationType, nodesDeep);

      // If we didn't find it, next try a substring
      if (returnValue == false)
      {
        // Don't increment nodesDeep, because we are about to go another node deep anyway
        std::size_t splitLocation = correctionName.find("_");
        // We only want to look at the split if we are only one node deep and
        // if the split is actually meaningful
        if (splitLocation != std::string::npos && nodesDeep == 1)
        {
          // Split from start to underscore
          std::string subCorrectionName = correctionName.substr(0, splitLocation);
          AliDebugClass(2, TString::Format("Attempting to retrieve property \"%s\" from base correction \"%s\" at level %i", propertyName.c_str(), subCorrectionName.c_str(), nodesDeep));
          // Retrieve the base correction node
          // Need to create new node! Otherwise it will assign the correctionName node to subCorrectionName node!
          YAML::Node subCorrectionNode = node[subCorrectionName];
          returnValue = GetPropertyFromNodes(subCorrectionNode, sharedParametersNode, propertyName, property, subCorrectionName, configurationType, nodesDeep);
        }
      }
    }
  }
  else
  {
    tempMessage.str("");
    tempMessage << "Node is undefined for \""
          << (correctionName != "" ? correctionName + ":" : "")
          << propertyName << "\" from " << configurationType << " config at level " << nodesDeep;
    AliDebugClass(2, TString::Format("%s", tempMessage.str().c_str()));

    returnValue = false;
  }

  return returnValue;
}

template<typename T>
typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, std::string>::value || std::is_same<T, bool>::value>::type
AliEmcalCorrectionComponent::PrintRetrievedPropertyValue(T & property, std::stringstream & tempMessage)
{
  //AliDebugClassStream(2) << " with value " << property;
  tempMessage << " with value \"" << property << "\"";
}

template<typename T>
typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, std::string>::value && !std::is_same<T, bool>::value>::type
AliEmcalCorrectionComponent::PrintRetrievedPropertyValue(T & property, std::stringstream & tempMessage)
{
  // Cannot easily print these types, so just note that is the case!
  tempMessage << " with a value that cannot be trivially printed";
}

template<typename T>
bool AliEmcalCorrectionComponent::GetPropertyFromNode(const YAML::Node & node, std::string propertyName, T & property)
{
  if (node[propertyName])
  {
    property = node[propertyName].as<T>();
    return true;
  }
  return false;
}

#endif /* Hide yaml from CINT */

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 */