Line data    Source code

       1             : #ifndef ALIITSONLINESDDCMN_H
       2             : #define ALIITSONLINESDDCMN_H
       3             : 
       4             : ///////////////////////////////////////////////////////////////////
       5             : //                                                               //
       6             : // Class used for SDD noise corrected for common mode analysis   //
       7             : // Origin: F.Prino, Torino, prino@to.infn.it                     //
       8             : //                                                               //
       9             : ///////////////////////////////////////////////////////////////////
      10             : #include "AliITSOnlineSDD.h"
      11             : 
      12             : class TH1F;
      13             : class TH2F;
      14             : class TGraph;
      15           0 : class AliITSOnlineSDDCMN : public AliITSOnlineSDD {
      16             : 
      17             :  public:
      18             :   AliITSOnlineSDDCMN();
      19             :   AliITSOnlineSDDCMN(Int_t nddl, Int_t ncarlos, Int_t sid);
      20             :   virtual ~AliITSOnlineSDDCMN();
      21             :   void Reset();
      22             :   TH2F* GetCleanEvent(const TH2F* hrawd) const;
      23             :   void AddEvent(TH2F* hrawd);
      24             :   void ValidateAnodes();
      25             :   void ValidateModule();
      26             :   void ReadBaselines();
      27             : 
      28           0 :   void SetMinNoise(Float_t ns=0.001){fMinCorrNoise=ns;}
      29           0 :   void SetMaxNoise(Float_t ns=9.){fMaxCorrNoise=ns;}
      30           0 :   void SetNSigmaNoise(Float_t ns=4.){fNSigmaNoise=ns;}
      31           0 :   void SetMinNumGoodAnForGoodMod(Int_t cut=16){fMinNumGoodAnForGoodMod=cut;}
      32           0 :   void SetCutOnGoodAnodeClusterSize(Int_t clu=5){fMinClusterOfGoodAn=clu;}
      33             : 
      34           0 :   Bool_t IsAnodeGood(Int_t iAnode)const{ return fGoodAnode[iAnode];}
      35             :   Int_t CountGoodAnodes() const{
      36             :     Int_t nGdAn=0;
      37           0 :     for(Int_t ian=0;ian<fgkNAnodes;ian++) if(fGoodAnode[ian]) nGdAn++;  
      38           0 :     return nGdAn;
      39             :   }
      40             : 
      41           0 :   Float_t GetAnodeBaseline(Int_t iAnode) const{ return fBaseline[iAnode];}
      42           0 :   Int_t GetAnodeEqualizedBaseline(Int_t iAnode) const{ return fEqBaseline[iAnode];}
      43           0 :   Int_t GetAnodeBaselineOffset(Int_t iAnode) const{ return fOffsetBaseline[iAnode];}
      44           0 :   Float_t GetAnodeRawNoise(Int_t iAnode) const{ return fRawNoise[iAnode];}
      45           0 :   Float_t GetAnodeCommonMode(Int_t iAnode) const{ return fCMN[iAnode];}
      46             :   Float_t GetAnodeCorrNoise(Int_t iAnode) const{
      47           0 :     if(fNEvents>0) return fSumCorrNoise[iAnode]/fNEvents;
      48           0 :     else return 0;
      49           0 :   }
      50             : 
      51             :   Float_t CalcMeanNoise() const;
      52           0 :   Int_t GetNEvents() const {return fNEvents;}
      53             :   
      54             :   TH1F* GetBaselineAnodeHisto() const;
      55             :   TH1F* GetRawNoiseAnodeHisto() const;
      56             :   TH1F* GetCorrNoiseAnodeHisto() const;
      57             :   TH1F* GetCMNCoefAnodeHisto() const;
      58             :   TH1F* GetStatusAnodeHisto() const;
      59             :   TH1F* GetBaselineHisto() const;
      60             :   TH1F* GetRawNoiseHisto() const;
      61             :   TH1F* GetCorrNoiseHisto() const;
      62             : 
      63             :   void WriteToASCII();
      64             :   Bool_t WriteToROOT(TFile *fil);
      65             : 
      66             :  protected:
      67             : 
      68             :  private:
      69             :   Int_t fNEvents;                    // number of events
      70             :   Int_t fLowThreshold;             // low threshold for zero supp.
      71             :   Int_t fHighThreshold;            // high threshold for zero supp.
      72             :   Bool_t fGoodAnode[fgkNAnodes];     // anode quality: good(1) - bad (0)
      73             :   Float_t fBaseline[fgkNAnodes];     // array of anode baselines
      74             :   Int_t fEqBaseline[fgkNAnodes];     // array of anode baselines after equalization
      75             :   Int_t fOffsetBaseline[fgkNAnodes]; // array of offsets for baseline equal.
      76             :   Float_t fRawNoise[fgkNAnodes];     // array of anode raw noise
      77             :   Float_t fSumCorrNoise[fgkNAnodes]; // corrected noise summed over events
      78             :   Float_t fCMN[fgkNAnodes];          // common mode noise coeff.
      79             :   Float_t fMinCorrNoise;             // Cut value for minimum corrected noise
      80             :   Float_t fMaxCorrNoise;             // Cut value for maximum corrected noise
      81             :   Float_t fNSigmaNoise;              // Cut value for corrected noise (n*sigma)
      82             :   Int_t   fMinNumGoodAnForGoodMod;   // Min. n. good anodes to tag mod as good
      83             :   Int_t   fMinClusterOfGoodAn;       // Min. n. of adjacent good anodes
      84             : 
      85         116 :   ClassDef(AliITSOnlineSDDCMN,4);
      86             : };
      87             : #endif