Line data    Source code

       1             : #ifndef ALIITSCALIBRATIONSSD_H
       2             : #define ALIITSCALIBRATIONSSD_H
       3             : /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
       4             :  * See cxx source for full Copyright notice                               */ 
       5             : #include "AliITSCalibration.h"
       6             : #include "AliITSNoiseSSDv2.h"
       7             : #include "AliITSPedestalSSDv2.h"
       8             : #include "AliITSGainSSDv2.h"
       9             : #include "AliITSBadChannelsSSDv2.h"
      10             : 
      11             : /* $Id$ */
      12             : //////////////////////////////////////////////
      13             : // Calibration class for SSD                   //
      14             : //                                          //
      15             : //////////////////////////////////////////////
      16             : class AliITSCalibrationSSD : public AliITSCalibration {
      17             : 
      18             :  public:
      19             :     AliITSCalibrationSSD();
      20             :     AliITSCalibrationSSD(const char *dataType);
      21             :     virtual ~AliITSCalibrationSSD();
      22             : 
      23    20243124 :     Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); }
      24    20265278 :     Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,n); }
      25           8 :     void SetNoise( AliITSNoiseSSDv2* noise) {fNoise=noise;}
      26             : 
      27           0 :     Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); }
      28           0 :     Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,n); }
      29           0 :     void SetPedestal( AliITSPedestalSSDv2* pedestal) {fPedestal=pedestal;}
      30             : 
      31    30673888 :     Float_t GetGainP(Int_t n) {return fGain->GetGainP(fModule,n); }
      32    30696158 :     Float_t GetGainN(Int_t n) {return fGain->GetGainN(fModule,n); }
      33      654280 :     void SetGainP(Int_t n, Float_t value) {fGain->AddGainP(fModule,n,value);}
      34      638776 :     void SetGainN(Int_t n, Float_t value) {fGain->AddGainN(fModule,n,value);}
      35           8 :     void SetGain( AliITSGainSSDv2* gain) {fGain=gain;}
      36             : 
      37             :     void   SetBad() {
      38           0 :       fIsBad = kTRUE;
      39           0 :       for(Int_t i=0;i<fgkChipsPerModule;i++) fIsChipBad[i]=kTRUE;
      40           0 :     }
      41        6792 :     virtual Bool_t IsBad() const { return fIsBad; }
      42             :     void   SetChipBad(Int_t nChip) {
      43        3668 :       fIsChipBad[nChip] = kTRUE;
      44        1834 :     }
      45             :     void FillBadChipMap();
      46             :     virtual Bool_t IsChipBad(Int_t nChip) const {
      47       81504 :       return fIsChipBad[nChip];
      48             :     }
      49           0 :     Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module
      50    21028032 :     Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip
      51             : 
      52             :     void SetBadChannels( AliITSBadChannelsSSDv2* badchannels) {
      53           8 :       fBadChannels=badchannels;}
      54             :     Char_t GetBadPChannel(Int_t n) {
      55           0 :       return fBadChannels->GetBadChannelP(fModule,n); }
      56             :     Char_t GetBadNChannel(Int_t n) {
      57           0 :       return fBadChannels->GetBadChannelN(fModule,n); }
      58             :     Bool_t IsPChannelBad(Int_t n) {
      59    20865024 :       return fBadChannels->GetBadChannelP(fModule,n)&1; }
      60             :     Bool_t IsNChannelBad(Int_t n) {
      61    20865024 :       return fBadChannels->GetBadChannelN(fModule,n)&1; }
      62             : 
      63             :     //
      64             :     virtual  void   SetNDetParam(Int_t npar) {
      65             :         // set number of param
      66           0 :         fNPar=npar;
      67           0 :     }
      68             :     virtual  void   SetDetParam(Double_t *par);
      69             : 
      70             :     // Parameters options
      71             :     virtual Int_t   NDetParam() const {
      72             :         // number of param
      73           0 :         return fNPar;
      74             :     }
      75             :     virtual void    GetDetParam(Double_t *dpar) const; 
      76             : 
      77             :     virtual void    SetSigmaSpread(Double_t, Double_t) {
      78           0 :       NotImplemented("SetSigmaSpread");}
      79             :     
      80             :     virtual void    SigmaSpread(Double_t &, Double_t &) const {
      81           0 :       NotImplemented("SetSigmaSpread");}
      82             :     
      83       78710 :     void SetModule(Int_t mod){fModule = mod;}
      84             :     void SetModuleIndex(Int_t modId){
      85        6792 :       fModule=modId-500; // temporary patch, 500 is n. of SPD+SDD modules
      86        3396 :       FillBadChipMap();
      87        3396 :     }
      88          30 :     void SetKeVperADC(Double_t a=86.4/120.){fKeVperADC = a;}
      89       64560 :     Double_t ADCToKeV(Double_t adc) const {return adc*fKeVperADC;}
      90             : 
      91          30 :     void SetSSDADCpereV(Double_t a=(120./24888.9)*(85.0/77.0)){fSSDADCpereV = a;}
      92    40436992 :     Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;}
      93             :     Int_t GetSSDIEvToADC(Double_t eV) const { 
      94           0 :                                   return ((Int_t) GetSSDDEvToADC(eV)); }
      95             : 
      96             : 
      97             :  protected:
      98             : 
      99             :     static const Int_t fgkChipsPerModule  = 12;    // Number of chips/module
     100             :     static const Int_t fgkChannelsPerChip = 128;   // Number of channels/chip
     101             : 
     102             :     static const Int_t fgkNParDefault; // default for fNPar
     103             : 
     104             :     Int_t fModule;          //! module number (range 0 -> 1697)
     105             :     
     106             :     Int_t   fNPar;            // Number of detector param 
     107             :     Double_t *fDetPar;         //[fNPar] Array of parameters
     108             : 
     109             :     AliITSNoiseSSDv2 *fNoise; // pointer to noise calib object    
     110             :     AliITSPedestalSSDv2 *fPedestal; // pointer to pedestal calib object
     111             :     AliITSGainSSDv2 *fGain; // pointer to gain calib object
     112             :     AliITSBadChannelsSSDv2 *fBadChannels; // pointer to bad channels calib object
     113             : 
     114             :     Bool_t   fIsBad;                         // module is dead or alive ?
     115             :     Bool_t   fIsChipBad[fgkChipsPerModule];  // chip is dead or alive ?
     116             : 
     117             :     Double_t fSSDADCpereV;    // Constant to convert eV to ADC for SSD.
     118             :     Double_t fKeVperADC;       // Constant to convert ADC to keV
     119             : 
     120             :  private:
     121             :     AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
     122             :     AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.
     123             : 
     124         118 :     ClassDef(AliITSCalibrationSSD,6) //Response class for SSD
     125             :       };
     126             : #endif