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