AliEmcalCorrectionCellEmulateCrosstalk.h

Go to the documentation of this file.

#ifndef ALIEMCALCORRECTIONCELLEMULATECROSSTALK_H
#define ALIEMCALCORRECTIONCELLEMULATECROSSTALK_H

#include <TRandom3.h>

#include "AliEmcalCorrectionComponent.h"

class AliEmcalCorrectionCellEmulateCrosstalk : public AliEmcalCorrectionComponent {
 public:
  AliEmcalCorrectionCellEmulateCrosstalk();
  virtual ~AliEmcalCorrectionCellEmulateCrosstalk();

  // Sets up and runs the task
  Bool_t Initialize();
  void UserCreateOutputObjects();
  Bool_t Run();
  
  // Print correction paramters
  void PrintTCardParam();
  
 protected:

  // Useful constants
  static const Int_t fgkNEMCalCells = 17664;       
  static const Int_t fgkNsm = 22;                  

  // T-Card correlation emulation, do on MC
  void           MakeCellTCardCorrelation();
  void           CalculateInducedEnergyInTCardCell(Int_t absId, Int_t absIdRef, 
                                                   Int_t sm, Float_t ampRef, 
                                                   Int_t cellCase) ;

  void           AddInducedEnergiesToExistingCells();
  void           AddInducedEnergiesToNewCells();
  
  virtual void   ResetArrays();
  Bool_t         AcceptCell(Int_t absID);

  // Initialize array parameters.
  #if !(defined(__CINT__) || defined(__MAKECINT__))
  template <typename T>
  void RetrieveAndSetProperties(const T & properties);
  #endif
  void SetProperty(Float_t val[][fgkNsm], std::vector<double> & property, unsigned int iSM, const std::string & name);
  void SetProperty(Float_t val[fgkNsm], std::vector<double> & property, unsigned int iSM, const std::string & name);
  
  TH1F* fCellEnergyDistBefore;        
  TH1F* fCellEnergyDistAfter;         
  
  // T-Card correlation emulation, do on MC
  Bool_t                fTCardCorrClusEnerConserv; 
  Float_t               fTCardCorrCellsEner[fgkNEMCalCells]; 
  Bool_t                fTCardCorrCellsNew [fgkNEMCalCells]; 
  
  Float_t               fTCardCorrInduceEner         [4][fgkNsm]; 
  Float_t               fTCardCorrInduceEnerFrac     [4][fgkNsm]; 
  Float_t               fTCardCorrInduceEnerFracP1   [4][fgkNsm]; 
  Float_t               fTCardCorrInduceEnerFracWidth[4][fgkNsm]; 
  Float_t               fTCardCorrInduceEnerFracMax[fgkNsm];   
  Float_t               fTCardCorrInduceEnerFracMin[fgkNsm];   
  Float_t               fTCardCorrInduceEnerProb[fgkNsm];      
  
  TRandom3              fRandom;                   
  Bool_t                fRandomizeTCard;           
  
  Float_t               fTCardCorrMinAmp;          
  Float_t               fTCardCorrMinInduced;      
  Float_t               fTCardCorrMaxInducedELeak; 
  Float_t               fTCardCorrMaxInduced;      
  
  Bool_t                fPrintOnce;                
  
  AliAODCaloCells      *fAODCellsTmp;              

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

  // Allows the registration of the class so that it is availble to be used by the correction task.
  static RegisterCorrectionComponent<AliEmcalCorrectionCellEmulateCrosstalk> reg;

  ClassDef(AliEmcalCorrectionCellEmulateCrosstalk, 3); // EMCal cell crosstalk emulation correction component
};

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

template <typename T>
void AliEmcalCorrectionCellEmulateCrosstalk::RetrieveAndSetProperties(const T & properties)
{
  std::string taskName = GetName();
  std::map <std::string, std::vector<double>> values;

  for (auto& val : properties) {
    AliDebugStream(1) << "Processing value " << val.first << "\n";
    bool enabled = false;
    fYAMLConfig.GetProperty({taskName, val.first, "enabled"}, enabled, true);
    if (enabled) {
      AliDebugStream(1) << val.first << " enabled.\n";
      fYAMLConfig.GetProperty({taskName, val.first, "values"}, values, true);
      // "all"" is prioritized over any individual SM values
      auto property = values.find("all");
      if (property != values.end()) {
        // Set same value in all SMs
        AliDebugStream(1) << "Retrieving all SM settings for property " << val.first << "\n";
        for (unsigned int iSM = 0; iSM < fgkNsm; iSM++) {
          SetProperty(val.second, property->second, iSM, val.first);
        }
      }
      else {
        // Handle per SM values
        AliDebugStream(1) << "Retrieving per SM settings for property " << val.first << "\n";
        for (auto && property : values) {
          unsigned int iSM = std::stoul(property.first);
          // iSM must be >= 0 because it is unsigned
          if (iSM < fgkNsm) {
            SetProperty(val.second, property.second, iSM, val.first);
          }
          else {
            AliWarningStream() << "SM " << iSM << " requested for property " << val.first << " is out of range. Please check your configuration!\n";
          }
        }
      }
    }
  }
}
#endif

#endif /* ALIEMCALCORRECTIONCellEmulateCrosstalk_H */