]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSHandleDaSSD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Last warnings... fed up to wait
[u/mrichter/AliRoot.git] / ITS / AliITSHandleDaSSD.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 ITS SSD data handling
21/// used by DA.
22// Author: Oleksandr Borysov
23// Date: 18/07/2008
24///////////////////////////////////////////////////////////////////////////////
25
26#include <string>
27#include <fstream>
28#include <new>
29#include <Riostream.h>
30#include "AliITSHandleDaSSD.h"
31#include <math.h>
32#include <limits.h>
33#include "event.h"
34#include "TFile.h"
35#include "TString.h"
36#include "AliLog.h"
37#include "AliITSNoiseSSDv2.h"
38#include "AliITSPedestalSSDv2.h"
39#include "AliITSBadChannelsSSDv2.h"
40#include "AliITSRawStreamSSD.h"
41#include "AliRawReaderDate.h"
42#include "AliITSRawStreamSSD.h"
43#include "AliITSChannelDaSSD.h"
44
45
46ClassImp(AliITSHandleDaSSD)
47
48using namespace std;
49
50
51const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698; // Number of SSD modules in ITS
52const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108; // Number of SSD modules in DDL
53const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerSlot = 12; // Number of SSD modules in Slot
54const Short_t AliITSHandleDaSSD::fgkMinSSDModuleId = 500; // Initial SSD modules number
55const Int_t AliITSHandleDaSSD::fgkNumberOfSSDSlotsPerDDL = 9; // Number of SSD slots per DDL
56const Int_t AliITSHandleDaSSD::fgkNumberOfSSDDDLs = 16; // Number of SSD modules in Slot
57const Float_t AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0; // Defalt value for fPedestalThresholdFactor
58const Float_t AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0; // Defalt value for fCmThresholdFactor
59
60const UInt_t AliITSHandleDaSSD::fgkZsBitMask = 0x0000003F; // Bit mask for FEROM ZS
61const UInt_t AliITSHandleDaSSD::fgkOffSetBitMask = 0x000003FF; // Bit mask for FEROM Offset correction
62const UInt_t AliITSHandleDaSSD::fgkBadChannelMask = 0x00000001; // Mask to suppress the channel from the bad channel list
63const Int_t AliITSHandleDaSSD::fgkAdcPerDBlock = 6; // FEROM configuration file constant
64
65//______________________________________________________________________________
66AliITSHandleDaSSD::AliITSHandleDaSSD() :
67 fRawDataFileName(NULL),
68 fNumberOfModules(0),
69 fModules(NULL),
70 fModIndProcessed(0),
71 fModIndRead(0),
72 fModIndex(NULL),
73 fEqIndex(0),
74 fNumberOfEvents(0),
75 fBadChannelsList(NULL),
76 fDDLModuleMap(NULL),
77 fALaddersOff(0),
78 fCLaddersOff(0),
79 fLdcId(0),
80 fRunId(0),
81 fPedestalThresholdFactor(fgkPedestalThresholdFactor),
82 fCmThresholdFactor(fgkCmThresholdFactor),
83 fZsDefault(-1),
84 fOffsetDefault(INT_MAX),
85 fZsMinimum(2),
86 fMergeBCLists(1),
87 fZsFactor(3.0)
88{
89// Default constructor
90}
91
92
93//______________________________________________________________________________
94AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
95 fRawDataFileName(NULL),
96 fNumberOfModules(0),
97 fModules(NULL),
98 fModIndProcessed(0),
99 fModIndRead(0),
100 fModIndex(NULL),
101 fEqIndex(0),
102 fNumberOfEvents(0),
103 fBadChannelsList(NULL),
104 fDDLModuleMap(NULL),
105 fALaddersOff(0),
106 fCLaddersOff(0),
107 fLdcId(0),
108 fRunId(0),
109 fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
110 fCmThresholdFactor(fgkCmThresholdFactor),
111 fZsDefault(-1),
112 fOffsetDefault(INT_MAX),
113 fZsMinimum(2),
114 fMergeBCLists(1),
115 fZsFactor(3.0)
116{
117 if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
118}
119
120
121//______________________________________________________________________________
122AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
123 TObject(ssdadldc),
124 fRawDataFileName(ssdadldc.fRawDataFileName),
125 fNumberOfModules(ssdadldc.fNumberOfModules),
126 fModules(NULL),
127 fModIndProcessed(ssdadldc.fModIndProcessed),
128 fModIndRead(ssdadldc.fModIndRead),
129 fModIndex(NULL),
130 fEqIndex(0),
131 fNumberOfEvents(ssdadldc.fNumberOfEvents),
132 fBadChannelsList(NULL),
133 fDDLModuleMap(NULL),
134 fALaddersOff(ssdadldc.fALaddersOff),
135 fCLaddersOff(ssdadldc.fCLaddersOff),
136 fLdcId(ssdadldc.fLdcId),
137 fRunId(ssdadldc.fRunId),
138 fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor),
139 fCmThresholdFactor(ssdadldc.fCmThresholdFactor),
140 fZsDefault(ssdadldc.fZsDefault),
141 fOffsetDefault(ssdadldc.fOffsetDefault),
142 fZsMinimum(ssdadldc.fZsMinimum),
143 fMergeBCLists(ssdadldc.fMergeBCLists),
144 fZsFactor(ssdadldc.fZsFactor)
145{
146 // copy constructor
147 if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
148 fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
149 if (fModules) {
150 for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
151 if (ssdadldc.fModules[modind]) {
152 fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
153 if (!fModules[modind]) {
154 AliError("AliITSHandleDaSSD: Error copy constructor");
155 for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
156 delete [] fModules;
157 fModules = NULL;
158 break;
159 }
160 } else fModules[modind] = NULL;
161 }
162 } else {
163 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
164 fNumberOfModules = 0;
165 fModules = NULL;
166 }
167 }
168 if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by copy constructor, use other methods to init it!");
169 if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by copy constructor, use other methods to init it!");
170}
171
172
173//______________________________________________________________________________
174AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
175{
176// assignment operator
177 if (this == &ssdadldc) return *this;
178 TObject::operator=(ssdadldc);
179 if (fModules) {
180 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
181 delete [] fModules;
182 fModules = NULL;
183 }
184 if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
185 if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
186 fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
187 if (fModules) {
188 for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
189 if (ssdadldc.fModules[modind]) {
190 fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
191 if (!fModules[modind]) {
192 AliError("AliITSHandleDaSSD: Error assignment operator");
193 for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
194 delete [] fModules;
195 fModules = NULL;
196 break;
197 }
198 } else fModules[modind] = NULL;
199 }
200 } else {
201 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
202 fNumberOfModules = 0;
203 fModules = NULL;
204 }
205 }
206 fRawDataFileName = NULL;
207 fModIndProcessed = 0;
208 fModIndRead = 0;
209 fModIndex = NULL;
210 fEqIndex = ssdadldc.fEqIndex;
211 fNumberOfEvents = ssdadldc.fNumberOfEvents;
212 fLdcId = ssdadldc.fLdcId;
213 fRunId = ssdadldc.fRunId;
214 fPedestalThresholdFactor = ssdadldc.fPedestalThresholdFactor;
215 fCmThresholdFactor = ssdadldc.fCmThresholdFactor;
216 fZsDefault = ssdadldc.fZsDefault;
217 fOffsetDefault = ssdadldc.fOffsetDefault;
218 fZsMinimum = ssdadldc.fZsMinimum;
219 fMergeBCLists = ssdadldc.fMergeBCLists;
220 fZsFactor = ssdadldc.fZsFactor;
221 fALaddersOff = ssdadldc.fALaddersOff;
222 fCLaddersOff = ssdadldc.fCLaddersOff;
223 fBadChannelsList = NULL;
224 fDDLModuleMap = NULL;
225 fModIndex = NULL;
226 if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by assignment operator, use other methods to init it!");
227 if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by assignment operator, use other methods to init it!");
228 return *this;
229}
230
231
232//______________________________________________________________________________
233AliITSHandleDaSSD::~AliITSHandleDaSSD()
234{
235// Default destructor
236 if (fModules)
237 {
238 for (Int_t i = 0; i < fNumberOfModules; i++)
239 {
240 if (fModules[i]) delete fModules[i];
241 }
242 delete [] fModules;
243 }
244 if (fModIndex) delete [] fModIndex;
245 if (fBadChannelsList) delete fBadChannelsList;
246 if (fDDLModuleMap) delete [] fDDLModuleMap;
247}
248
249
250
251//______________________________________________________________________________
252void AliITSHandleDaSSD::Reset()
253{
254// Delete array of AliITSModuleDaSSD* objects.
255 if (fModules) {
256 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
257 delete [] fModules;
258 fModules = NULL;
259 }
260 if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
261/*
262 if (fBadChannelsList) {
263 delete fBadChannelsList;
264 fBadChannelsList = NULL;
265 }
266 if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL; }
267*/
268 fALaddersOff.Set(0);
269 fCLaddersOff.Set(0);
270 fRawDataFileName = NULL;
271 fModIndProcessed = fModIndRead = 0;
272 fNumberOfEvents = 0;
273 fLdcId = fRunId = 0;
274 fPedestalThresholdFactor = fgkPedestalThresholdFactor;
275 fCmThresholdFactor = fgkCmThresholdFactor;
276}
277
278
279
280//______________________________________________________________________________
281Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname)
282{
283// Read raw data file and set initial and configuration parameters
284 Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0;
285 Int_t nofeqipmentev, nofeqipment = 0, eqn = 0;
286 AliRawReaderDate *rawreaderdate = NULL;
287 UChar_t *data = NULL;
288 Long_t datasize = 0, eqbelsize = 1;
289
290 rawreaderdate = new AliRawReaderDate(rdfname, 0);
291 if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) {
292 AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname));
293 MakeZombie();
294 return kFALSE;
295 }
296 if (rawreaderdate->NextEvent()) {
297 fRunId = rawreaderdate->GetRunNumber();
298 rawreaderdate->RewindEvents();
299 } else { MakeZombie(); return kFALSE; }
300 if (fModules) Reset();
301 //rawreaderdate->SelectEvents(-1);
302 rawreaderdate->Select("ITSSSD");
303 nofstrips = 0;
304 while (rawreaderdate->NextEvent()) {
305 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
306 nofstripsev = 0;
307 nofeqipmentev = 0;
308 while (rawreaderdate->ReadNextData(data)) {
309 fLdcId = rawreaderdate->GetLDCId();
310 nofeqipmentev += 1;
311 datasize = rawreaderdate->GetDataSize();
312 eqbelsize = rawreaderdate->GetEquipmentElementSize();
313 if ( datasize % eqbelsize ) {
314 AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i",
315 rdfname, datasize, eqbelsize));
316 MakeZombie();
317 return kFALSE;
318 }
319 nofstripsev += (Int_t) (datasize / eqbelsize);
320 }
321 if (physeventind++) {
322 if (nofstrips != nofstripsev) AliWarning(Form("AliITSHandleDaSSD: number of strips varies from event to event, ev = %i, %i",
323 physeventind, nofstripsev));
324 if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to event");
325 }
326 nofstrips = nofstripsev;
327 nofeqipment = nofeqipmentev;
328 if (strn < nofstrips) strn = nofstrips;
329 if (eqn < nofeqipment) eqn = nofeqipment;
330 }
331 delete rawreaderdate;
332 if ((physeventind > 0) && (strn > 0))
333 {
334 fNumberOfEvents = physeventind;
335 fRawDataFileName = rdfname;
336 fEqIndex.Set(eqn);
337 fEqIndex.Reset(-1);
338 fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn];
339 if (fModIndex)
340 for (Int_t i = 0; i < fgkNumberOfSSDModulesPerDdl * eqn; i++) fModIndex[i] = -1;
341 else AliWarning(Form("AliITSHandleDaSSD: Error Init(%s): Index array for %i modules was not created",
342 rdfname, fgkNumberOfSSDModulesPerDdl * eqn));
343 if (SetNumberOfModules(fgkNumberOfSSDModulesPerDdl * eqn)) {
344 TString str = TString::Format("Max number of equipment: %i, max number of channels: %i\n", eqn, strn);
345 DumpInitData(str.Data());
346 return kTRUE;
347 }
348 }
349 MakeZombie();
350 return kFALSE;
351}
352
353
354
355//______________________________________________________________________________
356AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
357{
358// Retrieve AliITSModuleDaSSD object from the array
359 if (!fModules) return NULL;
360 for (Int_t i = 0; i < fNumberOfModules; i++) {
361 if (fModules[i]) {
362 if ( (fModules[i]->GetDdlId() == ddlID)
363 && (fModules[i]->GetAD() == ad)
364 && (fModules[i]->GetADC() == adc))
365 return fModules[i];
366 }
367 }
368 return NULL;
369}
370
371
372Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
373{
374// Retrieve the position of AliITSModuleDaSSD object in the array
375 if (!fModules) return -1;
376 for (Int_t i = 0; i < fNumberOfModules; i++) {
377 if (fModules[i]) {
378 if ( (fModules[i]->GetDdlId() == ddlID)
379 && (fModules[i]->GetAD() == ad)
380 && (fModules[i]->GetADC() == adc))
381 return i;
382 }
383 }
384 return -1;
385}
386
387
388
389//______________________________________________________________________________
390AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
391{
392// Retrieve AliITSChannalDaSSD object from the array
393 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
394 if ( (fModules[modind]->GetDdlId() == ddlID)
395 && (fModules[modind]->GetAD() == ad)
396 && (fModules[modind]->GetADC() == adc) )
397 {
398 return fModules[modind]->GetStrip(stripID);
399 }
400 }
401 AliError(Form("AliITSHandleDaSSD: Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!",
402 ddlID, ad, adc, stripID));
403 return NULL;
404}
405
406
407
408//______________________________________________________________________________
409Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
410{
411// Assign array element with AliITSModuleDaSSD object
412 if ((index < fNumberOfModules) && (index >= 0))
413 {
414 if (fModules[index]) delete fModules[index];
415 fModules[index] = module;
416 return kTRUE;
417 }
418 else return kFALSE;
419}
420
421
422
423//______________________________________________________________________________
424Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
425{
426// Allocates memory for AliITSModuleDaSSD objects
427 if (numberofmodules > fgkNumberOfSSDModules)
428 AliWarning(Form("AliITSHandleDaSSD: the number of modules %i you use exceeds the maximum %i for ALICE ITS SSD",
429 numberofmodules, fgkNumberOfSSDModules));
430 if (fModules) {
431 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
432 delete [] fModules;
433 fModules = NULL;
434 }
435 fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
436 if (fModules) {
437 fNumberOfModules = numberofmodules;
438 memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
439 return kTRUE;
440 } else {
441 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
442 fNumberOfModules = 0;
443 fModules = NULL;
444 }
445 return kFALSE;
446}
447
448
449
450//______________________________________________________________________________
451Bool_t AliITSHandleDaSSD::ReadStaticBadChannelsMap(const Char_t *filename)
452{
453// Reads Static Bad Channels Map from the file
454 TFile *bcfile;
455 if (!filename) {
456 AliWarning("No file name is specified for Static Bad Channels Map!");
457 return kFALSE;
458 }
459 bcfile = new TFile(filename, "READ");
460 if (bcfile->IsZombie()) {
461 AliWarning(Form("Error reading file %s with Static Bad Channels Map!", filename));
462 return kFALSE;
463 }
464 bcfile->GetObject("AliITSBadChannelsSSDv2;1", fBadChannelsList);
465 if (!fBadChannelsList) {
466 AliWarning("Error fBadChannelsList == NULL!");
467 bcfile->Close();
468 delete bcfile;
469 return kFALSE;
470 }
471 bcfile->Close();
472 delete bcfile;
473 return kTRUE;
474}
475
476
477
478Bool_t AliITSHandleDaSSD::ReadDDLModuleMap(const Char_t *filename)
479{
480// Reads the SSD DDL Map from the file
481 ifstream ddlmfile;
482 AliRawReaderDate *rwr = NULL;
483 AliITSRawStreamSSD *rsm = NULL;
484 void *event = NULL;
485 if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;}
486 fDDLModuleMap = new (nothrow) Int_t [fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl];
487 if (!fDDLModuleMap) {
488 AliWarning("Error allocation memory for DDL Map!");
489 return kFALSE;
490 }
491 if (!filename) {
492 AliWarning("No file name is specified for SSD DDL Map, using the one from AliITSRawStreamSSD!");
493 rwr = new AliRawReaderDate(event);
494 rsm = new AliITSRawStreamSSD(rwr);
495 rsm->Setv11HybridDDLMapping();
496 for (Int_t ddli = 0; ddli < fgkNumberOfSSDDDLs; ddli++)
497 for (Int_t mi = 0; mi < fgkNumberOfSSDModulesPerDdl; mi++)
498 fDDLModuleMap[(ddli * fgkNumberOfSSDModulesPerDdl + mi)] = rsm->GetModuleNumber(ddli, mi);
499 if (rsm) delete rsm;
500 if (rwr) delete rwr;
501 return kTRUE;
502 }
503 ddlmfile.open(filename, ios::in);
504 if (!ddlmfile.is_open()) {
505 AliWarning(Form("Error reading file %s with SSD DDL Map!", filename));
506 if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;}
507 return kFALSE;
508 }
509 Int_t ind = 0;
510 while((!ddlmfile.eof()) && (ind < (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))) {
511 ddlmfile >> fDDLModuleMap[ind++];
512 if (ddlmfile.fail()) AliError(Form("Error extracting number from the DDL map file %s, ind: ", filename, ind));
513 }
514 if (ind != (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))
515 AliWarning(Form("Only %i (< %i) entries were read from DDL Map!", ind, (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl)));
516 ddlmfile.close();
517 return kTRUE;
518}
519
520
521
522//______________________________________________________________________________
523Int_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
524{
525// Reads raw data from file
526 if (!Init(fileName)){
527 AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
528 return kFALSE;
529 }
530 fNumberOfEvents = eventsnumber;
531 return ReadModuleRawData (fNumberOfModules);
532}
533
534
535
536//______________________________________________________________________________
537Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
538{
539// Reads raw data from file
540 AliRawReader *rawreaderdate = NULL;
541 AliITSRawStreamSSD *stream = NULL;
542 AliITSModuleDaSSD *module;
543 AliITSChannelDaSSD *strip;
544 Long_t eventind = 0;
545 Int_t nofeqipment, eqind;
546 Short_t equipid, prequipid;
547 Short_t modind;
548 if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
549 if (!fModules) {
550 AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
551 return 0;
552 }
553 if (!fDDLModuleMap) if (!ReadDDLModuleMap()) AliWarning("DDL map is not defined, ModuleID will be set to 0!");
554 stream = new AliITSRawStreamSSD(rawreaderdate);
555 stream->Setv11HybridDDLMapping();
556 //rawreaderdate->SelectEvents(-1);
557 rawreaderdate->Select("ITSSSD");
558 modind = 0;
559 nofeqipment = 0;
560 while (rawreaderdate->NextEvent()) {
561 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
562 prequipid = -1;
563 eqind = -1;
564 while (stream->Next()) {
565 equipid = rawreaderdate->GetEquipmentId();
566 if ((equipid != prequipid)) {
567 if ((eqind = GetEqIndex(equipid)) < 0) { fEqIndex.AddAt(equipid, nofeqipment); eqind = nofeqipment++; }
568 prequipid = equipid;
569 }
570 Int_t equiptype = rawreaderdate->GetEquipmentType();
571 UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID();
572 UChar_t ad = stream->GetAD();
573 UChar_t adc = stream->GetADC();
574 UShort_t stripID = stream->GetSideFlag() ? AliITSChannelDaSSD::GetMaxStripIdConst() - stream->GetStrip() : stream->GetStrip();
575 Short_t signal = stream->GetSignal();
576
577 Int_t indpos = (eqind * fgkNumberOfSSDModulesPerDdl)
578 + ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
579 Int_t modpos = fModIndex[indpos];
580 if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
581 if ((modpos < 0) && (modind < modulesnumber)) {
582 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
583 Int_t mddli;
584 if (fDDLModuleMap) mddli = RetrieveModuleId(ddlID, ad, adc);
585 else mddli = 0;
586 if (!module->SetModuleIdData (ddlID, ad, adc, mddli)) return 0;
587 module->SetModuleRorcId (equipid, equiptype);
588 module->SetCMFeromEventsNumber(fNumberOfEvents);
589 modpos = fModIndRead + modind;
590 modind += 1;
591 fModules[modpos] = module;
592 fModIndex[indpos] = modpos;
593 }
594 if (stripID < AliITSModuleDaSSD::GetStripsPerModuleConst()) {
595 if (!(strip = fModules[modpos]->GetStrip(stripID))) {
596 strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
597 fModules[modpos]->SetStrip(strip, stripID);
598 }
599 strip->SetSignal(eventind, signal);
600 } else fModules[modpos]->SetCMFerom(signal, (stripID - AliITSModuleDaSSD::GetStripsPerModuleConst()), eventind);
601 }
602 if (++eventind > fNumberOfEvents) break;
603 }
604 delete stream;
605 delete rawreaderdate;
606 if (modind) cout << "The memory was allocated for " << modind << " modules." << endl;
607 fModIndRead += modind;
608 if (modind < modulesnumber) RelocateModules();
609 return modind;
610}
611
612
613
614//______________________________________________________________________________
615Bool_t AliITSHandleDaSSD::RelocateModules()
616{
617// Relocate memory for AliITSModuleDaSSD object array
618 Int_t nm = 0;
619 AliITSModuleDaSSD **marray = NULL;
620 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
621 if (fModules[modind]) nm += 1;
622 if (nm == fNumberOfModules) return kTRUE;
623 marray = new (nothrow) AliITSModuleDaSSD* [nm];
624 if (!marray) {
625 AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
626 return kFALSE;
627 }
628 nm = 0;
629 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
630 if (fModules[modind]) marray[nm++] = fModules[modind];
631 delete [] fModules;
632 fModules = marray;
633 fNumberOfModules = fModIndRead = nm;
634 return kTRUE;
635}
636
637
638
639//______________________________________________________________________________
640Bool_t AliITSHandleDaSSD::AddFeromCm(AliITSModuleDaSSD *const module)
641// Restore the original signal value adding CM calculated and subtracted in ferom
642{
643 AliITSChannelDaSSD *strip;
644 Short_t *signal, *cmferom;
645
646 if (!module) return kFALSE;
647 for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
648 if (!(cmferom = module->GetCMFerom(chipind))) {
649 AliWarning(Form("AliITSHandleDaSSD: There is no Ferom CM values for chip %i, module %i!", chipind, module->GetModuleId()));
650 continue;
651 }
652 for (Int_t strind = (chipind * AliITSModuleDaSSD::GetStripsPerChip());
653 strind < ((chipind + 1) * AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
654 if (!(strip = module->GetStrip(strind))) continue;
655 if (!(signal = strip->GetSignal())) continue;
656// if (strip->GetEventsNumber() != module->GetEventsNumber()) return kFALSE;
657 Long_t ovev = 0;
658 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
659 if (SignalOutOfRange(signal[ev]) || SignalOutOfRange(cmferom[ev])) ovev += 1;
660 else {
661 Short_t signal1 = signal[ev] + cmferom[ev];
662 strip->SetSignal(ev, signal1);
663 }
664 }
665 }
666 }
667 return kTRUE;
668}
669
670
671
672//______________________________________________________________________________
673Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
674{
675// Calculates Pedestal
676 AliITSChannelDaSSD *strip;
677 Float_t pedestal, noise;
678 Short_t *signal;
679 Long_t ovev, ev, n;
680 if (!module) return kFALSE;
681 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
682 if (!(strip = module->GetStrip(strind))) continue;
683 if (!(signal = strip->GetSignal())) {
684 AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
685 module->GetModuleId(), strind));
686 continue;
687 }
688//************* pedestal first pass ****************
689 pedestal = 0.0f;
690 ovev = 0l;
691 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
692 if (SignalOutOfRange(signal[ev])) ovev += 1;
693 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
694 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
695 strip->SetPedestal(pedestal);
696//************* noise *******************************
697 Double_t nsum = 0.0L;
698 ovev = 0l;
699 for (ev = 0; ev < strip->GetEventsNumber(); ev++) {
700 if (SignalOutOfRange(signal[ev])) ovev += 1;
701 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
702 }
703 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
704 else noise = AliITSChannelDaSSD::GetUndefinedValue();
705 strip->SetNoise(noise);
706//************* pedestal second pass ****************
707 pedestal = 0.0f;
708 ovev = 0l;
709 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
710 if ( SignalOutOfRange(signal[ev])
711 || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
712 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
713 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
714 strip->SetPedestal(pedestal);
715 strip->SetOverflowNumber(ovev);
716 }
717 return kTRUE;
718}
719
720
721//______________________________________________________________________________
722Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module)
723{
724// Calculates Noise
725 AliITSChannelDaSSD *strip;
726 Short_t *signal;
727 Float_t noise;
728 Long_t ovev, n;
729 if (!module) return kFALSE;
730 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
731 if (!(strip = module->GetStrip(strind))) continue;
732 if (!(signal = strip->GetSignal())) {
733 strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
734 AliError(Form("AliITSHandleDaSSD: Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()",
735 module->GetModuleId(), strind));
736 continue;
737 }
738 Double_t nsum = 0.0L;
739 ovev = 0l;
740 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
741 if (SignalOutOfRange(signal[ev])) ovev += 1;
742 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
743 }
744 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
745 else noise = AliITSChannelDaSSD::GetUndefinedValue();
746 strip->SetNoise(noise);
747 }
748 return kTRUE;
749}
750
751
752
753//______________________________________________________________________________
754Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
755{
756// Calculates Noise with CM correction
757 AliITSChannelDaSSD *strip = NULL;
758 Short_t *signal;
759 Float_t noise;
760 Long_t ovev, n;
761 if (!CalculateCM(module)) {
762 AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
763 return kFALSE;
764 }
765 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
766 if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
767 if (!(signal = strip->GetSignal())) {
768 strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
769 AliError(Form("SSDDAModule: Error CalculateNoiseWithoutCM(): there are no events data for module[%i] strip[%i]->GetSignal()",
770 module->GetModuleId(), strind));
771 continue; //return kFALSE;
772 }
773 Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
774 Double_t nsum = 0.0L;
775 ovev = 0l;
776 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
777 if (SignalOutOfRange(signal[ev])) ovev += 1;
778 else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
779 }
780 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
781 else noise = AliITSChannelDaSSD::GetUndefinedValue();
782 strip->SetNoiseCM(noise);
783 }
784 return kTRUE;
785}
786
787
788
789//______________________________________________________________________________
790Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
791{
792// Calculates CM
793 AliITSChannelDaSSD *strip = NULL;
794 Short_t *signal;
795 Long_t ovstr, n;
796 Int_t stripind;
797 module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
798 for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
799 stripind = chipind * module->GetStripsPerChip();
800 module->GetCM()[chipind].Set(fNumberOfEvents);
801 module->GetCM()[chipind].Reset(0.0f);
802 for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
803 // calculate firs approximation of CM.
804 Double_t cm0 = 0.0L;
805 ovstr = 0l;
806 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
807 if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
808 if (!(signal = strip->GetSignal())) {
809 AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()",
810 module->GetModuleId(), strind));
811 return kFALSE;
812 }
813 if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
814 else cm0 += (signal[ev] - strip->GetPedestal());
815 }
816 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n);
817 else { module->SetCM(0.0f, chipind, ev); continue; }
818 // calculate avarage (cm - (signal - pedestal)) over the chip
819 Double_t cmsigma = 0.0L;
820 ovstr = 0l;
821 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
822 if (!(strip = module->GetStrip(strind))) continue;
823 if (!(signal = strip->GetSignal())) {
824 AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()\n",
825 module->GetModuleId(), strind));
826 return kFALSE;
827 }
828 if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
829 else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
830 }
831 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = sqrt(cmsigma / (Float_t)(n));
832 else { module->SetCM(0.0f, chipind, ev); continue; }
833 // calculate cm with threshold
834 Double_t cmsum = 0.0L;
835 ovstr = 0l;
836 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
837 if (!(strip = module->GetStrip(strind))) continue;
838 signal = strip->GetSignal();
839 if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())
840 || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
841 else cmsum += (signal[ev] - strip->GetPedestal());
842 }
843 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
844 else cmsum = 0.0L;
845 if (!module->SetCM(cmsum, chipind, ev));
846 }
847 }
848 return kTRUE;
849}
850
851
852//______________________________________________________________________________
853Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread)
854{
855// Performs calculation of calibration parameters (pedestal, noise, ...)
856 Int_t nm = 0;
857 if (nmread <= 0) return kFALSE;
858 if (!fModules) return kFALSE;
859 while ((nm = ReadModuleRawData(nmread)) > 0) {
860 cout << "Processing next " << nm << " modules;" << endl;
861 for (Int_t modind = fModIndProcessed; modind < fModIndRead; modind++) {
862 if (!fModules[modind]) {
863 AliError(Form("AliITSHandleDaSSD: Error ProcessRawData(): No AliITSModuleDaSSD object with index %i is allocated in AliITSHandleDaSSD\n",
864 modind));
865 return kFALSE;
866 }
867 AddFeromCm(fModules[modind]);
868 CalculatePedestal(fModules[modind]);
869 CalculateNoise(fModules[modind]);
870 CalculateNoiseCM(fModules[modind]);
871 }
872 DeleteSignal();
873 DeleteCM();
874 DeleteCMFerom();
875 fModIndProcessed = fModIndRead;
876 cout << fModIndProcessed << " - done" << endl;
877 }
878 return kTRUE;
879}
880
881
882//______________________________________________________________________________
883Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
884{
885// Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
886 if (!fDDLModuleMap) {
887 AliError("Error DDLMap is not initialized, return 0!");
888 return 0;
889 }
890 Int_t mddli = ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
891 if ((ddlID < fgkNumberOfSSDDDLs) && (mddli < fgkNumberOfSSDModulesPerDdl)) {
892 mddli = fDDLModuleMap[ddlID * fgkNumberOfSSDModulesPerDdl + mddli];
893 }
894 else {
895 AliWarning(Form("Module index = %d or ddlID = %d is out of range 0 is rturned", ddlID, mddli));
896 mddli = 0;
897 }
898 if (mddli > SHRT_MAX) return SHRT_MAX;
899 else return (Short_t)mddli;
900}
901
902
903
904//______________________________________________________________________________
905AliITSNoiseSSDv2* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const
906{
907// Fill in the array for OCDB
908 AliITSNoiseSSDv2 *ldcn = NULL;
909 AliITSModuleDaSSD *module = NULL;
910 AliITSChannelDaSSD *strip = NULL;
911 if (!fModules) return NULL;
912 ldcn = new AliITSNoiseSSDv2;
913 if (!ldcn) {
914 AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
915 return NULL;
916 }
917 for (Int_t i = 0; i < fNumberOfModules; i++) {
918 if (!(module = fModules[i])) continue;
919 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
920 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
921 if (!(strip = module->GetStrip(strind))) continue;
922 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
923 if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
924 ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
925 else
926 ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
927 }
928 }
929 return ldcn;
930}
931
932
933//______________________________________________________________________________
934AliITSBadChannelsSSDv2* AliITSHandleDaSSD::GetCalibrationBadChannels() const
935{
936// Fill in the TObjArray with the list of bad channels
937 AliITSBadChannelsSSDv2 *ldcbc = NULL;
938 AliITSModuleDaSSD *module = NULL;
939 AliITSChannelDaSSD *strip = NULL;
940 if (!fModules) return NULL;
941 ldcbc = new AliITSBadChannelsSSDv2;
942 if (!ldcbc) {
943 AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
944 return NULL;
945 }
946 for (Int_t i = 0; i < fNumberOfModules; i++) {
947 if (!(module = fModules[i])) continue;
948 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
949 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
950 if (!(strip = module->GetStrip(strind))) continue;
951 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
952 if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
953 ldcbc->AddBadChannelP(modid, strip->GetStripId(), module->CheckIfBad(strip->GetStripId()));
954 else
955 ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()),
956 module->CheckIfBad(strip->GetStripId()));
957 }
958 }
959 return ldcbc;
960}
961
962
963
964//______________________________________________________________________________
965Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname)
966{
967// Save Calibration data locally
968 AliITSBadChannelsSSDv2 *ldcbc = NULL;
969 AliITSPedestalSSDv2 *ldcp = NULL;
970 AliITSNoiseSSDv2 *ldcn = NULL;
971 AliITSModuleDaSSD *module = NULL;
972 AliITSChannelDaSSD *strip = NULL;
973 Char_t *tmpfname;
974 TString dadatafilename("");
975 if (!fModules) return kFALSE;
976 ldcn = new AliITSNoiseSSDv2;
977 ldcp = new AliITSPedestalSSDv2;
978 ldcbc = new AliITSBadChannelsSSDv2;
979 if ((!ldcn) || (!ldcp) || (!ldcp)) {
980 AliError("Error allocation mamory for calibration objects, return kFALSE!");
981 return kFALSE;
982 }
983 for (Int_t i = 0; i < fNumberOfModules; i++) {
984 if (!(module = fModules[i])) continue;
985 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
986 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
987 if (!(strip = module->GetStrip(strind))) continue;
988 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
989 if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) {
990 ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
991 ldcp->AddPedestalP(modid, strip->GetStripId(), strip->GetPedestal());
992 ldcbc->AddBadChannelP(modid, strip->GetStripId(), module->CheckIfBad(strip->GetStripId()));
993 } else {
994 ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
995 ldcp->AddPedestalN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetPedestal());
996 ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()),
997 module->CheckIfBad(strip->GetStripId()));
998 }
999 }
1000 }
1001 if (dafname) dadatafilename.Form("%s/", dafname);
1002 dadatafilename += TString::Format("ITSSSDda_%i.root", fLdcId);
1003 tmpfname = new Char_t[dadatafilename.Length()+1];
1004 dafname = strcpy(tmpfname, dadatafilename.Data());
1005 TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
1006 if (fileRun->IsZombie()) {
1007 AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
1008 ldcn->Delete();
1009 delete fileRun;
1010 delete ldcn;
1011 delete ldcp;
1012 delete ldcbc;
1013 return kFALSE;
1014 }
1015 fileRun->WriteTObject(ldcn);
1016 fileRun->WriteTObject(ldcp);
1017 if (fBadChannelsList)
1018 if (fMergeBCLists) {
1019 MergeBadChannels(ldcbc);
1020 fileRun->WriteTObject(ldcbc);
1021 } else fileRun->WriteTObject(fBadChannelsList);
1022 else fileRun->WriteTObject(ldcbc);
1023 fileRun->Close();
1024 delete fileRun;
1025 delete ldcn;
1026 delete ldcp;
1027 delete ldcbc;
1028 return kTRUE;
1029}
1030
1031
1032//______________________________________________________________________________
1033Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSDv2*& bcl) const
1034{
1035// Merges the statick bad channels list with bad channels got upon calibration
1036 AliITSModuleDaSSD *module = 0;
1037 Int_t nmpch = 0, nmnch = 0, ngpch = 0, ngnch = 0;
1038 if (!fBadChannelsList || !bcl) {
1039 AliWarning("Either fBadChannelsList == NULL or bad_channels_list == NULL, there is nothing to merge!");
1040 return -1;
1041 }
1042 for (Int_t modind = 0; modind < GetNumberOfModules(); modind++) {
1043 if (!(module = fModules[modind])) continue;
1044 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
1045 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
1046 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetPNStripsPerModule(); strind++) {
1047 if ( (!(fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask))
1048 && (bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask) )
1049 ngpch++;
1050 if ( (!(fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask))
1051 && (bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask) )
1052 ngnch++;
1053 if ( (!(bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask))
1054 && (fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) {
1055 bcl->AddBadChannelP(modid, strind, fBadChannelsList->GetBadChannelP(modid, strind));
1056 nmpch++;
1057 }
1058 if ( (!(bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask))
1059 && (fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) {
1060 bcl->AddBadChannelN(modid, strind, fBadChannelsList->GetBadChannelN(modid, strind));
1061 nmnch++;
1062 }
1063 }
1064 }
1065 AliInfo(Form("Static bad, dynamic good: P%d, N%d", nmpch, nmnch));
1066 AliInfo(Form("Static good, dynamic bad: P%d, N%d", ngpch, ngnch));
1067 return (nmnch + nmpch);
1068}
1069
1070
1071
1072//______________________________________________________________________________
1073Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
1074{
1075// Dump calibration parameters
1076 AliITSModuleDaSSD *mod;
1077 AliITSChannelDaSSD *strip;
1078 if (!fModules) {
1079 cout << "SSDDALDC::DumpModInfo(): Error, no modules are allocated!" << endl;
1080 return kFALSE;
1081 }
1082 cout << "Modules with MeanNoise > " << meannosethreshold << endl;
1083 for (Int_t i = 0; i < fNumberOfModules; i++) {
1084 if (!(mod = fModules[i])) continue;
1085 Float_t maxnoise = 0.0f, meannoise = 0.0f, maxped = 0.0f;
1086 Int_t maxstrind = 0, novfstr = 0;
1087 for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
1088 if (!(strip = mod->GetStrip(strind))) {novfstr++; continue; }
1089 if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++; continue; }
1090 if (maxnoise < strip->GetNoiseCM()) {
1091 maxnoise = strip->GetNoiseCM();
1092 maxstrind = strind;
1093 }
1094 meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Float_t>(strind - novfstr + 1)
1095 : strip->GetNoiseCM();
1096 if (TMath::Abs(maxped) < TMath::Abs(strip->GetPedestal())) maxped = strip->GetPedestal();
1097 }
1098 if (meannoise > meannosethreshold)
1099 cout << "Mod: " << i << "; DDl: " << (int)mod->GetDdlId() << "; AD: " << (int)mod->GetAD()
1100 << "; ADC: " << (int)mod->GetADC() << "; MaxPed = " << maxped
1101 << "; MeanNoise = " << meannoise
1102 << "; NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
1103 }
1104 return kTRUE;
1105}
1106
1107
1108
1109//______________________________________________________________________________
1110Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
1111{
1112// Print Module calibration data whether in file on in cout
1113 AliITSChannelDaSSD *strip;
1114 ofstream datafile;
1115 ostream *outputfile;
1116 if (!fname) { outputfile = &cout; }
1117 else {
1118 datafile.open(fname, ios::out);
1119 if (datafile.fail()) return kFALSE;
1120 outputfile = dynamic_cast<ostream*>(&datafile);
1121 }
1122 *outputfile << "DDL = " << (int)ddlID << "; AD = " << (int)ad << "; ADC = " << (int)adc << endl;
1123 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
1124 if ( (strip = GetStrip(ddlID, ad, adc, strind)) ) {
1125 *outputfile << "Str = " << strind << "; ped = " << strip->GetPedestal()
1126 << "; noise = " << strip->GetNoiseCM() << endl;
1127 }
1128 else continue;
1129 }
1130 if (datafile.is_open()) datafile.close();
1131 return kTRUE;
1132}
1133
1134
1135
1136//______________________________________________________________________________
1137void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
1138{
1139// Print general information retrieved from raw data file
1140 cout << "Raw data file: " << fRawDataFileName << endl
1141 << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
1142 << "Number of physics events: " << fNumberOfEvents << endl
1143 << str;
1144}
1145
1146
1147//______________________________________________________________________________
1148Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
1149{
1150// Used to allocate simulated modules to test the performance
1151 AliITSModuleDaSSD *module;
1152 UChar_t ad, adc, ddlID;
1153 ad = adc = ddlID = 0;
1154 if (!(fModules[copymodind])) return kFALSE;
1155 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
1156 if (!fModules[modind]) {
1157 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
1158 if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
1159 else if (adc == 5) adc = 8;
1160 else if (adc == 13) {
1161 adc = 0;
1162 if (ad < 8) ad += 1;
1163 else {
1164 ad = 0;
1165 ddlID +=1;
1166 }
1167 }
1168 if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
1169 fModules[modind] = module;
1170 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
1171 AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
1172 Long_t eventsnumber = cstrip->GetEventsNumber();
1173 AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
1174 for (Long_t evind = 0; evind < eventsnumber; evind++) {
1175 Short_t sign = cstrip->GetSignal(evind);
1176 if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
1177 }
1178 module->SetStrip(strip, strind);
1179 }
1180 }
1181 else {
1182 ddlID = fModules[modind]->GetDdlId();
1183 ad = fModules[modind]->GetAD();
1184 adc = fModules[modind]->GetADC();
1185 }
1186 }
1187 for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);
1188 return kTRUE;
1189}
1190
1191
1192
1193//___________________________________________________________________________________________
1194Bool_t AliITSHandleDaSSD::AdDataPresent(const Int_t ddl, const Int_t ad) const
1195{
1196// Check if there are calibration data for given ddl and slot
1197 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
1198 if ((GetModule(modind)->GetAD() == ad) && (GetModule(modind)->GetDdlId() == ddl)) return kTRUE;
1199 return kFALSE;
1200}
1201
1202
1203
1204//___________________________________________________________________________________________
1205Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t ad, const Char_t *fname) const
1206// Saves calibration files for selected equipment (DDL)
1207{
1208 fstream feefile;
1209 Int_t zsml, offsetml;
1210 ULong_t zsth, offset, zsoffset;
1211 if (!fname) {
1212 AliError("File name must be specified!");
1213 return kFALSE;
1214 }
1215 if (!AdDataPresent(ddl, ad)) {
1216 AliError(Form("Error SaveEqSlotCalibrationData(ddl = %i, ad = %i) no data present", ddl, ad));
1217 return kFALSE;
1218 }
1219 feefile.open(fname, ios::out);
1220 if (!feefile.is_open()) {
1221 AliError(Form("Can not open the file %s for output!", fname));
1222 return kFALSE;
1223 }
1224 for (zsml = 0; fgkZsBitMask >> zsml; zsml++);
1225 for (offsetml = 0; fgkOffSetBitMask >> offsetml; offsetml++);
1226 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
1227 for (Int_t adcb = 0; adcb < fgkAdcPerDBlock; adcb++) {
1228 zsoffset = 0x0;
1229 for (Int_t j = 0; j < 2; j++) {
1230 Int_t adc = adcb + j * 8;
1231 zsth = ZsThreshold(ddl, ad, adc, strind);
1232 offset = OffsetValue(ddl, ad, adc, strind);
1233 zsoffset = zsoffset | (((zsth << offsetml) | offset) << ((j == 0) ? (offsetml + zsml) : 0));
1234 }
1235 feefile << "0x" << ConvBase(static_cast<unsigned long>(zsoffset), 16) << endl;
1236 }
1237 }
1238 feefile.close();
1239 return kTRUE;
1240}
1241
1242
1243//______________________________________________________________________________
1244Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1245{
1246// Check if the channel is bad
1247 AliITSModuleDaSSD *module = NULL;
1248 Int_t modn = -1;
1249 if (fBadChannelsList && fDDLModuleMap) {
1250 modn = RetrieveModuleId(ddl, ad, adc);
1251 if (modn < 0) return -1;
1252 if (modn < fgkMinSSDModuleId) {
1253 AliWarning(Form("Module ddl/ad/adc: %i/%i/%i has number %i which is wrong for SSD module", ddl, ad, adc, strn, modn));
1254 return -1;
1255 }
1256 Short_t modid = modn - fgkMinSSDModuleId;
1257 if (strn < AliITSModuleDaSSD::GetPNStripsPerModule())
1258 return (fBadChannelsList->GetBadChannelP(modid, strn) & fgkBadChannelMask);
1259 else return (fBadChannelsList->GetBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strn)) & fgkBadChannelMask);
1260 } else {
1261 AliError("Error ether bad channels list or DDLMap is not initialized or both, AliITSModuleDaSSD::CheckIfBad(str) is used!");
1262 if ((module = GetModule(ddl, ad, adc))) {
1263 return (module->CheckIfBad(strn) & fgkBadChannelMask);
1264 } else {
1265 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc));
1266 return 0ul;
1267 }
1268 return 0;
1269 }
1270}
1271
1272
1273
1274//______________________________________________________________________________
1275Int_t AliITSHandleDaSSD::LadderIsOff(const UChar_t ddl, const UChar_t ad, const UChar_t adc) const
1276{
1277//Checks if the module with given ddl, ad, adc is on the ladder which is in the list of ladders which are off
1278 const Int_t nm5 = 500;
1279 const Int_t nm6 = 1248;
1280 const Int_t nml5a = 12;
1281 const Int_t nml5c = 10;
1282 const Int_t nml6a = 12;
1283 const Int_t nml6c = 13;
1284 Int_t modn, ladder, layer, side;
1285 AliITSModuleDaSSD *module;
1286 if (!(module = GetModule(ddl, ad, adc))) return 0;
1287 if ((modn = module->GetModuleId()) <= 0) modn = RetrieveModuleId(ddl, ad, adc);
1288 if (modn <= 0) return 0;
1289 layer = modn >= nm6 ? 1 : 0; // 6 : 5
1290 ladder = (modn - (layer ? nm6 : nm5)) / (layer ? (nml6a + nml6c) : (nml5a + nml5c));
1291 if ( ((modn - (layer ? nm6 : nm5)) % (layer ? (nml6a + nml6c) : (nml5a + nml5c))) < (layer ? nml6a : nml5a))
1292 side = 0; // A
1293 else side = 1; // C
1294 ladder += (layer ? 600 : 500);
1295 layer += 5;
1296 if (side)
1297 if (fCLaddersOff.GetSize()) {
1298 for(Int_t i = 0; i < fCLaddersOff.GetSize(); i++)
1299 if (fCLaddersOff.At(i) == ladder) return fCLaddersOff.At(i);
1300 return 0;
1301 } else return 0;
1302 else
1303 if (fALaddersOff.GetSize()) {
1304 for(Int_t i = 0; i < fALaddersOff.GetSize(); i++)
1305 if (fALaddersOff.At(i) == ladder) return fALaddersOff.At(i);
1306 return 0;
1307 } else return 0;
1308 return 0;
1309}
1310
1311
1312
1313//______________________________________________________________________________
1314ULong_t AliITSHandleDaSSD::OffsetValue(const AliITSChannelDaSSD *strip,
1315 const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1316{
1317// Calculate the offset value to be upload to FEROM
1318 Int_t pedint;
1319 if (fOffsetDefault < INT_MAX) pedint = fOffsetDefault;
1320 else pedint = TMath::Nint(strip->GetPedestal());
1321 if (pedint > static_cast<Int_t>((fgkOffSetBitMask >> 1))) {
1322 if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (GetModule(ddl, ad, adc)->CheckIfBad(strn))))
1323 AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i can not be represented with mask 0x%s, Offset = %i",
1324 pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), (fgkOffSetBitMask >> 1)));
1325 return (fgkOffSetBitMask >> 1);
1326 }
1327 if ((-pedint) > static_cast<Int_t>(((fgkOffSetBitMask + 1) >> 1))) {
1328 if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (GetModule(ddl, ad, adc)->CheckIfBad(strn))))
1329 AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i can not be represented with mask 0x%s, Offset = %i",
1330 pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(),
1331 ((fgkOffSetBitMask & (~fgkOffSetBitMask >> 1)) - fgkOffSetBitMask - 1)));
1332 return fgkOffSetBitMask & (~fgkOffSetBitMask >> 1);
1333 }
1334 return fgkOffSetBitMask & (pedint >= 0 ? pedint : pedint + fgkOffSetBitMask + 1);
1335}
1336
1337
1338
1339//______________________________________________________________________________
1340ULong_t AliITSHandleDaSSD::OffsetValue(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1341{
1342// Calculate the offset value to be upload to FEROM
1343 AliITSChannelDaSSD *strip = NULL;
1344 AliITSModuleDaSSD *module = NULL;
1345 if ((module = GetModule(ddl, ad, adc))) {
1346 if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn);
1347 else {
1348 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn));
1349 return 0ul;
1350 }
1351 } else {
1352 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc));
1353 return 0ul;
1354 }
1355}
1356
1357
1358
1359//______________________________________________________________________________
1360ULong_t AliITSHandleDaSSD::ZsThreshold(AliITSChannelDaSSD *strip) const
1361{
1362// Calculate the value of zero suppression threshold to be upload to FEROM
1363 ULong_t zs;
1364 if (fZsDefault < 0) {
1365 zs = TMath::Nint(fZsFactor * strip->GetNoiseCM());
1366 if (zs < static_cast<ULong_t>(fZsMinimum)) zs = static_cast<ULong_t>(fZsMinimum);
1367 }
1368 else zs = fZsDefault;
1369 return (zs < fgkZsBitMask) ? (zs & fgkZsBitMask) : fgkZsBitMask;
1370}
1371
1372
1373//______________________________________________________________________________
1374ULong_t AliITSHandleDaSSD::ZsThreshold(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1375{
1376// Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list
1377 AliITSChannelDaSSD *strip = NULL;
1378 AliITSModuleDaSSD *module = NULL;
1379 if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask;
1380 if (LadderIsOff(ddl, ad, adc)) return fgkZsBitMask;
1381 if ((module = GetModule(ddl, ad, adc))) {
1382 if (fMergeBCLists) if (module->CheckIfBad(strn)) return fgkZsBitMask;
1383 if ((strip = module->GetStrip(strn))) return ZsThreshold(strip);
1384 else {
1385 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn));
1386 return 0ul;
1387 }
1388 } else {
1389 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc));
1390 return 0ul;
1391 }
1392}
1393
1394
1395//______________________________________________________________________________
1396string AliITSHandleDaSSD::ConvBase(const unsigned long value, const long base) const
1397{
1398// Converts the unsigned long number into that in another base
1399 string digits = "0123456789ABCDEF";
1400 string result;
1401 unsigned long v = value;
1402 if((base < 2) || (base > 16)) {
1403 result = "Error: base out of range.";
1404 }
1405 else {
1406 int i = 0;
1407 do {
1408 result = digits[v % base] + result;
1409 v /= base;
1410 i++;
1411 }
1412 while((v) || (i<8));
1413 }
1414 return result;
1415}
1416
1417
1418
1419//______________________________________________________________________________
1420Int_t AliITSHandleDaSSD::CheckOffChips() const
1421{
1422// Check if the chip, module are off
1423 AliITSChannelDaSSD *strip;
1424 Int_t offthreshold;
1425 Int_t strnd, chipnd, modnd, stroff, chipoff, modoff;
1426 offthreshold = TMath::Nint(fZsMinimum/fZsFactor);
1427 modnd = modoff = 0;
1428 for (Int_t mi = 0; mi < fNumberOfModules; mi++) {
1429 if (!fModules[mi]) { modnd++; continue; }
1430 if (fModules[mi]->GetModuleId() < 0) continue;
1431 if (LadderIsOff(fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()) ) continue;
1432 chipoff = chipnd = 0;
1433 for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
1434 strnd = stroff = 0;
1435 Int_t stripind = chipind * AliITSModuleDaSSD::GetStripsPerChip();
1436 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
1437 if (!(strip = fModules[mi]->GetStrip(strind))) { strnd++; continue; }
1438 if (strip->GetNoiseCM() < offthreshold ) stroff++;
1439 }
1440 if (strnd == AliITSModuleDaSSD::GetStripsPerChip()) chipnd++;
1441 else if (stroff == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
1442 else if ((stroff + strnd) == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
1443 }
1444 if ((!chipoff) && (!chipnd)) continue;
1445 if (chipnd == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1446 AliInfo(Form("Module: (ddl/ad/adc) %i/%i/%i seems to be off and it is not on the ladders which are off!",
1447 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1448 modnd++;
1449 }
1450 if (chipoff == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1451 AliInfo(Form("Module (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!",
1452 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1453 modoff++;
1454 }
1455 else if ((chipoff + chipnd) == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1456 AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!",
1457 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1458 modoff++;
1459 }
1460 else if (chipoff) {
1461 AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i has %i chips which are off!",
1462 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC(), chipoff));
1463 modoff++;
1464 }
1465 }
1466 return (modoff + modnd);
1467}