- fixing warnings/coverity
[u/mrichter/AliRoot.git] / ITS / AliITSCalibrationSSD.h
CommitLineData
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//////////////////////////////////////////////
18class 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