AliCaloCalibPedestal.h

Go to the documentation of this file.

#ifndef ALICALOCALIBPEDESTAL_H
#define ALICALOCALIBPEDESTAL_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//________________________________________________________________________
//
//________________________________________________________________________

#include "TProfile.h"
#include "TProfile2D.h"
#include "TH2.h"
#include "TObjArray.h"

#include "AliEMCALGeoParams.h"
class AliCaloRawStreamV3;
class AliCaloAltroMapping;
class AliRawReader;

class AliCaloCalibPedestal : public TObject 
{
  
 public:

  enum kDetType {kPhos, kEmCal, kNone}; 
  
  enum kDeadMapEntry{kAlive = 0, kDead, kHot, kWarning, kResurrected, kRecentlyDeceased, kNumDeadMapStates}; 
  
  AliCaloCalibPedestal(kDetType detectorType = kEmCal);
  virtual ~AliCaloCalibPedestal();

  // copy ctor, and '=' operator, are not fully tested/debugged yet
  // at least for now; the reference info is not copied from one to the other
  AliCaloCalibPedestal(AliCaloCalibPedestal &ped); 
  AliCaloCalibPedestal& operator = (AliCaloCalibPedestal &source);
  
  // Event processing methods:  
  Bool_t ProcessEvent(AliRawReader *rawReader);
  Bool_t ProcessEvent(AliCaloRawStreamV3  *in);
  
  // Mapping handling
  AliCaloAltroMapping **GetAltroMapping()     const { return fMapping ; }
  void  SetAltroMapping(AliCaloAltroMapping **mapp) { fMapping = mapp ; }

  // Parameter/cut handling
  void SetParametersFromFile(const char *parameterFile);
  void WriteParametersToFile(const char *parameterFile);

  // Simple getters
  
  // * Main profiles:
  
  TProfile2D * GetPedProfileLowGain (int i)            { ValidateProfiles() ; return (TProfile2D*)fPedestalLowGain [i] ; }  
  TProfile2D * GetPedProfileHighGain(int i)            { ValidateProfiles() ; return (TProfile2D*)fPedestalHighGain[i] ; }  
  
  TProfile   * GetPedLEDRefProfileLowGain (int i)      { ValidateProfiles() ; return (TProfile*)fPedestalLEDRefLowGain [i] ; }   
  TProfile   * GetPedLEDRefProfileHighGain(int i)      { ValidateProfiles() ; return (TProfile*)fPedestalLEDRefHighGain[i] ; }  
  
  TProfile2D * GetPeakProfileLowGain (int i)           { ValidateProfiles() ; return (TProfile2D*)fPeakMinusPedLowGain [i] ; } 
  TProfile2D * GetPeakProfileHighGain(int i)           { ValidateProfiles() ; return (TProfile2D*)fPeakMinusPedHighGain[i] ; }  
  
  // * Differences to references:
  
  TProfile2D * GetPedProfileLowGainDiff (int i)        { ValidateComparisonProfiles() ; return (TProfile2D*)fPedestalLowGainDiff [i] ; }  
  TProfile2D * GetPedProfileHighGainDiff(int i)        { ValidateComparisonProfiles() ; return (TProfile2D*)fPedestalHighGainDiff[i] ; }
  
  TProfile   * GetPedLEDRefProfileLowGainDiff (int i)  { ValidateComparisonProfiles() ; return (TProfile*)fPedestalLEDRefLowGainDiff [i] ; }  
  TProfile   * GetPedLEDRefProfileHighGainDiff(int i)  { ValidateComparisonProfiles() ; return (TProfile*)fPedestalLEDRefHighGainDiff[i] ; }
  
  TProfile2D * GetPeakProfileLowGainDiff (int i)       { ValidateComparisonProfiles() ; return (TProfile2D*)fPeakMinusPedLowGainDiff [i] ; }  
  TProfile2D * GetPeakProfileHighGainDiff(int i)       { ValidateComparisonProfiles() ; return (TProfile2D*)fPeakMinusPedHighGainDiff[i] ; }  
  
  // * Ratio to references:
  
  TProfile2D * GetPedProfileLowGainRatio (int i)       { ValidateComparisonProfiles() ; return (TProfile2D*)fPedestalLowGainRatio [i] ; } 
  TProfile2D * GetPedProfileHighGainRatio(int i)       { ValidateComparisonProfiles() ; return (TProfile2D*)fPedestalHighGainRatio[i] ; }   
  
  TProfile   * GetPedLEDRefProfileLowGainRatio (int i) { ValidateComparisonProfiles() ; return (TProfile*)fPedestalLEDRefLowGainRatio [i] ; } 
  TProfile   * GetPedLEDRefProfileHighGainRatio(int i) { ValidateComparisonProfiles() ; return (TProfile*)fPedestalLEDRefHighGainRatio[i] ; }   
  
  TProfile2D * GetPeakProfileLowGainRatio (int i)      { ValidateComparisonProfiles() ; return (TProfile2D*)fPeakMinusPedLowGainRatio [i] ; } 
  TProfile2D * GetPeakProfileHighGainRatio(int i)      { ValidateComparisonProfiles() ; return (TProfile2D*)fPeakMinusPedHighGainRatio[i] ; }   
  
  TH2F       * GetPeakHighGainHisto(int i)             { ValidateProfiles() ; return (TH2F*)fPeakMinusPedHighGainHisto[i] ; }   

  // * Bad channels:
  
  TH2D       * GetDeadMap(int i)                       { ValidateProfiles() ; return (TH2D*)fDeadMap[i] ; }
//void         SetDeadMap(int i, TH2D *h)              { ((TH2D*)fDeadMap[i])=h ; }

  TObjArray    GetDeadMap()                            { ValidateProfiles() ; return fDeadMap ; }
  void         SetDeadMap(TObjArray map)               { fDeadMap = map ; }

  Bool_t IsBadChannel    (int imod, int icol, int irow) const; 
  void   SetChannelStatus(int imod, int icol, int irow, int status); 
  Int_t  GetChannelStatus(int imod, int icol, int irow) const { return  (Int_t)((TH2D*)fDeadMap[imod])->GetBinContent(icol, irow) ; }
  
  // Basic info
  
  // * getters  
  
  kDetType GetDetectorType()         const { return fDetType ; } 
  TString  GetCaloString()           const { return fCaloString ; }  
  
  int      GetColumns()              const { return fColumns ; }  //The number of columns per module
  int      GetRows()                 const { return fRows    ; }  //The number of rows per module
  int      GetLEDRefs()              const { return fLEDRefs ; }  //The number of LED references/monitors per module
  int      GetModules()              const { return fModules ; }  //The number of modules
  int      GetRowMin()               const { return fRowMin  ; }  //for histo def.
  int      GetRowMax()               const { return fRowMax  ; }  //for histo def.
  int      GetRowMultiplier()        const { return fRowMultiplier ; }  //for histo filling

  // * RunNumbers : setters and getters
  void     SetRunNumber(int runNo)         { fRunNumber = runNo ; } 
  int      GetRunNumber()            const { return fRunNumber  ; } 
  int      GetRefRunNumber()         const { if (fReference) return fReference->GetRunNumber(); else return -1 ; } 

  // * Possibility to select only some samples for the pedestal calculation
  
  void     SetSelectPedestalSamples(Bool_t flag = kFALSE) { fSelectPedestalSamples = flag  ; } 
  Bool_t   GetSelectPedestalSamples()               const { return fSelectPedestalSamples  ; } 
  
  void     SetFirstPedestalSample(int i)   { fFirstPedestalSample = i    ; } // first sample to use
  void     SetLastPedestalSample (int i)   { fLastPedestalSample  = i    ; } // last sample to use
  int      GetFirstPedestalSample()  const { return fFirstPedestalSample ; } // first sample to use
  int      GetLastPedestalSample ()  const { return fLastPedestalSample  ; } // last sample to use

  // * Set threshold/event fraction for tower warnings
  void     SetDeadThreshold(int i)         { fDeadThreshold    = i    ; } // peak - pedestal dead threshold
  void     SetWarningThreshold(int i)      { fWarningThreshold = i    ; } // peak - pedestal warning threshold
  void     SetWarningFraction(double d)    { fWarningFraction  = d    ; } // event fraction for warnings
  int      GetDeadThreshold()        const { return fDeadThreshold    ; } // peak - pedestal dead threshold
  int      GetWarningThreshold()     const { return fWarningThreshold ; } // peak - pedestal warning threshold
  double   GetWarningFraction()      const { return fWarningFraction  ; } // event fraction for warnings
  
  // * hot towers
  void     SetHotSigma(double d)           { fHotSigma = d    ; } // rms away from normal
  double   GetHotSigma()             const { return fHotSigma ; }  // rms away from normal

  // * Basic counters
  int      GetNEvents()              const { return fNEvents    ; } 
  int      GetNChanFills()           const { return fNChanFills ; } 
  
  //Analysis functions
  
  void     SetDeadTowerCount(Int_t dead)   { fDeadTowers = dead ; } 
  int      GetDeadTowerCount()       const { return fDeadTowers ; }
  double   GetDeadTowerRatio()       const { return fDeadTowers/(double)(fRows*fColumns) ; } 
  int      GetDeadTowerNew()         const { return fNewDeadTowers ; } 
  int      GetDeadTowerResurrected() const { return fResurrectedTowers ; }  

  void     Reset();

  Bool_t   AddInfo(AliCaloCalibPedestal *ped);  
  
  //Functions related to comparing this with another (reference) run.
  Bool_t   LoadReferenceCalib(TString fileName, TString objectName); 
  
  AliCaloCalibPedestal * GetReference() const { return fReference ; }  
  Bool_t                 SetReference(AliCaloCalibPedestal *ref);

  void     ComputeDiffAndRatio();
  void     ComputeDeadTowers(const char * deadMapFile = 0);
  void     ComputeHotAndWarningTowers(const char * hotMapFile = 0);

  // Saving functions
  Bool_t   SaveHistograms(TString fileName, Bool_t saveEmptyHistos = kFALSE); 

  void     Init() { ValidateProfiles() ; } // do basic setup

 private:
  
  void     ValidateProfiles(); 
  void     CompressAndSetOwner();
  void     ValidateComparisonProfiles();
  
  // The histograms. We use a TObjArray instead of a simple array,because this gives automatic streaming properties for the
  // class. A TClonesArray would be more efficient, but it's a bit more difficult to use and it doesn't matter too much
  // since we have only one object per module in the array anyway.
  
  TObjArray fPedestalLowGain;             
  TObjArray fPedestalHighGain;            
  TObjArray fPedestalLEDRefLowGain;       
  TObjArray fPedestalLEDRefHighGain;      
  TObjArray fPeakMinusPedLowGain;         
  TObjArray fPeakMinusPedHighGain;        

  TObjArray fPeakMinusPedHighGainHisto;   
  
  // The difference of profiles between this and the reference object
  TObjArray fPedestalLowGainDiff;         
  TObjArray fPedestalHighGainDiff;        
  TObjArray fPedestalLEDRefLowGainDiff;   
  TObjArray fPedestalLEDRefHighGainDiff;  
  TObjArray fPeakMinusPedLowGainDiff;     
  TObjArray fPeakMinusPedHighGainDiff;    
  
  // The ratio of profiles between this and the reference object
  TObjArray fPedestalLowGainRatio;        
  TObjArray fPedestalHighGainRatio;       
  TObjArray fPedestalLEDRefLowGainRatio;  
  TObjArray fPedestalLEDRefHighGainRatio; 
  TObjArray fPeakMinusPedLowGainRatio;    
  TObjArray fPeakMinusPedHighGainRatio;   
  
  TObjArray fDeadMap;                     

  // Status counters
  int       fNEvents;                     
  int       fNChanFills;                  

  // The dead tower counts
  int       fDeadTowers;                  
  int       fNewDeadTowers;               
  int       fResurrectedTowers;           
  
  AliCaloCalibPedestal * fReference;      
  
  kDetType  fDetType;                     
  
  int       fColumns;                     
  int       fRows;                        
  
  int       fLEDRefs;                     
  int       fModules;                     
  
  int       fRowMin;                      
  int       fRowMax;                      
  int       fRowMultiplier;               
  
  TString   fCaloString;                  
  AliCaloAltroMapping **fMapping;         
  
  int       fRunNumber;                   
 
  Bool_t    fSelectPedestalSamples;       
  int       fFirstPedestalSample;         
  int       fLastPedestalSample;          

  int       fDeadThreshold;               
  int       fWarningThreshold;            
  double    fWarningFraction;             
  double    fHotSigma;                    

  // Constants needed by the class: EMCAL ones are kept in AliEMCALGeoParams.h
  static const int fgkPhosRows    = 64;   
  static const int fgkPhosCols    = 56;   
  static const int fgkPhosLEDRefs =  1;   
  static const int fgkPhosModules =  5;   

  ClassDef(AliCaloCalibPedestal, 8) ;

};
    
#endif // ALICALOCALIBPEDESTAL_H