Some clean-up in AliITSresponse classes + coding conventions
[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 void AliITSresponseSDD::SetCompressParam(Int_t  cp[8]){
143   // set compression param
144
145     Int_t i;
146     for (i=0; i<8; i++) {
147         fCPar[i]=cp[i];
148         //printf("\n CompressPar %d %d \n",i,fCPar[i]);    
149     } // end for i
150 }
151 //______________________________________________________________________
152 void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8]) const {
153   // give compression param
154
155     Int_t i;
156     for (i=0; i<8; i++) {
157         cp[i]=fCPar[i];
158     } // end for i
159 }
160 //______________________________________________________________________
161 void AliITSresponseSDD::SetNLookUp(Int_t p1){
162   // Set number of sigmas over which cluster disintegration is performed
163   fNcomps=p1;
164   fGaus = new TArrayF(fNcomps+1);
165   for(Int_t i=0; i<=fNcomps; i++) {
166     Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
167     (*fGaus)[i] = exp(-((x*x)/2));
168     //     cout << "fGaus[" << i << "]: " << fGaus->At(i) << endl;
169   }
170 }
171 //______________________________________________________________________
172 void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan){
173     // Set fGain to zero to simulate a random distribution of 
174     // dead modules, dead chips and single dead channels
175
176     for( Int_t m=0; m<fgkModules; m++ ) 
177         for( Int_t n=0; n<fgkChips; n++ ) 
178             for( Int_t p=0; p<fgkChannels; p++ ) 
179                  fGain[m][n][p] = 1.;
180                  
181     fDeadModules  = nmod;  
182     fDeadChips    = nchip;  
183     fDeadChannels = nchan; 
184     
185     // nothing to do
186     if( nmod == 0 && nchip == 0 && nchan == 0 ) return;
187
188     if( nmod < 0 || nmod > fgkModules ) 
189     { 
190         cout << "Wrong number of dead modules: " << nmod << endl; 
191         return; 
192     }
193     Int_t nmax = (fgkModules-nmod)*fgkChips; 
194     if( nchip < 0 || nchip > nmax ) 
195     { 
196         cout << "Wrong number of dead chips: " << nchip << endl; 
197         return; 
198     }
199     nmax = ((fgkModules - nmod)*fgkChips - nchip)*fgkChannels; 
200     if( nchan < 0 || nchan > nmax ) 
201     { 
202         cout << "Wrong number of dead channels: " << nchan << endl; 
203         return; 
204     }
205   
206     TRandom *gran = new TRandom();
207   
208     //  cout << "modules" << endl;
209     Int_t * mod = new Int_t [nmod];
210     Int_t i; //loop variable
211     for( i=0; i<nmod; i++ ) 
212     {
213         mod[i] = (Int_t) (1.+fgkModules*gran->Uniform());
214         cout << i+1 << ": Dead module nr: " << mod[i] << endl;
215         for(Int_t n=0; n<fgkChips; n++)
216             for(Int_t p=0; p<fgkChannels; p++)
217                 fGain[mod[i]-1][n][p] = 0.;
218     }
219
220     //  cout << "chips" << endl;
221     Int_t * chip     = new Int_t[nchip];
222     Int_t * chipMod = new Int_t[nchip];
223     i = 0;
224     while( i < nchip ) 
225     {
226         Int_t module = (Int_t) (fgkModules*gran->Uniform() + 1.);
227         if( module <=0 || module > fgkModules ) 
228             cout << "Wrong module: " << module << endl;
229         Int_t flagMod = 0;
230         for( Int_t k=0; k<nmod; k++ ) 
231             if( module == mod[k] ) { flagMod = 1; break; }
232         if( flagMod == 1 ) continue;
233         
234         Int_t chi = (Int_t) (fgkChips*gran->Uniform() + 1.);
235         if( chi <=0 || chi > fgkChips ) cout << "Wrong chip: " << chi << endl;
236         i++;
237         chip[i-1] = chi; 
238         chipMod[i-1] = module;
239         for( Int_t m=0; m<fgkChannels; m++ ) 
240             fGain[module-1][chi-1][m] = 0.;
241         cout << i << ": Dead chip nr. " << chip[i-1] << " in module nr: " 
242              << chipMod[i-1] << endl;
243     }
244
245     //  cout << "channels" << endl;
246     Int_t * channel      = new Int_t[nchan];
247     Int_t * channelChip = new Int_t[nchan];
248     Int_t * channelMod  = new Int_t[nchan];
249     i = 0;
250     while( i < nchan ) 
251     {
252         Int_t k; //loop variable
253         Int_t module = (Int_t) (fgkModules*gran->Uniform() + 1.);
254         if( module <=0 || module > fgkModules ) 
255             cout << "Wrong module: " << module << endl;
256         Int_t flagMod = 0;
257         for( k=0; k<nmod; k++ ) 
258             if( module == mod[k] ) { flagMod = 1; break; }
259         if( flagMod == 1 ) continue;
260         Int_t chipp = (Int_t) (fgkChips*gran->Uniform() + 1.);
261         if( chipp <=0 || chipp > fgkChips ) cout << "Wrong chip: "<< chipp<<endl;
262         Int_t flagChip = 0;
263         for( k=0; k<nchip; k++) 
264             if( chipp == chip[k] && module == chipMod[k] ) { 
265                 flagChip = 1; break; }
266         if( flagChip == 1 ) continue;
267         i++;
268         channel[i-1] = (Int_t) (fgkChannels*gran->Uniform() + 1.); 
269         if( channel[i-1] <=0 || channel[i-1] > fgkChannels ) 
270             cout << "Wrong channel: " << channel[i-1] << endl;
271         channelChip[i-1] = chipp;
272         channelMod[i-1] = module;
273         fGain[module-1][chipp-1][channel[i-1]-1] = 0.;
274         cout << i << ": Dead channel nr. " << channel[i-1] << " in chip nr. " 
275              << channelChip[i-1] << " in module nr: " << channelMod[i-1] 
276              << endl;
277     }
278     
279     delete [] mod;
280     delete [] chip;
281     delete [] chipMod;
282     delete [] channel;
283     delete [] channelMod;
284     delete [] channelChip;
285 }
286 //______________________________________________________________________
287 void AliITSresponseSDD::PrintGains(){
288     //
289
290   if( GetDeadModules() == 0 && 
291       GetDeadChips() == 0 && 
292       GetDeadChannels() == 0 )
293       return;  
294
295   // Print Electronics Gains
296   cout << "**************************************************" << endl; 
297   cout << "             Print Electronics Gains              " << endl;
298   cout << "**************************************************" << endl;
299
300   // Print SDD electronic gains
301   for(Int_t t=0; t<fgkModules;t++)
302     for(Int_t u=0; u<fgkChips;u++)
303       for(Int_t v=0; v<fgkChannels;v++)
304       {
305         if( fGain[t][u][v] != 1.0 )
306            cout << "Gain for Module: " << t+1 << ", Chip " << u+1 << 
307                    ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
308       }
309 }
310 //______________________________________________________________________
311 void AliITSresponseSDD::Print(){
312   // Print SDD response Parameters
313
314    cout << "**************************************************" << endl;
315    cout << "   Silicon Drift Detector Response Parameters    " << endl;
316    cout << "**************************************************" << endl;
317    cout << "Diffusion Coefficients: "<< fDiffCoeff<< ", "<<fDiffCoeff1 << endl;
318
319    cout << "Hardware compression parameters: " << endl; 
320    for(Int_t i=0; i<8; i++) cout << "fCPar[" << i << "] = " << fCPar[i] <<endl;
321    cout << "Noise before electronics (arbitrary units): " << fNoise << endl;
322    cout << "Baseline (ADC units): " << fBaseline << endl;
323    cout << "Noise after electronics (ADC units): " << fNoiseAfterEl << endl;
324
325    cout << "Dynamic Range: " << fDynamicRange << endl;
326    cout << "Charge Loss: " << fChargeLoss << endl;
327    cout << "Temperature: " << Temperature() << " K " << endl;
328    cout << "Drift Speed: " << fDriftSpeed << endl;
329    cout << "Electronics (1=PASCAL, 2=OLA): " << fElectronics << endl;
330
331    cout << "N. of Sigma for signal integration: " << fNsigmas << endl;
332    cout << "N. of bins in lookup table: " << fNcomps << endl;
333
334    cout << "Max. ADC Value: " << fMaxAdc << endl;
335    cout << "Min. Value: " << fMinVal << endl;
336
337    PrintGains();
338
339 }
340
341
342