SDD digits modified. Both compressed and decompressed ADC values are stored - Tempora...
[u/mrichter/AliRoot.git] / ITS / AliITSresponseSDD.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 #include <Riostream.h>
19 #include <TRandom.h>
20
21 #include "AliITSresponseSDD.h"
22
23 //////////////////////////////////////////////////
24 //  Response class for set:ITS                      //
25 //  Specific subdetector implementation             //
26 //  for silicon drift detectors                     //
27 //                                                  //
28 //                                                  //
29 //////////////////////////////////////////////////////
30
31 const Int_t AliITSresponseSDD::fgkModules;   
32 const Int_t AliITSresponseSDD::fgkChips;  
33 const Int_t AliITSresponseSDD::fgkChannels; 
34 const Int_t AliITSresponseSDD::fgkMaxAdcDefault = 1024;
35 const Float_t AliITSresponseSDD::fgkDynamicRangeDefault = 132.;
36 const Float_t AliITSresponseSDD::fgkfChargeLossDefault = 0;
37 const Float_t AliITSresponseSDD::fgkDiffCoeffDefault = 3.23;
38 const Float_t AliITSresponseSDD::fgkDiffCoeff1Default = 30.;
39 const Float_t AliITSresponseSDD::fgkTemperatureDefault = 296.;
40 const TString AliITSresponseSDD::fgkParam1Default = "same";
41 const TString AliITSresponseSDD::fgkParam2Default = "same";
42 const Float_t AliITSresponseSDD::fgkNoiseDefault = 10.;
43 const Float_t AliITSresponseSDD::fgkBaselineDefault = 20.;
44 const TString AliITSresponseSDD::fgkOptionDefault = "1D";
45 const Float_t AliITSresponseSDD::fgkMinValDefault  = 4;
46 const Float_t AliITSresponseSDD::fgkDriftSpeedDefault = 7.3;
47 const Float_t AliITSresponseSDD::fgkNsigmasDefault = 3.;
48 const Int_t AliITSresponseSDD::fgkNcompsDefault = 121;
49 //______________________________________________________________________
50 ClassImp(AliITSresponseSDD)
51
52 AliITSresponseSDD::AliITSresponseSDD(){
53   // default constructor
54    fGaus = 0;
55    SetDeadChannels();
56    SetMaxAdc(fgkMaxAdcDefault);
57    SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
58    SetDriftSpeed(fgkDriftSpeedDefault);
59    SetNSigmaIntegration(fgkNsigmasDefault);
60    SetNLookUp(fgkNcompsDefault);
61    // SetClock();
62    SetNoiseParam(fgkNoiseDefault,fgkBaselineDefault);
63    SetNoiseAfterElectronics();
64    SetJitterError();
65    SetElectronics();
66    SetDynamicRange(fgkDynamicRangeDefault);
67    SetChargeLoss(fgkfChargeLossDefault);
68    SetThresholds(fgkMinValDefault,0.);
69    SetParamOptions(fgkParam1Default.Data(),fgkParam2Default.Data());
70    SetTemperature(fgkTemperatureDefault);
71    SetZeroSupp(fgkOptionDefault);
72    SetDataType();
73    SetFilenames();
74    SetOutputOption();
75    SetDo10to8();
76    // set the default zero suppression parameters
77    fCPar[0]=0;
78    fCPar[1]=0;
79    fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
80    fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
81    fCPar[4]=0;
82    fCPar[5]=0;
83    fCPar[6]=0;
84    fCPar[7]=0;
85 }
86 //______________________________________________________________________
87 AliITSresponseSDD::AliITSresponseSDD(const char *dataType){
88   // constructor
89    fGaus = 0;
90    SetDeadChannels();
91    SetMaxAdc(fgkMaxAdcDefault);
92    SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
93    SetDriftSpeed(fgkDriftSpeedDefault);
94    SetNSigmaIntegration(fgkNsigmasDefault);
95    SetNLookUp(fgkNcompsDefault);
96    // SetClock();
97    SetNoiseParam(fgkNoiseDefault,fgkBaselineDefault);
98    SetNoiseAfterElectronics();
99    SetJitterError();
100    SetElectronics();
101    SetDynamicRange(fgkDynamicRangeDefault);
102    SetChargeLoss(fgkfChargeLossDefault);
103    SetThresholds(fgkMinValDefault,0.);
104    SetParamOptions(fgkParam1Default.Data(),fgkParam2Default.Data());
105    SetTemperature(fgkTemperatureDefault);
106    SetZeroSupp(fgkOptionDefault);
107    SetDataType(dataType);
108    SetFilenames();
109    SetOutputOption();
110    SetDo10to8();
111    // set the default zero suppression parameters
112    fCPar[0]=0;
113    fCPar[1]=0;
114    fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
115    fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
116    fCPar[4]=0;
117    fCPar[5]=0;
118    fCPar[6]=0;
119    fCPar[7]=0;
120 }
121 //______________________________________________________________________
122 AliITSresponseSDD::AliITSresponseSDD(const AliITSresponseSDD &ob) : AliITSresponse(ob) {
123   // Copy constructor
124   // Copies are not allowed. The method is protected to avoid misuse.
125   Error("AliITSresponseSDD","Copy constructor not allowed\n");
126 }
127
128 //______________________________________________________________________
129 AliITSresponseSDD& AliITSresponseSDD::operator=(const AliITSresponseSDD& /* ob */){
130   // Assignment operator
131   // Assignment is not allowed. The method is protected to avoid misuse.
132   Error("= operator","Assignment operator not allowed\n");
133   return *this;
134 }
135
136 //______________________________________________________________________
137 AliITSresponseSDD::~AliITSresponseSDD() { 
138
139   if(fGaus) delete fGaus;
140 }
141
142 //______________________________________________________________________
143 Int_t AliITSresponseSDD::Convert8to10(Int_t signal) const {
144   // Undo the lossive 10 to 8 bit compression.
145   // code from Davide C. and Albert W.
146   if(Do10to8()){  // kTRUE if the compression is active
147     if (signal < 0 || signal > 255) {
148       Warning("Convert8to10","out of range signal=%d",signal);
149       return 0;
150     } // end if signal <0 || signal >255
151
152     if (signal < 128) return signal;
153     if (signal < 192) {
154       if (TMath::Odd(signal)) return (128+((signal-128)<<1));
155       else  return (128+((signal-128)<<1)+1);
156     } // end if signal < 192
157     if (signal < 224) {
158       if (TMath::Odd(signal)) return (256+((signal-192)<<3)+3);
159       else  return (256+((signal-192)<<3)+4);
160     } // end if signal < 224
161     if (TMath::Odd(signal)) return (512+((signal-224)<<4)+7);
162     return (512+((signal-224)<<4)+8);
163   }
164   else {  
165     return signal;
166   }
167 }
168
169 //______________________________________________________________________
170 void AliITSresponseSDD::SetCompressParam(Int_t  cp[8]){
171   // set compression param
172
173     Int_t i;
174     for (i=0; i<8; i++) {
175         fCPar[i]=cp[i];
176         //printf("\n CompressPar %d %d \n",i,fCPar[i]);    
177     } // end for i
178 }
179 //______________________________________________________________________
180 void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8]) const {
181   // give compression param
182
183     Int_t i;
184     for (i=0; i<8; i++) {
185         cp[i]=fCPar[i];
186     } // end for i
187 }
188 //______________________________________________________________________
189 void AliITSresponseSDD::SetNLookUp(Int_t p1){
190   // Set number of sigmas over which cluster disintegration is performed
191   fNcomps=p1;
192   fGaus = new TArrayF(fNcomps+1);
193   for(Int_t i=0; i<=fNcomps; i++) {
194     Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
195     (*fGaus)[i] = exp(-((x*x)/2));
196     //     cout << "fGaus[" << i << "]: " << fGaus->At(i) << endl;
197   }
198 }
199 //______________________________________________________________________
200 void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan){
201     // Set fGain to zero to simulate a random distribution of 
202     // dead modules, dead chips and single dead channels
203
204     for( Int_t m=0; m<fgkModules; m++ ) 
205         for( Int_t n=0; n<fgkChips; n++ ) 
206             for( Int_t p=0; p<fgkChannels; p++ ) 
207                  fGain[m][n][p] = 1.;
208                  
209     fDeadModules  = nmod;  
210     fDeadChips    = nchip;  
211     fDeadChannels = nchan; 
212     
213     // nothing to do
214     if( nmod == 0 && nchip == 0 && nchan == 0 ) return;
215
216     if( nmod < 0 || nmod > fgkModules ) 
217     { 
218         cout << "Wrong number of dead modules: " << nmod << endl; 
219         return; 
220     }
221     Int_t nmax = (fgkModules-nmod)*fgkChips; 
222     if( nchip < 0 || nchip > nmax ) 
223     { 
224         cout << "Wrong number of dead chips: " << nchip << endl; 
225         return; 
226     }
227     nmax = ((fgkModules - nmod)*fgkChips - nchip)*fgkChannels; 
228     if( nchan < 0 || nchan > nmax ) 
229     { 
230         cout << "Wrong number of dead channels: " << nchan << endl; 
231         return; 
232     }
233   
234     TRandom *gran = new TRandom();
235   
236     //  cout << "modules" << endl;
237     Int_t * mod = new Int_t [nmod];
238     Int_t i; //loop variable
239     for( i=0; i<nmod; i++ ) 
240     {
241         mod[i] = (Int_t) (1.+fgkModules*gran->Uniform());
242         cout << i+1 << ": Dead module nr: " << mod[i] << endl;
243         for(Int_t n=0; n<fgkChips; n++)
244             for(Int_t p=0; p<fgkChannels; p++)
245                 fGain[mod[i]-1][n][p] = 0.;
246     }
247
248     //  cout << "chips" << endl;
249     Int_t * chip     = new Int_t[nchip];
250     Int_t * chipMod = new Int_t[nchip];
251     i = 0;
252     while( i < nchip ) 
253     {
254         Int_t module = (Int_t) (fgkModules*gran->Uniform() + 1.);
255         if( module <=0 || module > fgkModules ) 
256             cout << "Wrong module: " << module << endl;
257         Int_t flagMod = 0;
258         for( Int_t k=0; k<nmod; k++ ) 
259             if( module == mod[k] ) { flagMod = 1; break; }
260         if( flagMod == 1 ) continue;
261         
262         Int_t chi = (Int_t) (fgkChips*gran->Uniform() + 1.);
263         if( chi <=0 || chi > fgkChips ) cout << "Wrong chip: " << chi << endl;
264         i++;
265         chip[i-1] = chi; 
266         chipMod[i-1] = module;
267         for( Int_t m=0; m<fgkChannels; m++ ) 
268             fGain[module-1][chi-1][m] = 0.;
269         cout << i << ": Dead chip nr. " << chip[i-1] << " in module nr: " 
270              << chipMod[i-1] << endl;
271     }
272
273     //  cout << "channels" << endl;
274     Int_t * channel      = new Int_t[nchan];
275     Int_t * channelChip = new Int_t[nchan];
276     Int_t * channelMod  = new Int_t[nchan];
277     i = 0;
278     while( i < nchan ) 
279     {
280         Int_t k; //loop variable
281         Int_t module = (Int_t) (fgkModules*gran->Uniform() + 1.);
282         if( module <=0 || module > fgkModules ) 
283             cout << "Wrong module: " << module << endl;
284         Int_t flagMod = 0;
285         for( k=0; k<nmod; k++ ) 
286             if( module == mod[k] ) { flagMod = 1; break; }
287         if( flagMod == 1 ) continue;
288         Int_t chipp = (Int_t) (fgkChips*gran->Uniform() + 1.);
289         if( chipp <=0 || chipp > fgkChips ) cout << "Wrong chip: "<< chipp<<endl;
290         Int_t flagChip = 0;
291         for( k=0; k<nchip; k++) 
292             if( chipp == chip[k] && module == chipMod[k] ) { 
293                 flagChip = 1; break; }
294         if( flagChip == 1 ) continue;
295         i++;
296         channel[i-1] = (Int_t) (fgkChannels*gran->Uniform() + 1.); 
297         if( channel[i-1] <=0 || channel[i-1] > fgkChannels ) 
298             cout << "Wrong channel: " << channel[i-1] << endl;
299         channelChip[i-1] = chipp;
300         channelMod[i-1] = module;
301         fGain[module-1][chipp-1][channel[i-1]-1] = 0.;
302         cout << i << ": Dead channel nr. " << channel[i-1] << " in chip nr. " 
303              << channelChip[i-1] << " in module nr: " << channelMod[i-1] 
304              << endl;
305     }
306     
307     delete [] mod;
308     delete [] chip;
309     delete [] chipMod;
310     delete [] channel;
311     delete [] channelMod;
312     delete [] channelChip;
313 }
314 //______________________________________________________________________
315 void AliITSresponseSDD::PrintGains(){
316     //
317
318   if( GetDeadModules() == 0 && 
319       GetDeadChips() == 0 && 
320       GetDeadChannels() == 0 )
321       return;  
322
323   // Print Electronics Gains
324   cout << "**************************************************" << endl; 
325   cout << "             Print Electronics Gains              " << endl;
326   cout << "**************************************************" << endl;
327
328   // Print SDD electronic gains
329   for(Int_t t=0; t<fgkModules;t++)
330     for(Int_t u=0; u<fgkChips;u++)
331       for(Int_t v=0; v<fgkChannels;v++)
332       {
333         if( fGain[t][u][v] != 1.0 )
334            cout << "Gain for Module: " << t+1 << ", Chip " << u+1 << 
335                    ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
336       }
337 }
338 //______________________________________________________________________
339 void AliITSresponseSDD::Print(){
340   // Print SDD response Parameters
341
342    cout << "**************************************************" << endl;
343    cout << "   Silicon Drift Detector Response Parameters    " << endl;
344    cout << "**************************************************" << endl;
345    cout << "Diffusion Coefficients: "<< fDiffCoeff<< ", "<<fDiffCoeff1 << endl;
346
347    cout << "Hardware compression parameters: " << endl; 
348    for(Int_t i=0; i<8; i++) cout << "fCPar[" << i << "] = " << fCPar[i] <<endl;
349    cout << "Noise before electronics (arbitrary units): " << fNoise << endl;
350    cout << "Baseline (ADC units): " << fBaseline << endl;
351    cout << "Noise after electronics (ADC units): " << fNoiseAfterEl << endl;
352
353    cout << "Dynamic Range: " << fDynamicRange << endl;
354    cout << "Charge Loss: " << fChargeLoss << endl;
355    cout << "Temperature: " << Temperature() << " K " << endl;
356    cout << "Drift Speed: " << fDriftSpeed << endl;
357    cout << "Electronics (1=PASCAL, 2=OLA): " << fElectronics << endl;
358
359    cout << "N. of Sigma for signal integration: " << fNsigmas << endl;
360    cout << "N. of bins in lookup table: " << fNcomps << endl;
361
362    cout << "Max. ADC Value: " << fMaxAdc << endl;
363    cout << "Min. Value: " << fMinVal << endl;
364
365    PrintGains();
366
367 }
368
369
370