]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSModuleDaSSD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix for the case of non-existent calibration files
[u/mrichter/AliRoot.git] / ITS / AliITSModuleDaSSD.cxx
... / ...
CommitLineData
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
33ClassImp(AliITSModuleDaSSD)
34
35
36const Int_t AliITSModuleDaSSD::fgkStripsPerModule = 1536; // Number of strips per SSD module
37const Int_t AliITSModuleDaSSD::fgkPNStripsPerModule = 768; // Number of N/P strips per SSD module
38const Int_t AliITSModuleDaSSD::fgkStripsPerChip = 128; // Number of strips per chip HAL25
39const UChar_t AliITSModuleDaSSD::fgkMaxAdNumber = 9; // MAx SSD FEROM AD number
40const UChar_t AliITSModuleDaSSD::fgkMaxAdcNumber = 13; // MAx SSD FEROM ADC number
41const Int_t AliITSModuleDaSSD::fgkChipsPerModule = 12; // Number of HAL25 chips per SSD module
42
43
44
45using namespace std;
46
47//______________________________________________________________________________
48AliITSModuleDaSSD::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//______________________________________________________________________________
67AliITSModuleDaSSD::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//______________________________________________________________________________
87AliITSModuleDaSSD::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//______________________________________________________________________________
117AliITSModuleDaSSD::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//______________________________________________________________________________
152AliITSModuleDaSSD::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//______________________________________________________________________________
214AliITSModuleDaSSD& 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//______________________________________________________________________________
285AliITSModuleDaSSD::~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//______________________________________________________________________________
303Bool_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//______________________________________________________________________________
329Bool_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//______________________________________________________________________________
350Bool_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//______________________________________________________________________________
370void 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//______________________________________________________________________________
380void 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//______________________________________________________________________________
389Bool_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//______________________________________________________________________________
420Bool_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//______________________________________________________________________________
432Float_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//______________________________________________________________________________
442Bool_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//______________________________________________________________________________
458Bool_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//______________________________________________________________________________
470Bool_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
480void 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//______________________________________________________________________________
490Short_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