Line data    Source code

       1             : #ifndef ALIITSONLINESDDBASE_H
       2             : #define ALIITSONLINESDDBASE_H
       3             : 
       4             : ///////////////////////////////////////////////////////////////////
       5             : //                                                               //
       6             : // Class used for SDD baseline and noise analysis                //
       7             : // Origin: F.Prino, Torino, prino@to.infn.it                     //
       8             : //                                                               //
       9             : ///////////////////////////////////////////////////////////////////
      10             : #include "AliITSOnlineSDD.h"
      11             : #include <TMath.h>
      12             : 
      13             : class TH2F;
      14             : class TGraph;
      15           0 : class AliITSOnlineSDDBase : public AliITSOnlineSDD {
      16             : 
      17             :  public:
      18             :   AliITSOnlineSDDBase();
      19             :   AliITSOnlineSDDBase(Int_t nddl, Int_t ncarlos, Int_t sid);
      20             :   virtual ~AliITSOnlineSDDBase();
      21             :   void Reset();
      22             :   void AddEvent(TH2F* hrawd);
      23             :   void ValidateAnodes();
      24             : 
      25           0 :   void SetMinBaseline(Float_t bas=10.){fMinBaseline=bas;}
      26           0 :   void SetMaxBaseline(Float_t bas=150.){fMaxBaseline=bas;}
      27           0 :   void SetMinRawNoise(Float_t ns=0.5){fMinRawNoise=ns;}
      28           0 :   void SetMaxRawNoise(Float_t ns=9.){fMaxRawNoise=ns;}
      29           0 :   void SetNSigmaNoise(Float_t ns=4.){fNSigmaNoise=ns;}
      30           0 :   void SetGoldenBaselineValue(Float_t val=20.){fGoldenBaseline=val;}
      31             :   void SetZeroSuppThresholds(Float_t vall=2.2,Float_t valh=4.){
      32           0 :     fLowThrFact=vall;
      33           0 :     fHighThrFact=valh;
      34           0 :   }
      35             : 
      36           0 :   Bool_t IsAnodeGood(Int_t iAnode)const{ return fGoodAnode[iAnode];}
      37             :   Float_t GetAnodeBaseline(Int_t iAnode) const{
      38           0 :     if(fNEvents>0) return fSumBaseline[iAnode]/fNEvents;
      39           0 :     else return 0;
      40           0 :   }
      41             :   void GetMinAndMaxBaseline(Float_t &basMin, Float_t &basMax) const;
      42             :   Float_t GetMinimumBaseline() const;
      43             :   Float_t GetAnodeRawNoise(Int_t iAnode) const;
      44             : 
      45             :   Int_t CountGoodAnodes() const{
      46             :     Int_t nGdAn=0;
      47           0 :     for(Int_t ian=0;ian<fgkNAnodes;ian++) if(fGoodAnode[ian]) nGdAn++;  
      48           0 :     return nGdAn;
      49             :   }
      50             :   Float_t CalcMeanRawNoise() const;
      51             :   Float_t GetAnodeCommonMode(Int_t iAnode) const{
      52           0 :     if(fNEvents>0) return fSumCMN[iAnode]/fNEvents;
      53           0 :     else return 0;
      54           0 :   }
      55           0 :   Int_t GetNEvents() const {return fNEvents;}
      56             :   void WriteToASCII();
      57             : 
      58             :  protected:
      59             : 
      60             :  private:
      61             :   static const Int_t fgkMaxCorr;     // maximum baseline correction in AMBRA (=63)
      62             : 
      63             :   Int_t fNEvents;                    // number of events
      64             :   Bool_t fGoodAnode[fgkNAnodes];     // anode quality: good(1) - bad (0)
      65             :   Float_t fSumBaseline[fgkNAnodes];  // baseline summed over events
      66             :   Float_t fSumRawNoise[fgkNAnodes];  // noise summed over events
      67             :   Float_t fSumCMN[fgkNAnodes];       // common mode noise coeff.
      68             :   Float_t fMinBaseline;              // Cut value for minimum baseline
      69             :   Float_t fMaxBaseline;              // Cut value for maximum baseline
      70             :   Float_t fMinRawNoise;              // Cut value for minimum noise
      71             :   Float_t fMaxRawNoise;              // Cut value for maximum noise
      72             :   Float_t fNSigmaNoise;              // Cut value for noise (n*sigma)
      73             :   Float_t fGoldenBaseline;           // golden value for equalizing baselines
      74             :   Float_t fLowThrFact;               // factor for low threshold
      75             :   Float_t fHighThrFact;              // factor for high threshold
      76             : 
      77         116 :   ClassDef(AliITSOnlineSDDBase,2);
      78             : };
      79             : 
      80             : inline Float_t AliITSOnlineSDDBase::GetAnodeRawNoise(Int_t iAnode) const{
      81             :   // compute raw noise for given anode
      82             :   Float_t noise2=0.;
      83           0 :   if(fNEvents>0) noise2=fSumRawNoise[iAnode]/fNEvents-fSumBaseline[iAnode]*fSumBaseline[iAnode]/fNEvents/fNEvents;
      84           0 :   if(noise2>0.) return TMath::Sqrt(noise2);
      85           0 :   else return 0;
      86           0 : }
      87             : 
      88             : #endif