X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSresponseSDD.h;h=2026ffc335a5135108fbb848a096b0c80c7ef0da;hb=bab623297f43e4477d214ff163659850c9ef2f25;hp=ae69204fdd001769c4e5aaaa44537a299067b2d9;hpb=fa4f0f62df4ac0d6ba95f8e53b076a5468333040;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSresponseSDD.h b/ITS/AliITSresponseSDD.h index ae69204fdd0..2026ffc335a 100644 --- a/ITS/AliITSresponseSDD.h +++ b/ITS/AliITSresponseSDD.h @@ -5,8 +5,8 @@ * See cxx source for full Copyright notice */ -#include -#include +#include +#include /* $Id$ */ @@ -16,110 +16,127 @@ // for all the modules. // ///////////////////////////////////////////////////////////// -class AliITSresponseSDD : public AliITSresponse { - public: - - AliITSresponseSDD(); - virtual ~AliITSresponseSDD(); - - virtual void SetElectronics(Int_t p1=1) - {fElectronics=p1; /* Electronics: Pascal (1) or OLA (2) */ } - virtual Int_t Electronics() const {// Electronics: 1 = Pascal; 2 = OLA - return fElectronics;} - virtual void SetMaxAdc(Double_t p1) {// Adc-count saturation value - fMaxAdc=p1;} - virtual Float_t MaxAdc() const {// Get maximum Adc-count value - return fMaxAdc;} - virtual void SetChargeLoss(Double_t p1) { - // Set Linear Charge Loss Steepness // 0.01 for 20% - fChargeLoss=p1;} - virtual Float_t ChargeLoss() const {// Get Charge Loss Coefficient - return fChargeLoss;} - virtual void SetDynamicRange(Double_t p1) {// Set Dynamic Range - fDynamicRange = p1;} - virtual Float_t DynamicRange() const {// Get Dynamic Range - return fDynamicRange;} - - static Float_t DefaultDriftSpeed() {return fgkDriftSpeedDefault;} - - virtual void SetTimeOffset(Float_t to){fTimeOffset = to;} - virtual Float_t TimeOffset()const {return fTimeOffset;} - static Float_t DefaultTimeOffset() {return fgkTimeOffsetDefault;} - - virtual void SetADC2keV(Float_t conv){fADC2keV=conv;} - virtual Float_t ADC2keV()const {return fADC2keV;} - static Float_t DefaulttADC2keV() {return fgkADC2keVDefault;} - - virtual void SetParamOptions(const char *opt1,const char *opt2) { - // Parameters: "same" or read from "file" - fParam1=opt1; fParam2=opt2;} - virtual void ParamOptions(char *opt1,char *opt2) const {// options - strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());} - - void SetZeroSupp (const char *opt) { - // Zero-suppression option - could be ZS or NOTSUPP - fOption=opt;} - const char *ZeroSuppOption() const {// Get zero-suppression option - return fOption.Data();} - // Detector type response methods - virtual void SetNSigmaIntegration(Double_t p1) { - // Set number of sigmas over which cluster disintegration is performed - fNsigmas=p1;} - virtual Float_t NSigmaIntegration() const { - // Get number of sigmas over which cluster disintegration is performed - return fNsigmas;} - virtual void SetNLookUp(Int_t p1); - // Get number of intervals in which the gaussian lookup table is divided - virtual Int_t GausNLookUp() const {return fNcomps;} - virtual Float_t GausLookUp(Int_t i) { - if (!fGaus) SetNLookUp(fgkNcompsDefault); - if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i); +class AliITSresponseSDD : public TObject { + public: + enum {kVDCorr2Side = BIT(14)}; // if bit set, the object contains separate corrections for 2 sides + // + AliITSresponseSDD(); + virtual ~AliITSresponseSDD(){}; + + virtual void SetSideATimeZero(Float_t tzero){ + SetLayer3ATimeZero(tzero); + SetLayer4ATimeZero(tzero); + } + virtual void SetSideCTimeZero(Float_t tzero){ + SetLayer3CTimeZero(tzero); + SetLayer4CTimeZero(tzero); + } + virtual void SetLayer3ATimeZero(Float_t tzero){ + for(Int_t iLad=1; iLad<=kNLaddersLay3; iLad++) SetHalfLadderATimeZero(3,iLad,tzero); + } + virtual void SetLayer3CTimeZero(Float_t tzero){ + for(Int_t iLad=1; iLad<=kNLaddersLay3; iLad++) SetHalfLadderCTimeZero(3,iLad,tzero); + } + virtual void SetLayer4ATimeZero(Float_t tzero){ + for(Int_t iLad=1; iLad<=kNLaddersLay4; iLad++) SetHalfLadderATimeZero(4,iLad,tzero); + } + virtual void SetLayer4CTimeZero(Float_t tzero){ + for(Int_t iLad=1; iLad<=kNLaddersLay4; iLad++) SetHalfLadderCTimeZero(4,iLad,tzero); + } + virtual void SetHalfLadderATimeZero(Int_t lay, Int_t lad, Float_t tzero); + virtual void SetHalfLadderCTimeZero(Int_t lay, Int_t lad, Float_t tzero); + virtual void SetModuleTimeZero(Int_t modIndex, Float_t tzero){ + if(modIndexkNSPDmods+kNSDDmods) AliError(Form("SDD module number %d out of range",modIndex)); + fTimeZero[modIndex-kNSPDmods]=tzero; + } + + virtual void SetDeltaVDrift(Int_t modIndex, Float_t dv, Bool_t rightSide=kFALSE) { + int ind = GetVDIndex(modIndex,rightSide); + if (ind>=0) fDeltaVDrift[ind] = dv; + } + + virtual Float_t GetDeltaVDrift(Int_t modIndex,Bool_t rightSide=kFALSE) const { + int ind = GetVDIndex(modIndex,rightSide); + return ind<0 ? 0.:fDeltaVDrift[ind]; + } + // + Bool_t IsVDCorr2Side() const {return TestBit(kVDCorr2Side);} + void SetVDCorr2Side(Bool_t v=kTRUE) {SetBit(kVDCorr2Side,v);} + // + static Float_t DefaultTimeOffset() {return fgkTimeOffsetDefault;} + virtual void SetTimeOffset(Float_t to){fTimeOffset = to;} + virtual Float_t GetTimeOffset()const {return fTimeOffset;} + virtual Float_t GetTimeZero(Int_t modIndex) const { + if(modIndexkNSPDmods+kNSDDmods){ + AliError(Form("SDD module number %d out of range",modIndex)); + return 0.; + } + return fTimeZero[modIndex-kNSPDmods]; + } + + virtual void SetADC2keV(Float_t conv){fADC2keV=conv;} + virtual Float_t GetADC2keV()const {return fADC2keV;} + virtual void SetADCtokeV(Int_t modIndex, Float_t conv){ + if(modIndexkNSPDmods+kNSDDmods) AliError(Form("SDD module number %d out of range",modIndex)); + fADCtokeV[modIndex-kNSPDmods]=conv; + } + virtual Float_t GetADCtokeV(Int_t modIndex) const { + if(modIndexkNSPDmods+kNSDDmods){ + AliError(Form("SDD module number %d out of range",modIndex)); + return 0.; } - - void SetJitterError(Float_t jitter=20) { - // set Jitter error (20 um for ALICE from beam test measurements 2001) - fJitterError=jitter;} - Float_t JitterError() const {// set Jitter error - return fJitterError;} + return fADCtokeV[modIndex-kNSPDmods]; + } + + virtual void SetChargevsTime(Float_t slope){fChargevsTime=slope;} + virtual Float_t GetChargevsTime()const {return fChargevsTime;} + + static Float_t DefaultADC2keV() {return fgkADC2keVDefault;} + static Float_t DefaultChargevsTime() {return fgkChargevsTimeDefault;} + + static Float_t GetCarlosRXClockPeriod() {return fgkCarlosRXClockPeriod;} + void PrintChargeCalibrationParams() const; + void PrintTimeZeroes() const; + void PrintVdriftCorerctions() const; + protected: + // + virtual Int_t GetVDIndex(Int_t modIndex, Bool_t rightSide=kFALSE) const { + int ind = modIndex - kNSPDmods; + if(ind<0 || ind>=kNSDDmods) {AliError(Form("SDD module number %d out of range",modIndex)); return -1;} + return (rightSide && IsVDCorr2Side()) ? ind + kNSDDmods : ind; + } + + + protected: + + enum {kNSPDmods = 240}; + enum {kNSDDmods = 260}; + enum {kNLaddersLay3 = 14}; + enum {kNLaddersLay4 = 22}; + + + static const Float_t fgkTimeOffsetDefault; // default for fTimeOffset + static const Float_t fgkADC2keVDefault; // default for fADC2keV + static const Float_t fgkChargevsTimeDefault; // default for fChargevsTime + static const Float_t fgkCarlosRXClockPeriod; // clock period for CarlosRX - static const Int_t fgkMaxAdcDefault; // default for fMaxAdc - static const Float_t fgkDynamicRangeDefault; // default for fDynamicRange - static const Float_t fgkfChargeLossDefault; // default for fChargeLoss - static const Float_t fgkDiffCoeffDefault; // default for fDiffCoeff - static const Float_t fgkDiffCoeff1Default; // default for fDiffCoeff1 - static const TString fgkParam1Default; // default for fParam1 - static const TString fgkParam2Default; // default for fParam2 - static const TString fgkOptionDefault; // default for fOption - static const Float_t fgkDriftSpeedDefault; // default for drift speed - static const Float_t fgkTimeOffsetDefault; // default for fTimeOffset - static const Float_t fgkADC2keVDefault; // default for fADC2keV - static const Float_t fgkNsigmasDefault; //default for fNsigmas - static const Int_t fgkNcompsDefault; //default for fNcomps - - - Float_t fJitterError; // jitter error - Float_t fDynamicRange; // Set Dynamic Range - Float_t fChargeLoss; // Set Linear Coefficient for Charge Loss - Float_t fTimeOffset; // Time offset due to electronic delays - Float_t fADC2keV; // Conversion factor from ADC to keV - Int_t fElectronics; // Electronics - Float_t fMaxAdc; // Adc saturation value - Float_t fNsigmas; // Number of sigmas over which charge disintegration - // is performed - TArrayF *fGaus; // Gaussian lookup table for signal generation - Int_t fNcomps; // Number of samplings along the gaussian - TString fOption; // Zero-suppresion option (ZS or non-ZS) - TString fParam1; // Read baselines from file option - TString fParam2; // Read compression algo thresholds from file + Float_t fTimeOffset; // Time offset due to electronic delays + // --> obsolete, kept for backw. comp. + Float_t fTimeZero[kNSDDmods]; // Time Zero for each module + Float_t fDeltaVDrift[2*kNSDDmods]; // Vdrift correction (um/ns) for each module left (=kNSDDmods) sides + Float_t fADC2keV; // Conversion factor from ADC to keV + // --> obsolete, kept for backw. comp. + Float_t fChargevsTime; // Correction for zero suppression effect + Float_t fADCtokeV[kNSDDmods]; // ADC to keV conversion for each module private: - AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor - AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op. + AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor + AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op. - ClassDef(AliITSresponseSDD,11) // Base response class - + ClassDef(AliITSresponseSDD,20) + }; #endif