AliCaloCalibSignal.h

Go to the documentation of this file.

#ifndef ALICALOCALIBSIGNAL_H
#define ALICALOCALIBSIGNAL_H

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

//________________________________________________________________________
//________________________________________________________________________

#include "TString.h"
#include "TTree.h"
#include "AliEMCALGeoParams.h"

class AliCaloRawStreamV3;
class AliCaloAltroMapping;
class AliRawReader;
class AliCaloRawAnalyzer;

class AliCaloCalibSignal : public TObject 
{
  
 public:

  enum kDetType {kPhos, kEmCal, kNone}; 
  
  AliCaloCalibSignal(kDetType detectorType = kEmCal); // ctor
  virtual ~AliCaloCalibSignal(); // dtor

private:
  
  // Just declare them, avoid compilation warning
  AliCaloCalibSignal             (const AliCaloCalibSignal & /*sig*/  ); // copy ctor
  AliCaloCalibSignal& operator = (const AliCaloCalibSignal &/*source*/); // assing operator
  
public:
  
  // Event processing methods:
  Bool_t   ProcessEvent(AliRawReader *rawReader);
  Bool_t   ProcessEvent(AliCaloRawStreamV3 *in, UInt_t Timestamp); // added header for time info
 
  Bool_t   CheckFractionAboveAmp(const int *AmpVal, int resultArray[]) const; 
  Bool_t   CheckLEDRefAboveAmp  (const int *AmpVal, int resultArray[]) const;

  // Mapping handling
  AliCaloAltroMapping **GetAltroMapping()                     const { return fMapping; }
  void                  SetAltroMapping(AliCaloAltroMapping **mapp) { fMapping = mapp; }

  // Fitter / Analyzer
  Int_t    GetFittingAlgorithm()        const { return fFittingAlgorithm ; }
  void     SetFittingAlgorithm(Int_t val) ;         
  AliCaloRawAnalyzer *GetRawAnalyzer()  const { return fRawAnalyzer      ; }  

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

  // Simple getters
  // * for TTree
  TTree *  GetTreeAmpVsTime()           const { return fTreeAmpVsTime      ; }
  TTree *  GetTreeAvgAmpVsTime()        const { return fTreeAvgAmpVsTime   ; }
  TTree *  GetTreeLEDAmpVsTime()        const { return fTreeLEDAmpVsTime   ; }
  TTree *  GetTreeLEDAvgAmpVsTime()     const { return fTreeLEDAvgAmpVsTime; }

  // how many points do we have for each tower&gain
  int      GetNHighGain(int imod, int icol, int irow) const 
    { int towId = GetTowerNum(imod, icol, irow); return fNHighGain[towId] ; } 
  int      GetNLowGain (int imod, int icol, int irow) const 
    { int towId = GetTowerNum(imod, icol, irow); return fNLowGain [towId] ; }

  int      GetNHighGain(int towId)      const { return fNHighGain[towId] ; }  
  int      GetNLowGain (int towId)      const { return fNLowGain [towId] ; }  

  // also for LED reference
  int      GetNRef(const int imod, const int istripMod, const int igain) const 
    { int refId = GetRefNum(imod, istripMod, igain); return fNRef[refId] ; }
  int      GetNRef(int refId)           const { return fNRef[refId] ; }

  // 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      GetTowerNum(const int imod,  const int icol, const int irow) const 
  { return (imod*fColumns*fRows + icol*fRows + irow) ; } // help index

  int      GetChannelNum(const int imod, const int icol, const int irow, const int igain) const 
  { return (igain*fModules*fColumns*fRows + imod*fColumns*fRows + icol*fRows + irow) ; } 
  
  Bool_t   DecodeChannelNum(const int chanId, 
                            int *imod, int *icol, int *irow, int *igain) const; 
  
  // LED reference indexing
  
  int      GetRefNum(const int imod, const int istripMod, const int igain) const 
  { return (igain*fModules*fLEDRefs + imod*fLEDRefs + istripMod) ; } 
  
  Bool_t   DecodeRefNum(const int refId, 
                        int *imod, int *istripMod, int *igain) const;
  
  // Basic Counters
  int      GetNEvents()                 const { return fNEvents         ; }
  int      GetNAcceptedEvents()         const { return fNAcceptedEvents ; }

  // Get and Set Cuts
  
  //  * Section for if we should help with the event selection of what is likely LED events
  void     SetAmpCut(double d)                { fAmpCut = d    ; }
  double   GetAmpCut()                  const { return fAmpCut ; }
  
  void     SetReqFractionAboveAmpCutVal(double d) { fReqFractionAboveAmpCutVal = d    ; }
  double   GetReqFractionAboveAmpCutVal()   const { return fReqFractionAboveAmpCutVal ; }
  
  void     SetReqFractionAboveAmp(bool b)     { fReqFractionAboveAmp = b    ; }
  bool     GetReqFractionAboveAmp()     const { return fReqFractionAboveAmp ; }
  
  //  * also for LED Reference/Mon channels
  void     SetAmpCutLEDRef(double d)          { fAmpCutLEDRef = d    ; }
  double   GetAmpCutLEDRef()            const { return fAmpCutLEDRef ; }
 
  void     SetReqLEDRefAboveAmpCutVal(bool b) { fReqLEDRefAboveAmpCutVal = b    ; }
  bool     GetReqLEDRefAboveAmpCutVal() const { return fReqLEDRefAboveAmpCutVal ; }

  // *  We may select to get averaged info
  void     SetUseAverage(bool b)              { fUseAverage = b    ; }
  bool     GetUseAverage()              const { return fUseAverage ; }
  
  void     SetSecInAverage(int secInAverage)  { fSecInAverage = secInAverage ; } 
  int      GetSecInAverage()            const { return fSecInAverage         ; }

  void     SetDownscale(int i)                { fDownscale = i    ; }
  int      GetDownscale()               const { return fDownscale ; }

  // * Info on time since start of run
  //   These times are typically the same, but not necessarily if the events do not come in order 
  //   Could be useful when we know the length of the run (i.e. after it is over), e.g. for PreProcessor
  double   GetHour()                    const { return fHour       ; } // time info for current event
  double   GetCurrentHour()             const { return fHour       ; } // time info for current event (same as GetHour(), just more explicitly named)
  double   GetLatestHour()              const { return fLatestHour ; } // the latest time encountered
  void     SetLatestHour(double d)            { fLatestHour = d    ; } 

  // * RunNumbers : setters and getters
  void     SetRunNumber(int runNo)            { fRunNumber = runNo ; }
  int      GetRunNumber()               const { return fRunNumber  ; }  
  
  // * Start-of-run timestamp : set and get
  void     SetStartTime(int startTime)        { fStartTime = startTime ; }
  int      GetStartTime()               const { return fStartTime      ; }

  // Analysis functions
  
  void     ResetInfo();
  Bool_t   AddInfo(const AliCaloCalibSignal *sig);  

  // Saving functions
  Bool_t   Save(TString fileName); 
  Bool_t   Analyze();

 private:
 
  void     DeleteTrees(); 
  void     Zero(); 
  void     CreateTrees(); 
  
 private:

  kDetType fDetType;                    
  int      fColumns;                    
  int      fRows;                       
  int      fLEDRefs;                    
  int      fModules;                    
 
  TString  fCaloString;                 
  AliCaloAltroMapping **fMapping;       
  
  Int_t    fFittingAlgorithm;           
  AliCaloRawAnalyzer *fRawAnalyzer;     
  
  int      fRunNumber;                  
  int      fStartTime;                  

  double   fAmpCut;                     
  double   fReqFractionAboveAmpCutVal;  
  bool     fReqFractionAboveAmp;        

  double   fAmpCutLEDRef;               
  bool     fReqLEDRefAboveAmpCutVal;    

  double   fHour;                       
  double   fLatestHour;                 
  bool     fUseAverage;                 
  int      fSecInAverage;               

  int      fDownscale;                  

  // status counters
  int      fNEvents;                    
  int      fNAcceptedEvents;            

  // 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 =  0; 
  static const int fgkPhosModules =  5; 
  
  // From numbers above: EMCal+DCal has more possible towers than PHOS
  static const int fgkMaxTowers   = 23040; 
  
  // for LED references; maximum from EMCAL
  static const int fgkMaxRefs     =   480; 

  static const int fgkNumSecInHr  =  3600; 
  
  // trees
  TTree  * fTreeAmpVsTime;              
  TTree  * fTreeAvgAmpVsTime;           
  TTree  * fTreeLEDAmpVsTime;           
  TTree  * fTreeLEDAvgAmpVsTime;        

  // counters
  int      fNHighGain[fgkMaxTowers]  ;  
  int      fNLowGain [fgkMaxTowers]  ;  
  int      fNRef     [fgkMaxRefs * 2];  
  
  ClassDef(AliCaloCalibSignal, 9) ;
  
};
    
#endif // ALICALOCALIBSIGNAL_H