]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSHandleDaSSD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- Protection added for null or empty input chains
[u/mrichter/AliRoot.git] / ITS / AliITSHandleDaSSD.cxx
CommitLineData
223dda26 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///
23///////////////////////////////////////////////////////////////////////////////
24
25#include <Riostream.h>
f67db810 26#include "AliITSHandleDaSSD.h"
223dda26 27#include <math.h>
c4d90345 28#include <limits.h>
223dda26 29#include "event.h"
30#include "TFile.h"
c4d90345 31#include "TString.h"
223dda26 32#include "TObjArray.h"
c4d90345 33#include "AliLog.h"
223dda26 34#include "AliITSNoiseSSD.h"
c4d90345 35#include "AliITSRawStreamSSD.h"
223dda26 36#include "AliRawReaderDate.h"
37
38#include "AliITSChannelDaSSD.h"
f67db810 39
40
41ClassImp(AliITSHandleDaSSD)
42
43using namespace std;
44
45
c4d90345 46const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698; // Number of SSD modules in ITS
47const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108; // Number of SSD modules in ITS
48const Float_t AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0; // Defalt value for fPedestalThresholdFactor
49const Float_t AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0; // Defalt value for fCmThresholdFactor
50
51//______________________________________________________________________________
f67db810 52AliITSHandleDaSSD::AliITSHandleDaSSD() :
c4d90345 53 fRawDataFileName(NULL),
f67db810 54 fNumberOfModules(0),
55 fModules(NULL),
c4d90345 56 fModIndProcessed(0),
57 fModIndRead(0),
58 fNumberOfEvents(0),
f67db810 59 fLdcId(0),
c4d90345 60 fRunId(0),
61 fPedestalThresholdFactor(fgkPedestalThresholdFactor),
62 fCmThresholdFactor(fgkCmThresholdFactor)
f67db810 63{
223dda26 64// Default constructor
f67db810 65}
66
67
c4d90345 68//______________________________________________________________________________
69AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
70 fRawDataFileName(NULL),
f67db810 71 fNumberOfModules(0),
72 fModules(NULL),
c4d90345 73 fModIndProcessed(0),
74 fModIndRead(0),
75 fNumberOfEvents(0),
f67db810 76 fLdcId(0),
c4d90345 77 fRunId(0),
78 fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
79 fCmThresholdFactor(fgkCmThresholdFactor)
f67db810 80{
c4d90345 81 if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
f67db810 82}
83
84
c4d90345 85//______________________________________________________________________________
f67db810 86AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
87 TObject(ssdadldc),
c4d90345 88 fRawDataFileName(ssdadldc.fRawDataFileName),
f67db810 89 fNumberOfModules(ssdadldc.fNumberOfModules),
a69c8ba0 90 fModules(NULL),
c4d90345 91 fModIndProcessed(ssdadldc.fModIndProcessed),
92 fModIndRead(ssdadldc.fModIndRead),
93 fNumberOfEvents(ssdadldc.fNumberOfEvents),
f67db810 94 fLdcId(ssdadldc.fLdcId),
c4d90345 95 fRunId(ssdadldc.fRunId),
96 fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor),
97 fCmThresholdFactor(ssdadldc.fCmThresholdFactor)
f67db810 98{
99 // copy constructor
a69c8ba0 100 if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
101 fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
102 if (fModules) {
103 for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
104 if (ssdadldc.fModules[modind]) {
105 fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
106 if (!fModules[modind]) {
107 AliError("AliITSHandleDaSSD: Error copy constructor");
108 for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
109 delete [] fModules;
110 fModules = NULL;
111 break;
112 }
113 } else fModules[modind] = NULL;
114 }
115 } else {
116 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
117 fNumberOfModules = 0;
118 fModules = NULL;
119 }
120 }
f67db810 121}
122
123
c4d90345 124//______________________________________________________________________________
f67db810 125AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
126{
127// assignment operator
a69c8ba0 128 if (this == &ssdadldc) return *this;
129 if (fModules) {
130 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
131 delete [] fModules;
132 fModules = NULL;
133 }
134 if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
135 fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
136 if (fModules) {
137 for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
138 if (ssdadldc.fModules[modind]) {
139 fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
140 if (!fModules[modind]) {
141 AliError("AliITSHandleDaSSD: Error assignment operator");
142 for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
143 delete [] fModules;
144 fModules = NULL;
145 break;
146 }
147 } else fModules[modind] = NULL;
148 }
149 } else {
150 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
151 fNumberOfModules = 0;
152 fModules = NULL;
153 }
154 }
f67db810 155 return *this;
156}
157
158
c4d90345 159//______________________________________________________________________________
f67db810 160AliITSHandleDaSSD::~AliITSHandleDaSSD()
223dda26 161{
162// Default destructor
f67db810 163 if (fModules)
164 {
165 for (Int_t i = 0; i < fNumberOfModules; i++)
166 {
167 if (fModules[i]) delete fModules[i];
168 }
169 delete [] fModules;
170 }
171}
172
173
174
c4d90345 175//______________________________________________________________________________
176void AliITSHandleDaSSD::Reset()
177{
178// Delete array of AliITSModuleDaSSD* objects.
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 fRawDataFileName = NULL;
185 fModIndProcessed = fModIndRead = 0;
186 fNumberOfEvents = 0;
187 fLdcId = fRunId = 0;
188 fPedestalThresholdFactor = fgkPedestalThresholdFactor;
189 fCmThresholdFactor = fgkCmThresholdFactor;
190}
191
192
193
194//______________________________________________________________________________
195Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname)
196{
197// Read raw data file and set initial and configuration parameters
198 Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0;
199 Int_t nofeqipmentev, nofeqipment = 0, eqn = 0;
200 AliRawReaderDate *rawreaderdate = NULL;
201 UChar_t *data = NULL;
202 Long_t datasize = 0, eqbelsize = 1;
203
204 if (configfname) ReadConfigurationFile(configfname);
205 rawreaderdate = new AliRawReaderDate(rdfname, 0);
206 if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) {
207 AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname));
208 MakeZombie();
209 return kFALSE;
210 }
211 if (rawreaderdate->NextEvent()) {
212 fLdcId = rawreaderdate->GetLDCId();
213 fRunId = rawreaderdate->GetRunNumber();
214 rawreaderdate->RewindEvents();
215 } else { MakeZombie(); return kFALSE; }
216 if (fModules) Reset();
217 rawreaderdate->SelectEvents(-1);
218 nofstrips = 0;
219 while (rawreaderdate->NextEvent()) {
220 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
221 nofstripsev = 0;
222 nofeqipmentev = 0;
223 while (rawreaderdate->ReadNextData(data)) {
224 nofeqipmentev += 1;
225 datasize = rawreaderdate->GetDataSize();
226 eqbelsize = rawreaderdate->GetEquipmentElementSize();
227 if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
228 AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i",
229 rdfname, datasize, eqbelsize));
230 MakeZombie();
231 return kFALSE;
232 }
233 nofstripsev += (Int_t) (datasize / eqbelsize);
234 }
235 if (physeventind++) {
236 if (nofstrips != nofstripsev) AliWarning("AliITSHandleDaSSD: number of strips varies from event to evnt");
237 if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to evnt");
238 }
239 nofstrips = nofstripsev;
240 nofeqipment = nofeqipmentev;
241 if (strn < nofstrips) strn = nofstrips;
242 if (eqn < nofeqipment) eqn = nofeqipment;
243 }
244 delete rawreaderdate;
245 if ((physeventind > 0) && (strn > 0))
246 {
247 fNumberOfEvents = physeventind;
248 fRawDataFileName = rdfname;
249 if (SetNumberOfModules(fgkNumberOfSSDModules)) {
a69c8ba0 250 TString str = TString::Format("Max number of equipment: %i, max number of channels: %i\n", eqn, strn);
c4d90345 251 DumpInitData(str.Data());
252 return kTRUE;
253 }
254 }
255 MakeZombie();
256 return kFALSE;
257}
258
259
260//______________________________________________________________________________
261Bool_t AliITSHandleDaSSD::ReadConfigurationFile(const Char_t *configfname)
262const {
263// Dowload configuration parameters from configuration file or database
264 return kFALSE;
265}
266
267
268
269//______________________________________________________________________________
f67db810 270AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
271{
223dda26 272// Retrieve AliITSModuleDaSSD object from the array
f67db810 273 if (!fModules) return NULL;
274 for (Int_t i = 0; i < fNumberOfModules; i++) {
275 if (fModules[i]) {
276 if ( (fModules[i]->GetDdlId() == ddlID)
277 && (fModules[i]->GetAD() == ad)
278 && (fModules[i]->GetADC() == adc))
279 return fModules[i];
280 }
281 }
282 return NULL;
283}
284
285
c4d90345 286Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
287{
288// Retrieve the position of AliITSModuleDaSSD object in the array
289 if (!fModules) return -1;
290 for (Int_t i = 0; i < fNumberOfModules; i++) {
291 if (fModules[i]) {
292 if ( (fModules[i]->GetDdlId() == ddlID)
293 && (fModules[i]->GetAD() == ad)
294 && (fModules[i]->GetADC() == adc))
295 return i;
296 }
297 }
298 return -1;
299}
300
301
f67db810 302
c4d90345 303//______________________________________________________________________________
f67db810 304AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
305{
223dda26 306// Retrieve AliITSChannalDaSSD object from the array
f67db810 307 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
308 if ( (fModules[modind]->GetDdlId() == ddlID)
309 && (fModules[modind]->GetAD() == ad)
310 && (fModules[modind]->GetADC() == adc) )
311 {
312 return fModules[modind]->GetStrip(stripID);
313 }
314 }
c4d90345 315 AliError(Form("AliITSHandleDaSSD: Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!",
316 ddlID, ad, adc, stripID));
f67db810 317 return NULL;
318}
319
320
321
c4d90345 322//______________________________________________________________________________
f67db810 323Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
324{
223dda26 325// Assign array element with AliITSModuleDaSSD object
f67db810 326 if ((index < fNumberOfModules) && (index >= 0))
327 {
328 if (fModules[index]) delete fModules[index];
329 fModules[index] = module;
330 return kTRUE;
331 }
332 else return kFALSE;
333}
334
335
c4d90345 336
337//______________________________________________________________________________
f67db810 338Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
339{
223dda26 340// Allocates memory for AliITSModuleDaSSD objects
341 if (numberofmodules > fgkNumberOfSSDModules)
c4d90345 342 AliWarning(Form("AliITSHandleDaSSD: the number of modules %i you use exceeds the maximum %i for ALICE ITS SSD",
343 numberofmodules, fgkNumberOfSSDModules));
344 if (fModules) {
345 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
346 delete [] fModules;
347 fModules = NULL;
348 }
223dda26 349 fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
350 if (fModules) {
351 fNumberOfModules = numberofmodules;
352 memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
353 return kTRUE;
354 } else {
c4d90345 355 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
f67db810 356 fNumberOfModules = 0;
357 fModules = NULL;
223dda26 358 }
f67db810 359 return kFALSE;
360}
361
362
c4d90345 363
364//______________________________________________________________________________
365Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
f67db810 366{
223dda26 367// Reads raw data from file
c4d90345 368 AliRawReaderDate *rawreaderdate = NULL;
f67db810 369 AliITSModuleDaSSD *module;
370 AliITSChannelDaSSD *strip;
371 Long_t datasize, eventind = 0;
372 Int_t nofstrips, eqbelsize;
373 UShort_t modind;
374 long32 *data;
c4d90345 375 UChar_t *databyte;
376 if (!Init(fileName)){
377 AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
f67db810 378 return kFALSE;
379 }
c4d90345 380 rawreaderdate = new AliRawReaderDate(fileName, 0);
223dda26 381 rawreaderdate->SelectEvents(-1);
f67db810 382 while (rawreaderdate->NextEvent()) {
223dda26 383 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
f67db810 384 fLdcId = rawreaderdate->GetLDCId();
385 fRunId = rawreaderdate->GetRunNumber();
386 modind = 0;
c4d90345 387 while (rawreaderdate->ReadNextData(databyte)) {
388 data = reinterpret_cast<long32*>(databyte);
f67db810 389 Int_t equipid = rawreaderdate->GetEquipmentId(); // EquipmentID required to access to rorc
390 Int_t equiptype = rawreaderdate->GetEquipmentType(); //
391 UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); // GetDDLID(); index of DDL, ITS SSD: 33-48
392 datasize = rawreaderdate->GetDataSize();
393 eqbelsize = rawreaderdate->GetEquipmentElementSize();
394 if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
c4d90345 395 AliError(Form("AliITSHandleDaSSD: Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i",
396 datasize, eqbelsize));
f67db810 397 return kFALSE;
398 }
399 nofstrips = (Int_t) (datasize / eqbelsize);
400 for (Int_t strind = 0; strind < nofstrips; strind++) {
401 UChar_t ad = (UChar_t) (data[strind] >> 28) & 0x0000000F; // index of AD module 0-9
402 UChar_t adc = (UChar_t) (data[strind] >> 24) & 0x0000000F; // index of ADC module 0-5, 8-13
403 UShort_t stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF; // strip number 0-1535
404 Short_t signal = (Short_t)(data[strind] & 0x00000FFF);
405 signal = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst())
406 : signal;
407 if (!(module = GetModule(ddlID, ad, adc))) {
408 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
c4d90345 409 if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return kFALSE;
f67db810 410 module->SetModuleRorcId (equipid, equiptype);
411 fModules[modind++] = module;
412 }
413 if (!(strip = module->GetStrip(stripID))) {
414 strip = new AliITSChannelDaSSD(stripID, eventsnumber);
415 module->SetStrip(strip, stripID);
416 }
417 strip->SetSignal(eventind, signal);
418 }
419 if (modind) cout << "The memory was allocated for " << modind << " modules." << endl;
420 }
421 if (++eventind > eventsnumber) break;
422 }
423 delete rawreaderdate;
424 return RelocateModules();
425}
426
427
c4d90345 428
429//______________________________________________________________________________
430Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
431{
432// Reads raw data from file
433 AliRawReaderDate *rawreaderdate = NULL;
434 AliITSModuleDaSSD *module;
435 AliITSChannelDaSSD *strip;
436 Long_t datasize, eventind = 0;
437 Int_t nofstrips, eqbelsize;
438 UShort_t modind;
439 long32 *data;
440 UChar_t *databyte;
441 if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
442 if (!fModules) {
443 AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
444 return 0;
445 }
446 rawreaderdate->SelectEvents(-1);
447 modind = 0;
448 while (rawreaderdate->NextEvent()) {
449 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
450 while (rawreaderdate->ReadNextData(databyte)) {
451 data = reinterpret_cast<long32*>(databyte);
452 Int_t equipid = rawreaderdate->GetEquipmentId(); // EquipmentID required to access to rorc
453 Int_t equiptype = rawreaderdate->GetEquipmentType(); //
454 UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); // GetDDLID(); index of DDL, ITS SSD: 33-48
455 datasize = rawreaderdate->GetDataSize();
456 eqbelsize = rawreaderdate->GetEquipmentElementSize();
457 if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
458 AliError(Form("AliITSHandleDaSSD: Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i",
459 datasize, eqbelsize));
460 return kFALSE;
461 }
462 nofstrips = (Int_t) (datasize / eqbelsize);
463 for (Int_t strind = 0; strind < nofstrips; strind++) {
464 UChar_t ad = (UChar_t) (data[strind] >> 28) & 0x0000000F; // index of AD module 0-9
465 UChar_t adc = (UChar_t) (data[strind] >> 24) & 0x0000000F; // index of ADC module 0-5, 8-13
466 UShort_t stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF; // strip number 0-1535
467 Short_t signal = (Short_t)(data[strind] & 0x00000FFF);
468 signal = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst())
469 : signal;
470 Int_t modpos = GetModuleIndex(ddlID, ad, adc);
471 if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
472 if ((modpos < 0) && (modind < modulesnumber)) {
473 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
474 if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return 0;
475 module->SetModuleRorcId (equipid, equiptype);
476 modpos = fModIndRead + modind;
477 modind += 1;
478 fModules[modpos] = module;
479 }
480 if (!(strip = fModules[modpos]->GetStrip(stripID))) {
481 strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
482 fModules[modpos]->SetStrip(strip, stripID);
483 }
484 strip->SetSignal(eventind, signal);
485 }
486 }
487 if (++eventind > fNumberOfEvents) break;
488 }
489 delete rawreaderdate;
490 if (modind) cout << "The memory was allocated for " << modind << " modules." << endl;
491 fModIndRead += modind;
492 if (modind < modulesnumber) RelocateModules();
493 return modind;
494}
495
496
497
498//______________________________________________________________________________
f67db810 499Bool_t AliITSHandleDaSSD::RelocateModules()
223dda26 500{
501// Relocate memory for AliITSModuleDaSSD object array
f67db810 502 Int_t nm = 0;
223dda26 503 AliITSModuleDaSSD **marray = NULL;
f67db810 504 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
505 if (fModules[modind]) nm += 1;
506 if (nm == fNumberOfModules) return kTRUE;
223dda26 507 marray = new (nothrow) AliITSModuleDaSSD* [nm];
508 if (!marray) {
c4d90345 509 AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
f67db810 510 return kFALSE;
511 }
512 nm = 0;
513 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
514 if (fModules[modind]) marray[nm++] = fModules[modind];
515 delete [] fModules;
516 fModules = marray;
c4d90345 517 fNumberOfModules = fModIndRead = nm;
f67db810 518 return kTRUE;
519}
520
521
c4d90345 522
523//______________________________________________________________________________
524Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
f67db810 525{
223dda26 526// Calculates Pedestal
f67db810 527 AliITSChannelDaSSD *strip;
c4d90345 528 Float_t pedestal, noise;
529 Short_t *signal;
530 Long_t ovev, ev, n;
531 if (!module) return kFALSE;
532 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
533 if (!(strip = module->GetStrip(strind))) continue;
534 if (!(signal = strip->GetSignal())) {
535 AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
536 module->GetModuleId(), strind));
537 continue;
f67db810 538 }
c4d90345 539//************* pedestal first pass ****************
540 pedestal = 0.0f;
541 ovev = 0l;
542 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
543 if (SignalOutOfRange(signal[ev])) ovev += 1;
544 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
545 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
546 strip->SetPedestal(pedestal);
547//************* noise *******************************
548 Double_t nsum = 0.0L;
549 ovev = 0l;
550 for (ev = 0; ev < strip->GetEventsNumber(); ev++) {
551 if (SignalOutOfRange(signal[ev])) ovev += 1;
552 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
553 }
554 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
555 else noise = AliITSChannelDaSSD::GetUndefinedValue();
556 strip->SetNoise(noise);
557//************* pedestal second pass ****************
558 pedestal = 0.0f;
559 ovev = 0l;
560 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
561 if ( SignalOutOfRange(signal[ev])
562 || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
563 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
564 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
565 strip->SetPedestal(pedestal);
566 strip->SetOverflowNumber(ovev);
f67db810 567 }
568 return kTRUE;
569}
570
571
c4d90345 572//______________________________________________________________________________
a69c8ba0 573Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module)
f67db810 574{
223dda26 575// Calculates Noise
f67db810 576 AliITSChannelDaSSD *strip;
577 Short_t *signal;
578 Float_t noise;
579 Long_t ovev, n;
c4d90345 580 if (!module) return kFALSE;
581 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
582 if (!(strip = module->GetStrip(strind))) continue;
583 if (!(signal = strip->GetSignal())) {
584 strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
585 AliError(Form("AliITSHandleDaSSD: Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()",
586 module->GetModuleId(), strind));
587 continue;
f67db810 588 }
c4d90345 589 Double_t nsum = 0.0L;
590 ovev = 0l;
591 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
592 if (SignalOutOfRange(signal[ev])) ovev += 1;
593 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
594 }
595 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
596 else noise = AliITSChannelDaSSD::GetUndefinedValue();
597 strip->SetNoise(noise);
f67db810 598 }
599 return kTRUE;
600}
601
602
603
c4d90345 604//______________________________________________________________________________
605Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
f67db810 606{
c4d90345 607// Calculates Noise with CM correction
608 AliITSChannelDaSSD *strip = NULL;
609 Short_t *signal;
610 Float_t noise;
611 Long_t ovev, n;
612 if (!CalculateCM(module)) {
613 AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
614 return kFALSE;
615 }
616 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
617 if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
618 if (!(signal = strip->GetSignal())) {
619 strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
620 AliError(Form("SSDDAModule: Error CalculateNoiseWithoutCM(): there are no events data for module[%i] strip[%i]->GetSignal()",
621 module->GetModuleId(), strind));
622 return kFALSE;
f67db810 623 }
c4d90345 624 Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
625 Double_t nsum = 0.0L;
626 ovev = 0l;
627 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
628 if (SignalOutOfRange(signal[ev])) ovev += 1;
629 else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
630 }
631 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
632 else noise = AliITSChannelDaSSD::GetUndefinedValue();
633 strip->SetNoiseCM(noise);
634 }
635return kTRUE;
f67db810 636}
637
638
639
c4d90345 640//______________________________________________________________________________
641Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
f67db810 642{
c4d90345 643// Calculates CM
f67db810 644 AliITSChannelDaSSD *strip = NULL;
c4d90345 645 Short_t *signal;
646 Long_t ovstr, n;
647 Int_t stripind;
648 module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
649 for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
650 stripind = chipind * module->GetStripsPerChip();
651 module->GetCm()[chipind].Set(fNumberOfEvents);
652 module->GetCm()[chipind].Reset(0.0f);
653 for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
654 // calculate firs approximation of CM.
655 Double_t cm0 = 0.0L;
656 ovstr = 0l;
657 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
658 if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
659 if (!(signal = strip->GetSignal())) {
660 AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()",
661 module->GetModuleId(), strind));
662 return kFALSE;
663 }
664 if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) ||
665 (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
666 else cm0 += (signal[ev] - strip->GetPedestal());
f67db810 667 }
c4d90345 668 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n);
669 else { module->SetCM(0.0f, chipind, ev); continue; }
670 // calculate avarage (cm - (signal - pedestal)) over the chip
671 Double_t cmsigma = 0.0L;
672 ovstr = 0l;
673 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
674 if (!(strip = module->GetStrip(strind))) continue;
675 if (!(signal = strip->GetSignal())) {
676 AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()\n",
677 module->GetModuleId(), strind));
678 return kFALSE;
f67db810 679 }
c4d90345 680 if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) ||
681 (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
682 else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
f67db810 683 }
c4d90345 684 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = sqrt(cmsigma / (Float_t)(n));
685 else { module->SetCM(0.0f, chipind, ev); continue; }
686 // calculate cm with threshold
687 Double_t cmsum = 0.0L;
688 ovstr = 0l;
689 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
690 if (!(strip = module->GetStrip(strind))) continue;
691 signal = strip->GetSignal();
692 if ( (signal[ev] >= AliITSChannelDaSSD::GetOverflowConst())
693 || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())
694 || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
695 else cmsum += (signal[ev] - strip->GetPedestal());
696 }
697 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
698 else cmsum = 0.0L;
699 if (!module->SetCM(cmsum, chipind, ev));
700 }
701 }
702 return kTRUE;
703}
704
705
706//______________________________________________________________________________
707Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread)
708{
709// Performs calculation of calibration parameters (pedestal, noise, ...)
710 Int_t nm = 0;
711 if (nmread <= 0) return kFALSE;
712 if (!fModules) return kFALSE;
713 while ((nm = ReadModuleRawData(nmread)) > 0) {
714 cout << "Processing next " << nm << " modules;" << endl;
715 for (Int_t modind = fModIndProcessed; modind < fModIndRead; modind++) {
716 if (!fModules[modind]) {
717 AliError(Form("AliITSHandleDaSSD: Error ProcessRawData(): No AliITSModuleDaSSD object with index %i is allocated in AliITSHandleDaSSD\n",
718 modind));
719 return kFALSE;
f67db810 720 }
c4d90345 721 CalculatePedestal(fModules[modind]);
722 CalculateNoise(fModules[modind]);
723 CalculateNoiseCM(fModules[modind]);
f67db810 724 }
c4d90345 725 DeleteSignal();
a69c8ba0 726// DeleteCM();
c4d90345 727 fModIndProcessed = fModIndRead;
728 cout << fModIndProcessed << " - done" << endl;
729 }
730 return kTRUE;
f67db810 731}
732
733
c4d90345 734//______________________________________________________________________________
735Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
736{
737// Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
738 Int_t mddli = (ad - 1) * 12 + ((adc<6) ? adc : (adc-2));
739 if ((ddlID < AliITSRawStreamSSD::kDDLsNumber) && (mddli < AliITSRawStreamSSD::kModulesPerDDL)) {
740 mddli = AliITSRawStreamSSD::GetModuleNumber(ddlID, mddli);
741 if (mddli > SHRT_MAX) return SHRT_MAX;
742 else return (Short_t)mddli;
743 }
744 else {
745 AliWarning(Form("Module index = %d or ddlID = %d is out of range -1 is rturned", ddlID, mddli));
746 return -1;
747 }
748}
749
f67db810 750
c4d90345 751
752//______________________________________________________________________________
f67db810 753TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
223dda26 754{
755// Fill in the array for OCDB
f67db810 756 TObjArray *ldcc;
c4d90345 757 TObject *modcalibobj;
f67db810 758 if (!fModules) return NULL;
759 ldcc = new TObjArray(fNumberOfModules, 0);
760 for (Int_t i = 0; i < fNumberOfModules; i++) {
761 if (!fModules[i]) {
762 delete ldcc;
763 return NULL;
764 }
c4d90345 765 modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule());
766 ldcc->AddAt(modcalibobj, i);
f67db810 767 }
768 ldcc->Compress();
769 return ldcc;
770}
771
772
c4d90345 773//______________________________________________________________________________
774Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) const
f67db810 775{
223dda26 776// Save Calibration data locally
f67db810 777 TObjArray *ldcc;
c4d90345 778 TObject *modcalibobj;
779 Char_t *tmpfname;
780 TString dadatafilename("");
f67db810 781 if (!fModules) return kFALSE;
782 ldcc = new TObjArray(fNumberOfModules, 0);
783 for (Int_t i = 0; i < fNumberOfModules; i++) {
784 if (!fModules[i]) {
785 delete ldcc;
786 return kFALSE;
787 }
c4d90345 788 modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule());
789 ldcc->AddAt(modcalibobj, i);
f67db810 790 }
791 ldcc->Compress();
a69c8ba0 792 if (dafname) dadatafilename.Form("%s/", dafname);
793 dadatafilename += TString::Format("ITSSSDda_%i_%i.root", fLdcId, fRunId);
794 tmpfname = new Char_t[dadatafilename.Length()+1];
c4d90345 795 dafname = strcpy(tmpfname, dadatafilename.Data());
796 TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
f67db810 797 if (fileRun->IsZombie()) {
c4d90345 798 AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
f67db810 799 ldcc->Delete();
800 delete fileRun;
c4d90345 801 delete ldcc;
f67db810 802 return kFALSE;
803 }
804 fileRun->WriteTObject(ldcc);
805 fileRun->Close();
806 ldcc->Delete();
807 delete fileRun;
c4d90345 808 delete ldcc;
809 return kTRUE;
810}
811
812
813
814//______________________________________________________________________________
815Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
816{
817// Dump calibration parameters
818 AliITSModuleDaSSD *mod;
819 AliITSChannelDaSSD *strip;
820 if (!fModules) {
821 cout << "SSDDALDC::DumpModInfo(): Error, no modules are allocated!" << endl;
822 return kFALSE;
823 }
824 cout << "Modules with MeanNoise > " << meannosethreshold << endl;
825 for (Int_t i = 0; i < fNumberOfModules; i++) {
826 if (!(mod = fModules[i])) continue;
827 Float_t maxnoise = 0.0f, meannoise = 0.0f;
828 Int_t maxstrind = 0, novfstr = 0;
829 for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
830 if (!(strip = mod->GetStrip(strind))) {novfstr++; continue; }
831 if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++; continue; }
832 if (maxnoise < strip->GetNoiseCM()) {
833 maxnoise = strip->GetNoiseCM();
834 maxstrind = strind;
835 }
836 meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Float_t>(strind - novfstr + 1)
837 : strip->GetNoiseCM();
838 }
839 if (meannoise > meannosethreshold)
840 cout << "Mod: " << i << "; DDl: " << (int)mod->GetDdlId() << "; AD: " << (int)mod->GetAD()
841 << "; ADC: " << (int)mod->GetADC() << "; MeanNoise = " << meannoise
842 << "; NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
843 }
844 return kTRUE;
845}
846
847
848
849//______________________________________________________________________________
850Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
851{
852// Print Module calibration data whether in file on in cout
853 AliITSChannelDaSSD *strip;
854 ofstream datafile;
855 ostream *outputfile;
856 if (!fname) { outputfile = &cout; }
857 else {
858 datafile.open(fname, ios::out);
859 if (datafile.fail()) return kFALSE;
860 outputfile = dynamic_cast<ostream*>(&datafile);
861 }
862 *outputfile << "DDL = " << (int)ddlID << "; AD = " << (int)ad << "; ADC = " << (int)adc << endl;
863 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
864 if (strip = GetStrip(ddlID, ad, adc, strind)) {
865 *outputfile << "Str = " << strind << "; ped = " << strip->GetPedestal()
866 << "; noise = " << strip->GetNoiseCM() << endl;
867 }
868 else continue;
869 }
870 if (datafile.is_open()) datafile.close();
871 return kTRUE;
872}
873
874
875
876void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
877{
878// Print general information retrieve from raw data file
879 cout << "Raw data file: " << fRawDataFileName << endl
880 << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
881 << "Number of physics events: " << fNumberOfEvents << endl
882 << str;
883}
884
885
886//______________________________________________________________________________
887Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
888{
889// Used to allocate simulated modules to test the performance
890 AliITSModuleDaSSD *module;
891 UChar_t ad, adc, ddlID;
892 ad = adc = ddlID = 0;
893 if (!(fModules[copymodind])) return kFALSE;
894 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
895 if (!fModules[modind]) {
896 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
897 if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
898 else if (adc == 5) adc = 8;
899 else if (adc == 13) {
900 adc = 0;
901 if (ad < 8) ad += 1;
902 else {
903 ad = 0;
904 ddlID +=1;
905 }
906 }
907 if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
908 fModules[modind] = module;
909 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
910 AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
911 Long_t eventsnumber = cstrip->GetEventsNumber();
912 AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
913 for (Long_t evind = 0; evind < eventsnumber; evind++) {
914 Short_t sign = *cstrip->GetSignal(evind);
915 if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
916 }
917 module->SetStrip(strip, strind);
918 }
919 }
920 else {
921 ddlID = fModules[modind]->GetDdlId();
922 ad = fModules[modind]->GetAD();
923 adc = fModules[modind]->GetADC();
924 }
925 }
926 for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);
f67db810 927 return kTRUE;
928}