]>
Commit | Line | Data |
---|---|---|
fcf95fc7 | 1 | #ifndef ALIITSCALIBRATIONSSD_H |
2 | #define ALIITSCALIBRATIONSSD_H | |
b42cfa25 | 3 | /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * |
4 | * See cxx source for full Copyright notice */ | |
fcf95fc7 | 5 | #include "AliITSCalibration.h" |
88128115 | 6 | #include "AliITSNoiseSSDv2.h" |
7 | #include "AliITSPedestalSSDv2.h" | |
8 | #include "AliITSGainSSDv2.h" | |
9 | #include "AliITSBadChannelsSSDv2.h" | |
569a17d8 | 10 | #include "TArrayF.h" |
14a74335 | 11 | #include "TArrayI.h" |
fcf95fc7 | 12 | |
b42cfa25 | 13 | /* $Id$ */ |
fcf95fc7 | 14 | ////////////////////////////////////////////// |
8be4e1b1 | 15 | // Calibration class for SSD // |
fcf95fc7 | 16 | // // |
17 | ////////////////////////////////////////////// | |
18 | class AliITSCalibrationSSD : public AliITSCalibration { | |
19 | ||
20 | public: | |
21 | AliITSCalibrationSSD(); | |
22 | AliITSCalibrationSSD(const char *dataType); | |
23 | virtual ~AliITSCalibrationSSD(); | |
14a74335 | 24 | |
ced4d9bc | 25 | Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); } |
26 | Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,n); } | |
88128115 | 27 | void SetNoise( AliITSNoiseSSDv2* noise) {fNoise=noise;} |
fb4dfab9 | 28 | |
ced4d9bc | 29 | Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); } |
30 | Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,n); } | |
88128115 | 31 | void SetPedestal( AliITSPedestalSSDv2* pedestal) {fPedestal=pedestal;} |
b42cfa25 | 32 | |
ced4d9bc | 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);} | |
88128115 | 37 | void SetGain( AliITSGainSSDv2* gain) {fGain=gain;} |
fb4dfab9 | 38 | |
df1d5598 | 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 | } | |
23197852 | 47 | void FillBadChipMap(); |
df1d5598 | 48 | virtual Bool_t IsChipBad(Int_t nChip) const { |
49 | return fIsChipBad[nChip]; | |
50 | } | |
ced4d9bc | 51 | Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module |
52 | Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip | |
53 | ||
88128115 | 54 | void SetBadChannels( AliITSBadChannelsSSDv2* badchannels) { |
ced4d9bc | 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; } | |
14a74335 | 64 | |
ced4d9bc | 65 | // |
fcf95fc7 | 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 | ||
ced4d9bc | 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 | ||
bb292d31 | 85 | void SetModule(Int_t mod){fModule = mod;} |
aac93143 | 86 | void SetModuleIndex(Int_t modId){ |
87 | fModule=modId-500; // temporary patch, 500 is n. of SPD+SDD modules | |
88 | FillBadChipMap(); | |
89 | } | |
bb292d31 | 90 | void SetKeVperADC(Double_t a=86.4/120.){fKeVperADC = a;} |
91 | Double_t ADCToKeV(Double_t adc) const {return adc*fKeVperADC;} | |
14a74335 | 92 | |
c23ff1b4 | 93 | void SetSSDADCpereV(Double_t a=(120./24888.9)*(85.0/77.0)){fSSDADCpereV = a;} |
bb292d31 | 94 | Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;} |
95 | Int_t GetSSDIEvToADC(Double_t eV) const { | |
96 | return ((Int_t) GetSSDDEvToADC(eV)); } | |
14a74335 | 97 | |
ced4d9bc | 98 | |
8be4e1b1 | 99 | protected: |
df1d5598 | 100 | |
101 | static const Int_t fgkChipsPerModule = 12; // Number of chips/module | |
102 | static const Int_t fgkChannelsPerChip = 128; // Number of channels/chip | |
103 | ||
fcf95fc7 | 104 | static const Int_t fgkNParDefault; // default for fNPar |
14a74335 | 105 | |
ced4d9bc | 106 | Int_t fModule; //! module number (range 0 -> 1697) |
107 | ||
fcf95fc7 | 108 | Int_t fNPar; // Number of detector param |
109 | Double_t *fDetPar; //[fNPar] Array of parameters | |
110 | ||
88128115 | 111 | AliITSNoiseSSDv2 *fNoise; |
112 | AliITSPedestalSSDv2 *fPedestal; | |
113 | AliITSGainSSDv2 *fGain; | |
114 | AliITSBadChannelsSSDv2 *fBadChannels; | |
fb4dfab9 | 115 | |
df1d5598 | 116 | Bool_t fIsBad; // module is dead or alive ? |
117 | Bool_t fIsChipBad[fgkChipsPerModule]; // chip is dead or alive ? | |
118 | ||
8be4e1b1 | 119 | Double_t fSSDADCpereV; // Constant to convert eV to ADC for SSD. |
120 | Double_t fKeVperADC; // Constant to convert ADC to keV | |
121 | ||
fcf95fc7 | 122 | private: |
123 | AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor | |
124 | AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op. | |
125 | ||
c23ff1b4 | 126 | ClassDef(AliITSCalibrationSSD,6) //Response class for SSD |
ced4d9bc | 127 | }; |
fcf95fc7 | 128 | #endif |