AliAnalysisTaskEMCALTimeCalib.h

Go to the documentation of this file.

#ifndef AliAnalysisTaskEMCALTimeCalib_h
#define AliAnalysisTaskEMCALTimeCalib_h

//_________________________________________________________________________
//_________________________________________________________________________

class TH1F;
class TH1D;
class TH2D;
class TH1C;

//class AliESDEvent;
//class AliESDCaloCluster;
//class AliAODCaloCluster;
class AliVCluster;
//class AliAODEvent;
class AliVEvent;
//class AliTOFT0maker;

#include "AliAnalysisTaskSE.h"
#include <fstream>

class AliAnalysisTaskEMCALTimeCalib : public AliAnalysisTaskSE 
{
 public:

   enum { kNSM = 20, kNBCmask = 4 };

   AliAnalysisTaskEMCALTimeCalib() : AliAnalysisTaskSE(),
    fRunNumber(-1),
    //    fTOFmaker(0),
    fOutputList(0),
    fgeom(0),
    fGeometryName(0),
    fMinClusterEnergy(0),
    fMaxClusterEnergy(0),
    fMinNcells(0),
    fMaxNcells(0),
    fMinLambda0(0),
    fMaxLambda0(0),
    fMinLambda0LG(0),
    fMaxLambda0LG(0),
    fMaxRtrack(0),
    fMinCellEnergy(0),
    fReferenceFileName(),
    fReferenceRunByRunFileName(),
    fPileupFromSPD(kFALSE),
    fMinTime(0),
    fMaxTime(0),
    fMostEneCellOnly(kFALSE),
    fRawTimeNbins (0),
    fRawTimeMin   (0),
    fRawTimeMax   (0),
    fPassTimeNbins(0),
    fPassTimeMin  (0),
    fPassTimeMax  (0),
    fEnergyNbins  (0),
    fEnergyMin(0),
    fEnergyMax(0),
    fEnergyLGNbins  (0),
    fEnergyLGMin(0),
    fEnergyLGMax(0),
    fFineNbins(0),
    fFineTmin(0),
    fFineTmax(0),
    fL1PhaseList(0),
    fBadReco(kFALSE),
    fFillHeavyHisto(kFALSE),
    fBadChannelMapArray(),
    fBadChannelMapSet(kFALSE),
    fSetBadChannelMapSource(0),
    fBadChannelFileName(),
    fhcalcEvtTime(0),
    fhEvtTimeHeader(0),
    fhEvtTimeDiff(0),
    fhEventType(0),
    fhTOFT0vsEventNumber(0),
    fhTcellvsTOFT0(0),
    fhTcellvsTOFT0HD(0),
    fhTcellvsSM(0),
    fhEneVsAbsIdHG(0),
    fhEneVsAbsIdLG(0),
    fhTimeVsBC(0),
    fhTimeSumSq(),
    fhTimeEnt(),
    fhTimeSum(),
    fhTimeLGSumSq(),
    fhTimeLGEnt(),
    fhTimeLGSum(),
    fhAllAverageBC(),
    fhAllAverageLGBC(),
    fhRefRuns(0),
    fhTimeDsup(),
    fhTimeDsupBC(),
    fhTimeDsupLG(),
    fhTimeDsupLGBC(),
    fhRawTimeVsIdBC(),
    fhRawTimeSumBC(),
    fhRawTimeEntriesBC(),
    fhRawTimeSumSqBC(),
    fhRawTimeVsIdLGBC(),
    fhRawTimeSumLGBC(),
    fhRawTimeEntriesLGBC(),
    fhRawTimeSumSqLGBC(),
    fhRawCorrTimeVsIdBC(),
    fhRawCorrTimeVsIdLGBC(),
    fhTimeVsIdBC(),
    fhTimeVsIdLGBC()
    { ; }
  
  AliAnalysisTaskEMCALTimeCalib(const char *name);
  virtual ~AliAnalysisTaskEMCALTimeCalib() { ; }
  
  // struct for storing PAR info
  struct PARInfo {
      Int_t runNumber = 0;
      Int_t numPARs = 0;
      std::vector<ULong64_t> PARGlobalBCs;
  };

  //  virtual void   LocalInit();
  //virtual Bool_t Notify();
  virtual void   NotifyRun();
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);
  
  // Getters and setters
  Int_t    GetRunNumber()         { return fRunNumber         ; }
  Double_t GetMinClusterEnergy()  { return fMinClusterEnergy  ; }
  Double_t GetMaxClusterEnergy()  { return fMaxClusterEnergy  ; }
  Int_t    GetMinNcells()         { return fMinNcells         ; }
  Int_t    GetMaxNcells()         { return fMaxNcells         ; }
  Double_t GetMinLambda0()        { return fMinLambda0        ; }
  Double_t GetMaxLambda0()        { return fMaxLambda0        ; }
  Double_t GetMinLambda0LG()      { return fMinLambda0LG      ; }
  Double_t GetMaxLambda0LG()      { return fMaxLambda0LG      ; }
  Double_t GetMaxRtrack()         { return fMaxRtrack         ; }
  Double_t GetMinCellEnergy()     { return fMinCellEnergy     ; }
  TString  GetReferenceFileName() { return fReferenceFileName ; }
  TString  GetReferenceRunByRunFileName() { return fReferenceRunByRunFileName ; }
  TString  GetGeometryName()      { return fGeometryName      ; }
  Double_t GetMinTime()           { return fMinTime           ; }
  Double_t GetMaxTime()           { return fMaxTime           ; }
  TString  GetBadChannelFileName() { return fBadChannelFileName ; }

  void SetRunNumber        (Int_t    v) { fRunNumber        = v ; }
  void SetMinClusterEnergy (Double_t v) { fMinClusterEnergy = v ; }
  void SetMaxClusterEnergy (Double_t v) { fMaxClusterEnergy = v ; }
  void SetMinNcells        (Int_t    v) { fMinNcells        = v ; }  
  void SetMaxNcells        (Int_t    v) { fMaxNcells        = v ; }   
  void SetMinLambda0       (Double_t v) { fMinLambda0       = v ; }    
  void SetMaxLambda0       (Double_t v) { fMaxLambda0       = v ; }    
  void SetMinLambda0LG     (Double_t v) { fMinLambda0LG     = v ; }    
  void SetMaxLambda0LG     (Double_t v) { fMaxLambda0LG     = v ; }    
  void SetMaxRtrack        (Double_t v) { fMaxRtrack        = v ; }    
  void SetMinCellEnergy    (Double_t v) { fMinCellEnergy    = v ; }    
  void SetReferenceFileName(TString  v) { fReferenceFileName= v ; }
  void SetReferenceRunByRunFileName(TString  v) { fReferenceRunByRunFileName= v ; }
  void SetGeometryName     (TString  v) { fGeometryName     = v ; }
  void SetMinTime          (Double_t v) { fMinTime          = v ; }    
  void SetMaxTime          (Double_t v) { fMaxTime          = v ; } 
  void SetBadChannelFileName(TString  v) { fBadChannelFileName = v ; }

  //histogram settings
  void SetRawTimeHisto (Int_t nbins,Double_t lower,Double_t upper) { 
    fRawTimeNbins = nbins;
    fRawTimeMin = lower ;
    fRawTimeMax = upper ;
  }
  void SetPassTimeHisto (Int_t nbins,Double_t lower,Double_t upper) { 
    fPassTimeNbins = nbins;
    fPassTimeMin = lower ;
    fPassTimeMax = upper ;
  }
  void SetEnergyHistoHG (Int_t nbins,Double_t lower,Double_t upper) { 
    fEnergyNbins = nbins;
    fEnergyMin = lower ;
    fEnergyMax = upper ;
  }
  void SetEnergyHistoLG (Int_t nbins,Double_t lower,Double_t upper) { 
    fEnergyLGNbins = nbins;
    fEnergyLGMin = lower ;
    fEnergyLGMax = upper ;
  }

  void SetFineT0Histo (Int_t nbins,Double_t lower,Double_t upper) { 
    fFineNbins = nbins;
    fFineTmin = lower ;
    fFineTmax = upper ;
  }


  // Switches
  void SwitchOnPileupFromSPD()  { fPileupFromSPD = kTRUE ; }
  void SwitchOffPileupFromSPD() { fPileupFromSPD = kFALSE ; }

  void SwitchOnMostEneCellOnly()  { fMostEneCellOnly = kTRUE ; }
  void SwitchOffMostEneCellOnly() { fMostEneCellOnly = kFALSE ; }
  
  void SwitchOnBadReco()  { fBadReco = kTRUE ; }
  void SwitchOffBadReco() { fBadReco = kFALSE ; }

  void SwithOnFillHeavyHisto()  { fFillHeavyHisto = kTRUE ; }
  void SwithOffFillHeavyHisto() { fFillHeavyHisto = kFALSE ; }

  void SetBadChannelMapSource(Int_t v) { fSetBadChannelMapSource = v ; }
  Int_t GetBadChannelMapSource() { return fSetBadChannelMapSource ; }

  void SetDefaultCuts();
  void LoadReferenceHistos(); //loaded once per period to the memory

  void LoadReferenceRunByRunHistos(); //loaded once to the memory at the beginning, phases for all runs 
  void SetL1PhaseReferenceForGivenRun();//set refernce L1phase per run 

  void SetL1PhaseReferencePAR();//set reference L1phase for specific PAR in run
  void SetPARInfo(TString PARfilename);//for given run, load in PAR info from file

  void LoadBadChannelMap(); //load bad channel map, main
  void LoadBadChannelMapFile(); //load bad channel map from file
  void LoadBadChannelMapOADB();//load bad channel map from OADB
  Int_t GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const { 
    if(fBadChannelMapArray) return (Int_t) ((TH2I*)fBadChannelMapArray->At(iSM))->GetBinContent(iCol,iRow); 
    else return 0;}//Channel is ok by default
  Int_t GetEMCALChannelStatus(Int_t absId) const {
    if(fBadChannelMapArray) return (Int_t) ((TH2I*)fBadChannelMapArray->At(0))->GetBinContent(absId+1);
    else return 0;}//Channel is ok by default

  static void ProduceCalibConsts(TString inputFile="time186319testWOL0.root",TString outputFile="Reference.root",Bool_t isFinal=kFALSE, Bool_t isPAR=kFALSE);
  static void ProduceOffsetForSMsV2(Int_t runNumber,TString inputFile="Reference.root",TString outputFile="ReferenceSM.root",Bool_t offset100=kTRUE, Bool_t justL1phase=kTRUE,TString PARfilename="");

  private:
  
  // variables and functions needed for PAR handling
  std::vector<PARInfo> fPARvec; 
  PARInfo fCurrentPARs; 
  Int_t fCurrentPARIndex = 0; 
  Bool_t fIsPARRun = kFALSE; 
  void GetPARInfoForRunNumber(Int_t runnum);

  
  virtual void PrepareTOFT0maker();
  Bool_t SetEMCalGeometry();
  Bool_t AcceptCluster(AliVCluster* clus);
  Bool_t CheckCellRCU(Int_t nSupMod,Int_t icol,Int_t irow);
  Bool_t IsLowGainCellInCluster(AliVCluster* clus);

  // data members
  Int_t          fRunNumber ; 
  
//  /// pointer to get T0 from TOF
//  AliTOFT0maker *fTOFmaker;   //->
  
  TList         *fOutputList; //->
  
  AliEMCALGeometry *fgeom;              
  TString        fGeometryName ;        
   
  // setable variables for cuts
  
  Double_t       fMinClusterEnergy ;    
  Double_t       fMaxClusterEnergy ;    
  
  Int_t          fMinNcells ;           
  Int_t          fMaxNcells ;           
  
  Double_t       fMinLambda0 ;          
  Double_t       fMaxLambda0 ;          
  Double_t       fMinLambda0LG ;        
  Double_t       fMaxLambda0LG ;        
  
  Double_t       fMaxRtrack ;           
  
  Double_t       fMinCellEnergy;        

  TString        fReferenceFileName ;   
  TString        fReferenceRunByRunFileName ;   

  Bool_t         fPileupFromSPD ;       

  Double_t       fMinTime ;             
  Double_t       fMaxTime ;             

  Bool_t         fMostEneCellOnly ;     
  
  //histogram settings
  Int_t          fRawTimeNbins ;        
  Double_t       fRawTimeMin   ;        
  Double_t       fRawTimeMax   ;        
  Int_t          fPassTimeNbins;        
  Double_t       fPassTimeMin  ;        
  Double_t       fPassTimeMax  ;        
  Int_t          fEnergyNbins  ;        
  Double_t       fEnergyMin    ;        
  Double_t       fEnergyMax    ;        
  Int_t          fEnergyLGNbins;        
  Double_t       fEnergyLGMin  ;        
  Double_t       fEnergyLGMax  ;        
  Int_t          fFineNbins    ;        
  Double_t       fFineTmin     ;        
  Double_t       fFineTmax     ;        

  TObjArray     *fL1PhaseList;          
  Bool_t         fBadReco;              

  Bool_t         fFillHeavyHisto;       

  // bad channel map
  TObjArray     *fBadChannelMapArray;   
  Bool_t         fBadChannelMapSet;     
  Int_t          fSetBadChannelMapSource;
  TString        fBadChannelFileName ;  

  // histograms
  TH1F          *fhcalcEvtTime;         
  TH1F          *fhEvtTimeHeader;       
  TH1F          *fhEvtTimeDiff;         
  TH1F          *fhEventType;           
  TH1F          *fhTOFT0vsEventNumber;  
  TH2F          *fhTcellvsTOFT0;        
  TH2F          *fhTcellvsTOFT0HD;      
  TH2F          *fhTcellvsSM;           
  TH2F          *fhEneVsAbsIdHG;        
  TH2F          *fhEneVsAbsIdLG;        
  TH2F          *fhTimeVsBC;            

  // histos for storing the time values per cell for further averaging;
  TH1F    *fhTimeSumSq  [kNBCmask]; 
  TH1F    *fhTimeEnt    [kNBCmask]; 
  TH1F    *fhTimeSum    [kNBCmask]; 
  TH1F    *fhTimeLGSumSq[kNBCmask]; 
  TH1F    *fhTimeLGEnt  [kNBCmask]; 
  TH1F    *fhTimeLGSum  [kNBCmask]; 

  // histos with reference values after the first iteration  
  TH1F    *fhAllAverageBC   [kNBCmask]; 
  TH1F    *fhAllAverageLGBC [kNBCmask]; 

  // histo with reference values run-by-run after the first iteration 
  TH1C    *fhRefRuns; 

  // control histos
  TH2F    *fhTimeDsup  [kNSM];            
  TH2F    *fhTimeDsupBC[kNSM][kNBCmask];  
  TH2F    *fhTimeDsupLG  [kNSM];            
  TH2F    *fhTimeDsupLGBC[kNSM][kNBCmask];  

  //main histos for raw time
  TH2F          *fhRawTimeVsIdBC     [kNBCmask]; 
  TH1F          *fhRawTimeSumBC      [kNBCmask]; 
  TH1F          *fhRawTimeEntriesBC  [kNBCmask]; 
  TH1F          *fhRawTimeSumSqBC    [kNBCmask]; 
  TH2F          *fhRawTimeVsIdLGBC   [kNBCmask]; 
  TH1F          *fhRawTimeSumLGBC    [kNBCmask]; 
  TH1F          *fhRawTimeEntriesLGBC[kNBCmask]; 
  TH1F          *fhRawTimeSumSqLGBC  [kNBCmask]; 

  //histos for correction of Raw Time with PAR
  std::vector<std::vector<TH2F*>> fhRawTimePARs;
  std::vector<std::vector<TH2F*>> fhRawTimeLGPARs;

  //histos for raw time after wrong reconstruction correction (100ns and L1 phase)
  TH2F          *fhRawCorrTimeVsIdBC  [kNBCmask]; 
  TH2F          *fhRawCorrTimeVsIdLGBC[kNBCmask]; 

  //histos for raw time after wrong reconstruction correction (100ns and L1 phase) and new L1 phase
  TH2F          *fhTimeVsIdBC  [kNBCmask]; 
  TH2F          *fhTimeVsIdLGBC[kNBCmask]; 

  AliAnalysisTaskEMCALTimeCalib(           const AliAnalysisTaskEMCALTimeCalib&);
  
  AliAnalysisTaskEMCALTimeCalib& operator=(const AliAnalysisTaskEMCALTimeCalib&); 
  
  ClassDef(AliAnalysisTaskEMCALTimeCalib, 5) ;
};

#endif