Fixes for SSD detector algorithms and preprocessor (Panos)
[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: 18/07/2008
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   fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
114   if (!fCmFerom) {
115      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
116      fCmFerom = NULL;
117   }  
118 }
119
120
121 //______________________________________________________________________________
122 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
123   fEquipId(0),
124   fEquipType(0),
125   fDdlId(0),
126   fAd(0),
127   fAdc(0),
128   fModuleId(0),
129   fNumberOfStrips(0),
130   fStrips(NULL),
131   fNumberOfChips(0),
132   fCm(NULL),
133   fCmFerom(NULL),
134   fEventsNumber(0)
135 {
136 // Constructor, allocates memory for AliITSChannelDaSSD* and events data
137   if (numberofstrips != fgkStripsPerModule) 
138     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
139   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
140   if (fStrips) {
141      fNumberOfStrips = numberofstrips;
142      memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
143      for (Int_t i = 0; i < fNumberOfStrips; i++) {
144        fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
145        if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
146      }
147   } else {
148      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
149      fNumberOfStrips = 0;
150      fStrips = NULL;
151   }  
152   fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
153   if (fCmFerom) {
154     for (Int_t i = 0; i < fgkChipsPerModule; i++) {
155       fCmFerom[i].Set(eventsnumber);
156       fCmFerom[i].Reset(0);
157     }  
158   }
159   else {
160      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
161      fCmFerom = NULL;
162   }  
163 }
164
165
166
167 //______________________________________________________________________________
168 AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
169   TObject(module),
170   fEquipId(module.fEquipId),
171   fEquipType(module.fEquipType),
172   fDdlId(module.fDdlId),
173   fAd(module.fAd),
174   fAdc(module.fAdc),
175   fModuleId(module.fModuleId),
176   fNumberOfStrips(module.fNumberOfStrips),
177   fStrips(NULL),
178   fNumberOfChips(module.fNumberOfChips),
179   fCm(NULL),
180   fCmFerom(NULL),
181   fEventsNumber(module.fEventsNumber)
182 {
183 // copy constructor
184   if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
185     fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
186     if (fStrips) {
187       for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
188         if (module.fStrips[strind]) {
189           fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
190           if (!fStrips[strind]) { 
191             AliError("AliITSModuleDaSSD: Error copy constructor");
192             for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
193             delete [] fStrips;
194             fStrips = NULL;
195             break;
196           }
197         } else fStrips[strind] = NULL; 
198       }   
199     } else {
200        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
201        fNumberOfStrips = 0;
202        fStrips = NULL;
203     }  
204   }
205   if (module.fCm) {
206     fCm = new (nothrow) TArrayF [module.fNumberOfChips];
207     if (fCm) {
208       for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind]; 
209     } else {
210        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
211        fNumberOfChips = 0;
212        fCm = NULL;
213     }  
214   }
215   
216   if (module.fCmFerom) {
217     fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
218     if (fCmFerom) {
219       for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind]; 
220     } else {
221        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
222        fCmFerom = NULL;
223     }  
224   }
225 }
226
227
228
229 //______________________________________________________________________________
230 AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
231 {
232 // assignment operator
233   if (this == &module)  return *this;  
234   TObject::operator=(module);
235   if (fStrips) {
236     for (Long_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
237     delete [] fStrips;
238     fStrips = NULL;
239   } 
240   fEquipId = module.fEquipId;
241   fEquipType = module.fEquipType;
242   fDdlId = module.fDdlId;
243   fAd = module.fAd;
244   fAdc = module.fAdc;
245   fModuleId = module.fModuleId;
246   fStrips = NULL;
247   fNumberOfChips = module.fNumberOfChips;
248   fCm = NULL;
249   fEventsNumber = module.fEventsNumber;
250   if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
251     fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
252     if (fStrips) {
253       memset(fStrips, 0, (sizeof(AliITSChannelDaSSD*) * module.fNumberOfStrips));
254       for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
255         if (module.fStrips[strind]) {
256           fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
257           if (!fStrips[strind]) { 
258             AliError("AliITSModuleDaSSD: Error copy constructor");
259             for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
260             delete [] fStrips;
261             fStrips = NULL;
262             fNumberOfStrips = 0;
263             break;
264           }
265         } else fStrips[strind] = NULL; 
266       }
267       fNumberOfStrips = module.fNumberOfStrips;
268     } else {
269        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
270        fNumberOfStrips = 0;
271        fStrips = NULL;
272     }  
273   }
274   if (fCm) delete [] fCm;
275   if (module.fCm) {
276     fCm = new (nothrow) TArrayF [module.fNumberOfChips];
277     if (fCm) {
278       for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind]; 
279     } else {
280        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
281        fNumberOfChips = 0;
282        fCm = NULL;
283     }  
284   }  
285   if (fCmFerom) delete [] fCmFerom;
286   if (module.fCmFerom) {
287     fCmFerom = new (nothrow) TArrayS [module.fNumberOfChips];
288     if (fCmFerom) {
289       for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind]; 
290     } else {
291        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
292        fCmFerom = NULL;
293     }  
294   }  
295   return *this;
296 }
297     
298
299     
300 //______________________________________________________________________________
301 AliITSModuleDaSSD::~AliITSModuleDaSSD()
302 {
303 // Destructor
304   if (fStrips)
305   {
306     for (Long_t i = 0; i < fNumberOfStrips; i++)
307     { 
308       if (fStrips[i]) delete fStrips[i];
309     }
310     delete [] fStrips;
311   } 
312   if (fCm) delete [] fCm;
313   if (fCmFerom) delete [] fCmFerom;
314 }
315
316
317
318 //______________________________________________________________________________
319 Bool_t AliITSModuleDaSSD::SetNumberOfStrips(const Int_t numberofstrips)
320 {
321 // Allocates memory for AliITSChannelDaSSD*
322   if (fStrips) {
323     for (Int_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
324     delete [] fStrips;
325     fStrips = NULL;
326   }  
327   if (numberofstrips <= 0) {fNumberOfStrips = 0; return kTRUE; } 
328   if (numberofstrips != fgkStripsPerModule) 
329     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
330   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
331   if (fStrips) {
332      fNumberOfStrips = numberofstrips;
333      memset(fStrips, 0, sizeof(AliITSChannelDaSSD*) * numberofstrips);
334      return kTRUE;
335   } else {
336      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
337      fNumberOfStrips = 0;
338      fStrips = NULL;
339      return kFALSE;
340   }  
341 }
342
343
344 //______________________________________________________________________________
345 Bool_t AliITSModuleDaSSD::SetNumberOfChips(const Int_t nchips)
346 {
347 // Allocate nchips TArrayF objects to save Common Mode
348   DeleteCM();
349   if (nchips <= 0) {fNumberOfChips = 0; return kTRUE; } 
350   if (nchips != fgkChipsPerModule) 
351     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i HAL25 chips", fgkChipsPerModule));
352   fCm = new (nothrow) TArrayF [nchips];
353   if (fCm) {
354      fNumberOfChips = nchips;
355      return kTRUE;
356   } else {
357      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", nchips));
358      fNumberOfChips = 0;
359      fCm = NULL;
360      return kFALSE;
361   }  
362 }
363
364   
365 //______________________________________________________________________________
366 Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_t moduleID)
367 {
368 // SetModuleIdData
369   if (ad > fgkMaxAdNumber) {
370     AliWarning(Form("AliITSModuleDaSSD: Wrong AD number: %i", ad));
371     return kFALSE;
372   }  
373   if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
374     AliWarning(Form("AliITSModuleDaSSD: Wrong ADC number: %i", adc));
375     return kFALSE;
376   }  
377   fDdlId = ddlID;
378   fAd = ad;
379   fAdc = adc;
380   fModuleId = moduleID;
381   return kTRUE;
382 }
383
384
385 //______________________________________________________________________________
386 void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
387 {
388 // Set id data of FEE connected to the Module
389   fDdlId = ddlID;
390   fAd = ad;
391   fAdc = adc;
392 }
393
394
395 //______________________________________________________________________________
396 void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
397 {
398 // Set data to access FEROM registres via DDL
399   fEquipId = equipid; 
400   fEquipType = equiptype;
401 }
402
403
404 //______________________________________________________________________________
405 Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
406 {
407 // Allocate the memory for the events data
408   Int_t i;
409   if (!fStrips) return kFALSE;
410   for (i = 0; i < fNumberOfStrips; i++) {
411     if (fStrips[i])  
412       if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
413         for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
414         AliError(Form("AliITSModuleDaSSD: Error allocating memory for i% events for module %i, strip %i", 
415                                     eventsnumber, (Int_t)fModuleId, i));
416         return kFALSE;
417       }
418     else 
419       if (!(fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber))) {
420         for (Int_t j = 0; j < i; j++) delete fStrips[j];
421         delete [] fStrips;
422         fNumberOfStrips = 0;
423         fStrips = NULL;
424         AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
425         return kFALSE;
426       }
427   } 
428   if (fCmFerom) {
429     for (Int_t ie = 0; ie < fgkChipsPerModule; ie++) {
430       fCmFerom[ie].Set(eventsnumber);
431       fCmFerom[ie].Reset(0);
432     }  
433   }
434   else  AliError("AliITSModuleDaSSD: No memory was allocated for fCmFerom!");
435   fEventsNumber = eventsnumber;
436   return kTRUE;
437 }
438
439
440
441 //______________________________________________________________________________
442 Bool_t AliITSModuleDaSSD::SetCM (const Float_t cm, const Int_t chipn, const Int_t evn)
443
444 // Set value of CM for a given chip and event 
445   if ((!fCm) || (chipn >= fNumberOfChips)) return kFALSE;
446   if (evn >= fCm[chipn].GetSize()) return kFALSE;
447   else fCm[chipn][evn] = cm;
448   return kTRUE;
449 }
450
451
452
453 //______________________________________________________________________________
454 Float_t  AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn)   const 
455
456 // Get value of CM for a given chip and event 
457   if ((!fCm) || (chipn >= fNumberOfChips)) return 0.0f;
458   if (evn >= fCm[chipn].GetSize()) return 0.0f;
459   else return fCm[chipn][evn];
460 }
461
462
463
464 //______________________________________________________________________________
465 Bool_t  AliITSModuleDaSSD::SetCMFeromEventsNumber(const Long_t eventsnumber)
466 {
467 // Allocates memory for the values of CM calculated in Ferom
468   if (!fCmFerom) return kFALSE;
469   for (Int_t chipind = 0; chipind < fgkChipsPerModule; chipind++) {
470       fCmFerom[chipind].Set(eventsnumber);
471       fCmFerom[chipind].Reset(0);
472   }
473   return kTRUE;
474 }
475
476 //______________________________________________________________________________
477 Bool_t AliITSModuleDaSSD::SetCMFerom (const Short_t cm, const Int_t chipn, const Int_t evn)
478
479 // Set value of FeromCM for a given chip and event 
480   if ((!fCmFerom) || (chipn >= fgkChipsPerModule)) return kFALSE;
481   if (evn >= fCmFerom[chipn].GetSize()) return kFALSE;
482   else fCmFerom[chipn][evn] = cm;
483   return kTRUE;
484 }
485
486
487
488 //______________________________________________________________________________
489 Short_t  AliITSModuleDaSSD::GetCMFerom(const Int_t chipn, const Long_t evn)   const 
490
491 // Get value of FeromCM for a given chip and event 
492   if ((!fCmFerom) || (chipn >= fgkChipsPerModule)) return 0;
493   if (evn >= fCmFerom[chipn].GetSize()) return 0;
494   else return fCmFerom[chipn][evn];
495 }
496
497
498
499 UChar_t AliITSModuleDaSSD::CheckIfBad(const Int_t stripn) const
500 {
501 //Applies the bad channel creteria and set the appropriate flags for returned valie 
502   UInt_t          bcflags = 0;
503   const UInt_t    WOffsetMask = 0x000003FF;
504   if (!fStrips[stripn]) bcflags |= 3;
505   else {
506     if (fStrips[stripn]->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue()) bcflags |= 8;
507     if (fStrips[stripn]->GetNoiseCM() > 20) bcflags |= 8;
508     if (fStrips[stripn]->GetNoiseCM() < 1) bcflags |= 16;
509     if (fStrips[stripn]->GetPedestal() > ((WOffsetMask >> 1) - 1))  bcflags |= 4;
510     else if ((-(fStrips[stripn]->GetPedestal())) > (WOffsetMask >> 1))  bcflags |= 4;
511     if (bcflags) bcflags |= 3;
512   }
513   return bcflags;
514 }