]>
Commit | Line | Data |
---|---|---|
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 | Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); } | |
24 | Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,n); } | |
25 | void SetNoise( AliITSNoiseSSDv2* noise) {fNoise=noise;} | |
26 | ||
27 | Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); } | |
28 | Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,n); } | |
29 | void SetPedestal( AliITSPedestalSSDv2* pedestal) {fPedestal=pedestal;} | |
30 | ||
31 | Float_t GetGainP(Int_t n) {return fGain->GetGainP(fModule,n); } | |
32 | Float_t GetGainN(Int_t n) {return fGain->GetGainN(fModule,n); } | |
33 | void SetGainP(Int_t n, Float_t value) {fGain->AddGainP(fModule,n,value);} | |
34 | void SetGainN(Int_t n, Float_t value) {fGain->AddGainN(fModule,n,value);} | |
35 | void SetGain( AliITSGainSSDv2* gain) {fGain=gain;} | |
36 | ||
37 | void SetBad() { | |
38 | fIsBad = kTRUE; | |
39 | for(Int_t i=0;i<fgkChipsPerModule;i++) fIsChipBad[i]=kTRUE; | |
40 | } | |
41 | virtual Bool_t IsBad() const { return fIsBad; } | |
42 | void SetChipBad(Int_t nChip) { | |
43 | fIsChipBad[nChip] = kTRUE; | |
44 | } | |
45 | void FillBadChipMap(); | |
46 | virtual Bool_t IsChipBad(Int_t nChip) const { | |
47 | return fIsChipBad[nChip]; | |
48 | } | |
49 | Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module | |
50 | Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip | |
51 | ||
52 | void SetBadChannels( AliITSBadChannelsSSDv2* badchannels) { | |
53 | fBadChannels=badchannels;} | |
54 | Char_t GetBadPChannel(Int_t n) { | |
55 | return fBadChannels->GetBadChannelP(fModule,n); } | |
56 | Char_t GetBadNChannel(Int_t n) { | |
57 | return fBadChannels->GetBadChannelN(fModule,n); } | |
58 | Bool_t IsPChannelBad(Int_t n) { | |
59 | return fBadChannels->GetBadChannelP(fModule,n)&1; } | |
60 | Bool_t IsNChannelBad(Int_t n) { | |
61 | return fBadChannels->GetBadChannelN(fModule,n)&1; } | |
62 | ||
63 | // | |
64 | virtual void SetNDetParam(Int_t npar) { | |
65 | // set number of param | |
66 | fNPar=npar; | |
67 | } | |
68 | virtual void SetDetParam(Double_t *par); | |
69 | ||
70 | // Parameters options | |
71 | virtual Int_t NDetParam() const { | |
72 | // number of param | |
73 | return fNPar; | |
74 | } | |
75 | virtual void GetDetParam(Double_t *dpar) const; | |
76 | ||
77 | virtual void SetSigmaSpread(Double_t, Double_t) { | |
78 | NotImplemented("SetSigmaSpread");} | |
79 | ||
80 | virtual void SigmaSpread(Double_t &, Double_t &) const { | |
81 | NotImplemented("SetSigmaSpread");} | |
82 | ||
83 | void SetModule(Int_t mod){fModule = mod;} | |
84 | void SetModuleIndex(Int_t modId){ | |
85 | fModule=modId-500; // temporary patch, 500 is n. of SPD+SDD modules | |
86 | FillBadChipMap(); | |
87 | } | |
88 | void SetKeVperADC(Double_t a=86.4/120.){fKeVperADC = a;} | |
89 | Double_t ADCToKeV(Double_t adc) const {return adc*fKeVperADC;} | |
90 | ||
91 | void SetSSDADCpereV(Double_t a=(120./24888.9)*(85.0/77.0)){fSSDADCpereV = a;} | |
92 | Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;} | |
93 | Int_t GetSSDIEvToADC(Double_t eV) const { | |
94 | 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 | ClassDef(AliITSCalibrationSSD,6) //Response class for SSD | |
125 | }; | |
126 | #endif |