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