remove props
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSPDscanAnalyzer.h
index 8a8ef7e..1af02d0 100644 (file)
@@ -1,48 +1,58 @@
 #ifndef ALIITSONLINESPDSCANANALYZER_H
 #define ALIITSONLINESPDSCANANALYZER_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
 
 ////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                 //
 // This class is used in the detector algorithm framework //
 // to process the data stored in special container files  //
 // (see AliITSOnlineSPDscan). For instance, minimum       //
-// threshold values can be calculated.                    //
+// threshold values can be extracted.                     //
 ////////////////////////////////////////////////////////////
 
 #include <TString.h>
+#include <TH1F.h>
 
 class AliITSOnlineSPDscan;
 class AliITSOnlineCalibrationSPDhandler;
 class TGraph;
 class TH2F;
+class TArrayI;
 
 class AliITSOnlineSPDscanAnalyzer {
 
  public:
-  AliITSOnlineSPDscanAnalyzer(const Char_t *fileName);
+  AliITSOnlineSPDscanAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler *handler, Bool_t readFromGridFile=kFALSE);
   AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle);
   ~AliITSOnlineSPDscanAnalyzer();
 
   AliITSOnlineSPDscanAnalyzer& operator=(const AliITSOnlineSPDscanAnalyzer& handle);
 
+  Bool_t     IsChipPresent(UInt_t hs, UInt_t chipNr);
+  Bool_t     IsOverWriteSet() const {return fOverWrite;}
+  void       SetCalibHandler(AliITSOnlineCalibrationSPDhandler * const handler) {fHandler=handler;}
   void       SetParam(const Char_t *pname, const Char_t *pval);
+  void       ReadParamsFromLocation(const Char_t *dirName);
 
   UInt_t     GetType() const {return fType;}
   UInt_t     GetDacId() const {return fDacId;}
-
+  
   Int_t      GetDelay(UInt_t hs, UInt_t chipNr);
   Int_t      GetMinTh(UInt_t hs, UInt_t chipNr);
+  TArrayI    GetMeanTh(UInt_t hs, UInt_t chipNr);
   
   Int_t      GetNrNoisyUnima(UInt_t hs, UInt_t chipNr);
 
-  Bool_t     ProcessDeadPixels(Char_t *oldCalibDir);
-  Bool_t     ProcessNoisyPixels(Char_t *oldCalibDir);
-  Bool_t     SaveDeadNoisyPixels(UInt_t module, Char_t *calibDir);
+  Bool_t     ProcessUniformity();
+  Bool_t     ProcessDeadPixels();
+  Bool_t     ProcessNoisyPixels();
 
   Bool_t     ProcessNrTriggers();
 
-  AliITSOnlineCalibrationSPDhandler* GetOnlineCalibrationHandler(UInt_t module);
-  AliITSOnlineSPDscan* GetOnlineScan() {return fScanObj;}
+  AliITSOnlineSPDscan* GetOnlineScan() const {return fScanObj;}
   UInt_t     GetRouterNr();
   Bool_t     GetHalfStavePresent(UInt_t hs);
 
@@ -50,7 +60,18 @@ class AliITSOnlineSPDscanAnalyzer {
   TGraph*    GetMeanMultiplicityG(UInt_t hs, UInt_t chipNr);
   TGraph*    GetHitEventEfficiencyG(UInt_t hs, UInt_t chipNr);
   TH2F*      GetHitMapTot(UInt_t step);
-
+  TH2F*      GetPhysicalHitMapTot(UInt_t step);
+  TH2F*      GetHitMapChip(UInt_t step, UInt_t hs, UInt_t chip);
+
+  Float_t    GetTPeff() const {return fTPeff;}
+  TH1F*      GetTPeffHS() const {return fTPeffHS;}
+  TH1F*      GetTPeffChip(UInt_t hs) const {return fTPeffChip[hs];}
+  Float_t    GetDeadPixel() const {return fDeadPixel;}
+  TH1F*      GetDeadPixelHS() const {return fDeadPixelHS;}
+  TH1F*      GetDeadPixelChip(UInt_t hs) const {return fDeadPixelChip[hs];}
+  Float_t    GetNoisyPixel() const {return fNoisyPixel;}
+  TH1F*      GetNoisyPixelHS() const {return fNoisyPixelHS;}
+  TH1F*      GetNoisyPixelChip(UInt_t hs) const {return fNoisyPixelChip[hs];}
 
  private:
   UInt_t               fType;           // calib type
@@ -58,14 +79,29 @@ class AliITSOnlineSPDscanAnalyzer {
   TString              fFileName;       // container file name
   enum                 calibvals{kMINTH,kMEANTH,kDAC,kUNIMA,kNOISE,kDELAY};  // calib types
 
-  AliITSOnlineSPDscan               *fScanObj;      // container obj
-  AliITSOnlineCalibrationSPDhandler *fHandler[240]; // calib help objs
+  AliITSOnlineSPDscan               *fScanObj;  // container obj
+  AliITSOnlineCalibrationSPDhandler *fHandler;  // calib helper obj
+  Bool_t     fbModuleScanned[240];        // is module used in scan?
 
   TGraph*    fMeanMultiplicity[6][11];   // mean mult graphs
   TGraph*    fHitEventEfficiency[6][11]; // hit event graphs
   TGraph*    fTriggers;                  // trigger graph
 
-  void       Init();                     // init
+  // uniformity scan analysis:
+  Float_t    fTPeff;                     // number of good pixels [%] (for full router)
+  TH1F*      fTPeffHS;                   // 6 bin histogram, number good pixels [%] (for each hs)
+  TH1F*      fTPeffChip[6];              // 10 bin histograms, number good pixels [%] (for each chip)
+  Float_t    fDeadPixel;                 // number of dead pixels [%] (for full router)
+  TH1F*      fDeadPixelHS;               // 6 bin histogram, number dead pixels [%] (for each hs)
+  TH1F*      fDeadPixelChip[6];          // 10 bin histograms, number dead pixels [%] (for each chip)
+  Float_t    fNoisyPixel;                // number of 'noisy' pixels [%] (for full router)
+  TH1F*      fNoisyPixelHS;              // 6 bin histogram, number 'noisy' pixels [%] (for each hs)
+  TH1F*      fNoisyPixelChip[6];         // 10 bin histograms, number 'noisy' pixels [%] (for each chip)
+  
+  void       Init(Bool_t readFromGridFile=kFALSE);                     // init
+
+  void       CreateUniformityHistograms(); // method to create all histograms to be filled by 'ProcessUniformity'
+  void       DeleteUniformityHistograms(); // method to delete all histograms used by uniformity scan analysis
 
   Bool_t     ProcessMeanMultiplicity();  // process mean mult
   Bool_t     ProcessHitEventEfficiency();// process hit event eff
@@ -85,6 +121,10 @@ class AliITSOnlineSPDscanAnalyzer {
   UInt_t     fStepDownDacSafe;          // nr of steps down to put threshold result (to be on the safe side)
   Float_t    fMaxBaseLineLevel;         // maximum value for the base line to compare with
 
+
+
 };
 
 #endif
+
+