Updated version of SSD Detector Algorithms (S. Borysov)
[u/mrichter/AliRoot.git] / ITS / AliITSModuleDaSSD.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, 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 ///////////////////////////////////////////////////////////////////////////////
19 ///
20 /// This class provides storage container ITS SSD module callibration data
21 /// used by DA. 
22 ///
23 ///////////////////////////////////////////////////////////////////////////////
24
25 #include "AliITSNoiseSSD.h"
26 #include "AliITSModuleDaSSD.h"
27 #include "TString.h"
28 #include "AliLog.h"
29
30 ClassImp(AliITSModuleDaSSD)
31
32
33 const Int_t   AliITSModuleDaSSD::fgkStripsPerModule   = 1536;   // Number of strips per SSD module
34 const Int_t   AliITSModuleDaSSD::fgkPNStripsPerModule = 768;    // Number of N/P strips per SSD module
35 const Int_t   AliITSModuleDaSSD::fgkStripsPerChip     = 128;    // Number of strips per chip HAL25
36 const UChar_t AliITSModuleDaSSD::fgkMaxAdNumber       = 9;      // MAx SSD FEROM AD number
37 const UChar_t AliITSModuleDaSSD::fgkMaxAdcNumber      = 13;     // MAx SSD FEROM ADC number
38 const Int_t   AliITSModuleDaSSD::fgkChipsPerModule    = 12;     // Number of HAL25 chips per SSD module
39
40
41
42 using namespace std;
43
44 //______________________________________________________________________________
45 AliITSModuleDaSSD::AliITSModuleDaSSD() :
46   fEquipId(0),
47   fEquipType(0),
48   fDdlId(0),
49   fAd(0),
50   fAdc(0),
51   fModuleId(0),
52   fNumberOfStrips(0),
53   fStrips(NULL),
54   fNumberOfChips(0),
55   fCm(NULL),
56   fEventsNumber(0)
57 {
58 // Default constructor
59 }
60
61
62 //______________________________________________________________________________
63 AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
64   fEquipId(0),
65   fEquipType(0),
66   fDdlId(ddlID),
67   fAd(ad),
68   fAdc(adc),
69   fModuleId(moduleID),
70   fNumberOfStrips(0),
71   fStrips(NULL),
72   fNumberOfChips(0),
73   fCm(NULL),
74   fEventsNumber(0)
75 {
76 // Constructor, set module id data
77 }
78
79
80
81 //______________________________________________________________________________
82 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
83   fEquipId(0),
84   fEquipType(0),
85   fDdlId(0),
86   fAd(0),
87   fAdc(0),
88   fModuleId(0),
89   fNumberOfStrips(0),
90   fStrips(NULL),
91   fNumberOfChips(0),
92   fCm(NULL),
93   fEventsNumber(0)
94 {
95 // Constructor, allocates memory for AliITSChannelDaSSD*
96   if (numberofstrips != fgkStripsPerModule) 
97     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
98   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
99   if (fStrips) {
100      fNumberOfStrips = numberofstrips;
101      for (Int_t i = 0; i < numberofstrips; i++) fStrips[i]= NULL;
102   } else {
103      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
104      fNumberOfStrips = 0;
105      fStrips = NULL;
106   }  
107 }
108
109
110 //______________________________________________________________________________
111 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
112   fEquipId(0),
113   fEquipType(0),
114   fDdlId(0),
115   fAd(0),
116   fAdc(0),
117   fModuleId(0),
118   fNumberOfStrips(0),
119   fStrips(NULL),
120   fNumberOfChips(0),
121   fCm(NULL),
122   fEventsNumber(0)
123 {
124 // Constructor, allocates memory for AliITSChannelDaSSD* and events data
125   if (numberofstrips != fgkStripsPerModule) 
126     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
127   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
128   if (fStrips) {
129      fNumberOfStrips = numberofstrips;
130      memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
131      for (Int_t i = 0; i < fNumberOfStrips; i++) {
132        fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
133        if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
134      }
135   } else {
136      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
137      fNumberOfStrips = 0;
138      fStrips = NULL;
139   }  
140 }
141
142
143
144 //______________________________________________________________________________
145 AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
146   TObject(module),
147   fEquipId(module.fEquipId),
148   fEquipType(module.fEquipType),
149   fDdlId(module.fDdlId),
150   fAd(module.fAd),
151   fAdc(module.fAdc),
152   fModuleId(module.fModuleId),
153   fNumberOfStrips(module.fNumberOfStrips),
154   fStrips(NULL),
155   fNumberOfChips(module.fNumberOfChips),
156   fCm(NULL),
157   fEventsNumber(module.fEventsNumber)
158 {
159 // copy constructor
160   if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
161     fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
162     if (fStrips) {
163       for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
164         if (module.fStrips[strind]) {
165           fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
166           if (!fStrips[strind]) { 
167             AliError("AliITSModuleDaSSD: Error copy constructor");
168             for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
169             delete [] fStrips;
170             fStrips = NULL;
171             break;
172           }
173         } else fStrips[strind] = NULL; 
174       }   
175     } else {
176        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
177        fNumberOfStrips = 0;
178        fStrips = NULL;
179     }  
180   }
181   if (module.fCm) {
182     fCm = new (nothrow) TArrayF [module.fNumberOfChips];
183     if (fCm) {
184       for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind]; 
185     } else {
186        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
187        fNumberOfChips = 0;
188        fCm = NULL;
189     }  
190   }  
191 }
192
193
194
195 //______________________________________________________________________________
196 AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
197 {
198 // assignment operator
199   if (this == &module)  return *this;  
200   if (fStrips) {
201     for (Long_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
202     delete [] fStrips;
203   } 
204   fEquipId = module.fEquipId;
205   fEquipType = module.fEquipType;
206   fDdlId = module.fDdlId;
207   fAd = module.fAd;
208   fAdc = module.fAdc;
209   fModuleId = module.fModuleId;
210   fNumberOfStrips = module.fNumberOfStrips;
211   fStrips = NULL;
212   fNumberOfChips = module.fNumberOfChips;
213   fCm = NULL;
214   fEventsNumber = module.fEventsNumber;
215   if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
216     fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
217     if (fStrips) {
218       for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
219         if (module.fStrips[strind]) {
220           fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
221           if (!fStrips[strind]) { 
222             AliError("AliITSModuleDaSSD: Error copy constructor");
223             for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
224             delete [] fStrips;
225             fStrips = NULL;
226             break;
227           }
228         } else fStrips[strind] = NULL; 
229       }   
230     } else {
231        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
232        fNumberOfStrips = 0;
233        fStrips = NULL;
234     }  
235   }
236   if (fCm) delete [] fCm;
237   if (module.fCm) {
238     fCm = new (nothrow) TArrayF [module.fNumberOfChips];
239     if (fCm) {
240       for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind]; 
241     } else {
242        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
243        fNumberOfChips = 0;
244        fCm = NULL;
245     }  
246   }  
247   return *this;
248 }
249     
250
251     
252 //______________________________________________________________________________
253 AliITSModuleDaSSD::~AliITSModuleDaSSD()
254 {
255 // Destructor
256   if (fStrips)
257   {
258     for (Long_t i = 0; i < fNumberOfStrips; i++)
259     { 
260       if (fStrips[i]) delete fStrips[i];
261     }
262     delete [] fStrips;
263   } 
264   if (fCm) delete [] fCm;
265 }
266
267
268
269 //______________________________________________________________________________
270 Bool_t AliITSModuleDaSSD::SetNumberOfStrips(const Int_t numberofstrips)
271 {
272 // Allocates memory for AliITSChannelDaSSD*
273   if (fStrips) {
274     for (Int_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
275     delete [] fStrips;
276     fStrips = NULL;
277   }  
278   if (numberofstrips <= 0) {fNumberOfStrips = 0; return kTRUE; } 
279   if (numberofstrips != fgkStripsPerModule) 
280     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
281   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
282   if (fStrips) {
283      fNumberOfStrips = numberofstrips;
284      memset(fStrips, 0, sizeof(AliITSChannelDaSSD*) * numberofstrips);
285      return kTRUE;
286   } else {
287      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
288      fNumberOfStrips = 0;
289      fStrips = NULL;
290      return kFALSE;
291   }  
292 }
293
294
295 //______________________________________________________________________________
296 Bool_t AliITSModuleDaSSD::SetNumberOfChips(const Int_t nchips)
297 {
298 // Allocate nchips TArrayF objects to save Common Mode
299   DeleteCM();
300   if (nchips <= 0) {fNumberOfChips = 0; return kTRUE; } 
301   if (nchips != fgkChipsPerModule) 
302     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i HAL25 chips", fgkChipsPerModule));
303   fCm = new (nothrow) TArrayF [nchips];
304   if (fCm) {
305      fNumberOfChips = nchips;
306      return kTRUE;
307   } else {
308      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", nchips));
309      fNumberOfChips = 0;
310      fCm = NULL;
311      return kFALSE;
312   }  
313 }
314
315   
316 //______________________________________________________________________________
317 Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_t moduleID)
318 {
319 // SetModuleIdData
320   if (ad > fgkMaxAdNumber) {
321     AliWarning(Form("AliITSModuleDaSSD: Wrong AD number: %i", ad));
322     return kFALSE;
323   }  
324   if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
325     AliWarning(Form("AliITSModuleDaSSD: Wrong ADC number: %i", adc));
326     return kFALSE;
327   }  
328   fDdlId = ddlID;
329   fAd = ad;
330   fAdc = adc;
331   fModuleId = moduleID;
332   return kTRUE;
333 }
334
335
336 //______________________________________________________________________________
337 void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
338 {
339 // Set id data of FEE connected to the Module
340   fDdlId = ddlID;
341   fAd = ad;
342   fAdc = adc;
343 }
344
345
346 //______________________________________________________________________________
347 void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
348 {
349 // Set data to access FEROM registres via DDL
350   fEquipId = equipid; 
351   fEquipType = equiptype;
352 }
353
354
355 //______________________________________________________________________________
356 Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
357 {
358 // Allocate the memory for the events data
359   Int_t i;
360   if (!fStrips) return kFALSE;
361   for (i = 0; i < fNumberOfStrips; i++) {
362     if (fStrips[i])  
363       if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
364         for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
365         AliError(Form("AliITSModuleDaSSD: Error allocating memory for i% events for module %i, strip %i", 
366                                     eventsnumber, (Int_t)fModuleId, i));
367         return kFALSE;
368       }
369     else 
370       if (!(fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber))) {
371         for (Int_t j = 0; j < i; j++) delete fStrips[j];
372         delete [] fStrips;
373         fNumberOfStrips = 0;
374         fStrips = NULL;
375         AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
376         return kFALSE;
377       }
378   } 
379   return kTRUE;
380 }
381
382
383
384 //______________________________________________________________________________
385 Bool_t AliITSModuleDaSSD::SetCM (const Float_t cm, const Int_t chipn, const Int_t evn)
386
387 // Set value of CM for a given chip and event 
388   if ((!fCm) || (chipn >= fNumberOfChips)) return kFALSE;
389   if (evn >= fCm[chipn].GetSize()) return kFALSE;
390   else fCm[chipn][evn] = cm;
391   return kTRUE;
392 }
393
394
395
396 //______________________________________________________________________________
397 Float_t  AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn)   const 
398
399 // Get value of CM for a given chip and event 
400   if ((!fCm) || (chipn >= fNumberOfChips)) return 0.0f;
401   if (evn >= fCm[chipn].GetSize()) return 0.0f;
402   else return fCm[chipn][evn];
403 }
404
405
406
407 //______________________________________________________________________________
408 AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationSSDModule() const
409 {
410 // Creates the AliITSNoiseSSD objects with callibration data
411   AliITSNoiseSSD  *mc;
412   Float_t          noise;
413   if (!fStrips) return NULL;
414   mc = new AliITSNoiseSSD();
415   mc->SetMod(fModuleId);
416   mc->SetNNoiseP(fgkPNStripsPerModule);
417   mc->SetNNoiseN(fgkPNStripsPerModule);
418   for (Int_t i = 0; i < fNumberOfStrips; i++) {
419     if (!fStrips[i]) noise = AliITSChannelDaSSD::GetUndefinedValue();
420     else  noise = fStrips[i]->GetNoiseCM();
421     if (i < fgkPNStripsPerModule)
422           mc->AddNoiseP(i, noise);
423     else  mc->AddNoiseN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), noise);                     
424   }
425   return mc;
426 }