#ifndef ALIITSCALIBRATIONSSD_H
#define ALIITSCALIBRATIONSSD_H
-
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
#include "AliITSCalibration.h"
+#include "AliITSNoiseSSD.h"
+#include "AliITSPedestalSSD.h"
+#include "AliITSGainSSD.h"
+#include "AliITSBadChannelsSSD.h"
#include "AliITSresponseSSD.h"
-#include "TArrayD.h"
+#include "TArrayF.h"
#include "TArrayI.h"
+/* $Id$ */
//////////////////////////////////////////////
// Response class for SSD //
// //
//////////////////////////////////////////////
-
-
class AliITSCalibrationSSD : public AliITSCalibration {
public:
np=fNoiseP; nn=fNoiseN;
}
- // EF
- void SetNNoiseP(Int_t n) { fNoisP.Set(n); }
- void AddNoiseP(Int_t c, Double_t n) { fNoisP.AddAt(n,c);}
- TArrayD GetNoiseP() const {return fNoisP; }
- Double_t GetNoiseP(Int_t n) {return fNoisP.At(n); }
- void SetNNoiseN(Int_t n) { fNoisN.Set(n); }
- void AddNoiseN(Int_t c, Double_t n) { fNoisN.AddAt(n,c);}
- TArrayD GetNoiseN() const {return fNoisN; }
- Double_t GetNoiseN(Int_t n) {return fNoisN.At(n); }
-
- void SetNGainP(Int_t n) { fGainP.Set(n); }
- void AddGainP(Int_t c, Double_t n) { fGainP.AddAt(n,c);}
- TArrayD GetGainP() const {return fGainP; }
- Double_t GetGainP(Int_t n) {return fGainP.At(n); }
- void SetNGainN(Int_t n) { fGainN.Set(n); }
- void AddGainN(Int_t c, Double_t n) { fGainN.AddAt(n,c);}
- TArrayD GetGainN() const {return fGainN; }
- Double_t GetGainN(Int_t n) {return fGainN.At(n); }
+ void AddNoiseP(Int_t c, Float_t n) { fNoise->AddNoiseP(c,n);}
+ TArrayF GetNoiseP() {return fNoise->GetNoiseP(); }
+ Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(n); }
+ void AddNoiseN(Int_t c, Float_t n) { fNoise->AddNoiseN(c,n);}
+ TArrayF GetNoiseN() {return fNoise->GetNoiseN(); }
+ Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(n); }
+ void SetNoise( AliITSNoiseSSD* noise) {fNoise=noise;}
+
+ void AddPedestalP(Int_t c, Float_t n) { fPedestal->AddPedestalP(c,n);}
+ TArrayF GetPedestalP() {return fPedestal->GetPedestalP(); }
+ Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(n); }
+ void AddPedestalN(Int_t c, Float_t n) { fPedestal->AddPedestalN(c,n);}
+ TArrayF GetPedestalN() {return fPedestal->GetPedestalN(); }
+ Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(n); }
+ void SetPedestal( AliITSPedestalSSD* pedestal) {fPedestal=pedestal;}
+
+ void AddGainP(Int_t c, Float_t n) { fGain->AddGainP(c,n);}
+ TArrayF GetGainP() {return fGain->GetGainP(); }
+ Float_t GetGainP(Int_t n) {return fGain->GetGainP(n); }
+ void AddGainN(Int_t c, Float_t n) { fGain->AddGainN(c,n);}
+ TArrayF GetGainN() {return fGain->GetGainN(); }
+ Float_t GetGainN(Int_t n) {return fGain->GetGainN(n); }
+ void SetGain( AliITSGainSSD* gain) {fGain=gain;}
+
+ TArrayI GetBadPChannelsList() { return fBadChannels->GetBadPChannelsList(); } const
+ TArrayI GetBadNChannelsList() { return fBadChannels->GetBadNChannelsList(); } const
+ void SetBadChannels( AliITSBadChannelsSSD* badchannels) {fBadChannels=badchannels;}
void SetNoisePThreshold(Int_t threshold) { fNoisePThreshold = threshold;}
void AddNoisyPChannel(Int_t c, Int_t n) { fNoisyPChannelsList.AddAt(n,c);}
virtual void SetParamOptions(const char *opt1, const char *opt2) {((AliITSresponseSSD*)fResponse)->SetParamOptions(opt1,opt2);}
virtual void GetParamOptions(char *opt1,char *opt2) const {((AliITSresponseSSD*)fResponse)->ParamOptions(opt1,opt2);}
- virtual void SetADCpereV(Double_t a=200./30000.0) {((AliITSresponseSSD*)fResponse)->SetADCpereV(a);}
+ virtual void SetADCpereV(Double_t a=120./24888.9) {((AliITSresponseSSD*)fResponse)->SetADCpereV(a);}
virtual Double_t GetDEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->DEvToADC(eV);}
virtual Int_t IEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->IEvToADC(eV);}
+ virtual void SetKeVperADC(Double_t a=86.4/120.0) {((AliITSresponseSSD*)fResponse)->SetKeVperADC(a);}
+ virtual Double_t ADCToKeV(Double_t adc) const {return ((AliITSresponseSSD*)fResponse)->ADCToKeV(adc);}
+
virtual Double_t GetCouplingPR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPR();}
virtual Double_t GetCouplingPL() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingPL();}
virtual Double_t GetCouplingNR() const {return ((AliITSresponseSSD*)fResponse)->GetCouplingNR();}
Double_t fSigmaP; // Sigma charge spread on Pside
Double_t fSigmaN; // Sigma charge spread on Nside
- TArrayD fGainP; // Gain for P side channels
- TArrayD fGainN; // Gain for N side channels
+ AliITSNoiseSSD *fNoise;
+ AliITSPedestalSSD *fPedestal;
+ AliITSGainSSD *fGain;
+ AliITSBadChannelsSSD *fBadChannels;
+
+ TArrayF fGainP; // Gain for P side channels
+ TArrayF fGainN; // Gain for N side channels
+
+ TArrayF fNoisP; // Noise for P side channels
+ TArrayF fNoisN; // Noise for N side channels
- TArrayD fNoisP; // Noise for P side channels
- TArrayD fNoisN; // Noise for N side channels
+ TArrayF fPedP;
+ TArrayF fPedN;
- Double_t fNoisePThreshold; // need to decide if channel is noisy
+ Float_t fNoisePThreshold; // need to decide if channel is noisy
TArrayI fNoisyPChannelsList; // list of P side noisy channels
- Double_t fNoiseNThreshold; // need to decide if channel is noisy
+ Float_t fNoiseNThreshold; // need to decide if channel is noisy
TArrayI fNoisyNChannelsList; // list of N side noisy channels
TArrayI fDeadNChannelsList; // list of P side dead channels
AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.
- ClassDef(AliITSCalibrationSSD,1) //Response class for SSD
+ ClassDef(AliITSCalibrationSSD,2) //Response class for SSD
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff