ITS/AliITSCalibrationSSD.h

   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 #include "AliITSresponseSSD.h"
  11 #include "TArrayF.h"
  12 #include "TArrayI.h"
  13
  14 /* $Id$ */
  15 //////////////////////////////////////////////
  16 // Response class for SSD                   //
  17 //                                          //
  18 //////////////////////////////////////////////
  19 class AliITSCalibrationSSD : public AliITSCalibration {
  20
  21  public:
  22     AliITSCalibrationSSD();
  23     AliITSCalibrationSSD(const char *dataType);
  24     virtual ~AliITSCalibrationSSD();
  25
  26     virtual  void   SetNoiseParam(Double_t , Double_t ) {
  27       NotImplemented("SetNoiseParam");}
  28
  29     virtual void    GetNoiseParam(Double_t &, Double_t &) const {
  30       NotImplemented("SetNoiseParam");}
  31
  32     Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); }
  33     Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,n); }
  34     void SetNoise( AliITSNoiseSSDv2* noise) {fNoise=noise;}
  35
  36     Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); }
  37     Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,n); }
  38     void SetPedestal( AliITSPedestalSSDv2* pedestal) {fPedestal=pedestal;}
  39
  40     Float_t GetGainP(Int_t n) {return fGain->GetGainP(fModule,n); }
  41     Float_t GetGainN(Int_t n) {return fGain->GetGainN(fModule,n); }
  42     void SetGainP(Int_t n, Float_t value) {fGain->AddGainP(fModule,n,value);}
  43     void SetGainN(Int_t n, Float_t value) {fGain->AddGainN(fModule,n,value);}
  44     void SetGain( AliITSGainSSDv2* gain) {fGain=gain;}
  45
  46     void   SetBad() {
  47       fIsBad = kTRUE;
  48       for(Int_t i=0;i<fgkChipsPerModule;i++) fIsChipBad[i]=kTRUE;
  49     }
  50     virtual Bool_t IsBad() const { return fIsBad; }
  51     void   SetChipBad(Int_t nChip) {
  52       fIsChipBad[nChip] = kTRUE;
  53     }
  54     void FillBadChipMap();
  55     virtual Bool_t IsChipBad(Int_t nChip) const {
  56       return fIsChipBad[nChip];
  57     }
  58     Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module
  59     Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip
  60
  61     void SetBadChannels( AliITSBadChannelsSSDv2* badchannels) {
  62       fBadChannels=badchannels;}
  63     Char_t GetBadPChannel(Int_t n) {
  64       return fBadChannels->GetBadChannelP(fModule,n); }
  65     Char_t GetBadNChannel(Int_t n) {
  66       return fBadChannels->GetBadChannelN(fModule,n); }
  67     Bool_t IsPChannelBad(Int_t n) {
  68       return fBadChannels->GetBadChannelP(fModule,n)&1; }
  69     Bool_t IsNChannelBad(Int_t n) {
  70       return fBadChannels->GetBadChannelN(fModule,n)&1; }
  71
  72     //
  73     virtual  void   SetNDetParam(Int_t npar) {
  74         // set number of param
  75         fNPar=npar;
  76     }
  77     virtual  void   SetDetParam(Double_t *par);
  78
  79     // Parameters options
  80     virtual Int_t   NDetParam() const {
  81         // number of param
  82         return fNPar;
  83     }
  84     virtual void    GetDetParam(Double_t *dpar) const;
  85
  86     virtual void    SetSigmaSpread(Double_t, Double_t) {
  87       NotImplemented("SetSigmaSpread");}
  88
  89     virtual void    SigmaSpread(Double_t &, Double_t &) const {
  90       NotImplemented("SetSigmaSpread");}
  91
  92
  93     virtual void   SetThresholds(Double_t /* a */, Double_t /* b */)
  94       {NotImplemented("SetThresholds");}
  95     virtual void   Thresholds(Double_t & /* a */, Double_t & /* b */) const
  96       {NotImplemented("Thresholds");}
  97
  98     virtual void SetADCpereV(Double_t a=120./24888.9) {((AliITSresponseSSD*)fResponse)->SetADCpereV(a);}
  99     virtual Double_t GetDEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->DEvToADC(eV);}
 100     virtual Int_t IEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->IEvToADC(eV);}
 101
 102     virtual void SetKeVperADC(Double_t a=86.4/120.0) {((AliITSresponseSSD*)fResponse)->SetKeVperADC(a);}
 103     virtual Double_t ADCToKeV(Double_t adc) const {return ((AliITSresponseSSD*)fResponse)->ADCToKeV(adc);}
 104
 105   virtual Double_t GetCouplingPR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPR();}
 106   virtual Double_t GetCouplingPL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPL();}
 107   virtual Double_t GetCouplingNR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNR();}
 108   virtual Double_t GetCouplingNL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNL();}
 109   virtual void SetCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl)
 110     { ((AliITSresponseSSD*)fResponse)->SetCouplings(pr,pl,nr,nl);}
 111
 112   virtual Int_t GetZSThreshold() const {return ((AliITSresponseSSD*)fResponse)->GetZSThreshold();}
 113   virtual void SetZSThreshold(Int_t zsth)
 114     { ((AliITSresponseSSD*)fResponse)->SetZSThreshold(zsth);}
 115
 116  void SetModule(Int_t mod){fModule = mod;}
 117
 118 protected:
 119
 120     static const Int_t fgkChipsPerModule  = 12;    // Number of chips/module
 121     static const Int_t fgkChannelsPerChip = 128;   // Number of channels/chip
 122
 123     static const Int_t fgkNParDefault; // default for fNPar
 124
 125     Int_t fModule;          //! module number (range 0 -> 1697)
 126
 127     Int_t   fNPar;            // Number of detector param
 128     Double_t *fDetPar;         //[fNPar] Array of parameters
 129
 130     AliITSNoiseSSDv2 *fNoise;
 131     AliITSPedestalSSDv2 *fPedestal;
 132     AliITSGainSSDv2 *fGain;
 133     AliITSBadChannelsSSDv2 *fBadChannels;
 134
 135     Bool_t   fIsBad;                         // module is dead or alive ?
 136     Bool_t   fIsChipBad[fgkChipsPerModule];  // chip is dead or alive ?
 137
 138  private:
 139     AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
 140     AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.
 141
 142     ClassDef(AliITSCalibrationSSD,4) //Response class for SSD
 143       };
 144 #endif