]> 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
Corrected coding violations
[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>
28#include <sstream>
29#include <string>
30#include "event.h"
31#include "TFile.h"
32#include "TObjArray.h"
33#include "AliITSNoiseSSD.h"
34#include "AliRawReaderDate.h"
35
36#include "AliITSChannelDaSSD.h"
f67db810 37
38
39ClassImp(AliITSHandleDaSSD)
40
41using namespace std;
42
43
44AliITSHandleDaSSD::AliITSHandleDaSSD() :
45 fNumberOfModules(0),
46 fModules(NULL),
47 fLdcId(0),
48 fRunId(0)
49{
223dda26 50// Default constructor
f67db810 51}
52
53
54AliITSHandleDaSSD::AliITSHandleDaSSD(const Int_t numberofmodules) :
55 fNumberOfModules(0),
56 fModules(NULL),
57 fLdcId(0),
58 fRunId(0)
59{
223dda26 60// Constructor allocates memory for AliITSModuleDaSSD objects
f67db810 61 if (numberofmodules > fgkNumberOfSSDModules)
62 cout << "ALICE ITS SSD contains " << fgkNumberOfSSDModules << "modules!"<< endl;
223dda26 63 fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
64 if (fModules) {
65 fNumberOfModules = numberofmodules;
66 memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
67 } else {
68 Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules);
f67db810 69 fNumberOfModules = 0;
70 fModules = NULL;
223dda26 71 }
f67db810 72}
73
74
75AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
76 TObject(ssdadldc),
77 fNumberOfModules(ssdadldc.fNumberOfModules),
78 fModules(ssdadldc.fModules),
79 fLdcId(ssdadldc.fLdcId),
80 fRunId(ssdadldc.fRunId)
81{
82 // copy constructor
83
84 Fatal("AliITSHandleDaSSD", "copy constructor not implemented");
85}
86
87
88AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
89{
90// assignment operator
91
92 Fatal("operator =", "assignment operator not implemented");
93 return *this;
94}
95
96
97AliITSHandleDaSSD::~AliITSHandleDaSSD()
223dda26 98{
99// Default destructor
f67db810 100 if (fModules)
101 {
102 for (Int_t i = 0; i < fNumberOfModules; i++)
103 {
104 if (fModules[i]) delete fModules[i];
105 }
106 delete [] fModules;
107 }
108}
109
110
111
112AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
113{
223dda26 114// Retrieve AliITSModuleDaSSD object from the array
f67db810 115 if (!fModules) return NULL;
116 for (Int_t i = 0; i < fNumberOfModules; i++) {
117 if (fModules[i]) {
118 if ( (fModules[i]->GetDdlId() == ddlID)
119 && (fModules[i]->GetAD() == ad)
120 && (fModules[i]->GetADC() == adc))
121 return fModules[i];
122 }
123 }
124 return NULL;
125}
126
127
128
f67db810 129AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
130{
223dda26 131// Retrieve AliITSChannalDaSSD object from the array
f67db810 132 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
133 if ( (fModules[modind]->GetDdlId() == ddlID)
134 && (fModules[modind]->GetAD() == ad)
135 && (fModules[modind]->GetADC() == adc) )
136 {
137 return fModules[modind]->GetStrip(stripID);
138 }
139 }
140 Error("AliITSHandleDaSSD", "Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!", ddlID, ad, adc, stripID);
141 return NULL;
142}
143
144
145
146Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
147{
223dda26 148// Assign array element with AliITSModuleDaSSD object
f67db810 149 if ((index < fNumberOfModules) && (index >= 0))
150 {
151 if (fModules[index]) delete fModules[index];
152 fModules[index] = module;
153 return kTRUE;
154 }
155 else return kFALSE;
156}
157
158
159Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
160{
223dda26 161// Allocates memory for AliITSModuleDaSSD objects
162 if (numberofmodules > fgkNumberOfSSDModules)
163 Warning("AliITSHandleDaSSD", "The number of modules %i you use exceeds the maximum %i for ALICE ITS SSD", numberofmodules, fgkNumberOfSSDModules);
164 if (fModules) { delete [] fModules; fModules = NULL; }
165 fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
166 if (fModules) {
167 fNumberOfModules = numberofmodules;
168 memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
169 return kTRUE;
170 } else {
171 Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules);
f67db810 172 fNumberOfModules = 0;
173 fModules = NULL;
223dda26 174 }
f67db810 175 return kFALSE;
176}
177
178
179Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
180{
223dda26 181// Reads raw data from file
f67db810 182 AliRawReaderDate *rawreaderdate = new AliRawReaderDate(fileName, 0);
183 AliITSModuleDaSSD *module;
184 AliITSChannelDaSSD *strip;
185 Long_t datasize, eventind = 0;
186 Int_t nofstrips, eqbelsize;
187 UShort_t modind;
188 long32 *data;
189 if (!fModules) {
190 Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: no structure was allocated for data");
191 return kFALSE;
192 }
223dda26 193 rawreaderdate->SelectEvents(-1);
f67db810 194 while (rawreaderdate->NextEvent()) {
223dda26 195 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
f67db810 196 fLdcId = rawreaderdate->GetLDCId();
197 fRunId = rawreaderdate->GetRunNumber();
198 modind = 0;
199 while (rawreaderdate->ReadNextData((UChar_t*&)data)) {
200 Int_t equipid = rawreaderdate->GetEquipmentId(); // EquipmentID required to access to rorc
201 Int_t equiptype = rawreaderdate->GetEquipmentType(); //
202 UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); // GetDDLID(); index of DDL, ITS SSD: 33-48
203 datasize = rawreaderdate->GetDataSize();
204 eqbelsize = rawreaderdate->GetEquipmentElementSize();
205 if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
206 Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i", datasize,
207 eqbelsize);
208 return kFALSE;
209 }
210 nofstrips = (Int_t) (datasize / eqbelsize);
211 for (Int_t strind = 0; strind < nofstrips; strind++) {
212 UChar_t ad = (UChar_t) (data[strind] >> 28) & 0x0000000F; // index of AD module 0-9
213 UChar_t adc = (UChar_t) (data[strind] >> 24) & 0x0000000F; // index of ADC module 0-5, 8-13
214 UShort_t stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF; // strip number 0-1535
215 Short_t signal = (Short_t)(data[strind] & 0x00000FFF);
216 signal = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst())
217 : signal;
218 if (!(module = GetModule(ddlID, ad, adc))) {
219 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
220 if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
221 module->SetModuleRorcId (equipid, equiptype);
222 fModules[modind++] = module;
223 }
224 if (!(strip = module->GetStrip(stripID))) {
225 strip = new AliITSChannelDaSSD(stripID, eventsnumber);
226 module->SetStrip(strip, stripID);
227 }
228 strip->SetSignal(eventind, signal);
229 }
230 if (modind) cout << "The memory was allocated for " << modind << " modules." << endl;
231 }
232 if (++eventind > eventsnumber) break;
233 }
234 delete rawreaderdate;
235 return RelocateModules();
236}
237
238
239Bool_t AliITSHandleDaSSD::RelocateModules()
223dda26 240{
241// Relocate memory for AliITSModuleDaSSD object array
f67db810 242 Int_t nm = 0;
223dda26 243 AliITSModuleDaSSD **marray = NULL;
f67db810 244 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
245 if (fModules[modind]) nm += 1;
246 if (nm == fNumberOfModules) return kTRUE;
223dda26 247 marray = new (nothrow) AliITSModuleDaSSD* [nm];
248 if (!marray) {
249 Error("AliITSHandleDaSSD", "Error relocating memory for %i AliITSModuleDaSSD* objects!", nm);
f67db810 250 return kFALSE;
251 }
252 nm = 0;
253 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
254 if (fModules[modind]) marray[nm++] = fModules[modind];
255 delete [] fModules;
256 fModules = marray;
257 fNumberOfModules = nm;
258 return kTRUE;
259}
260
261
262Bool_t AliITSHandleDaSSD::CalculatePedestal()
263{
223dda26 264// Calculates Pedestal
f67db810 265 Float_t pedestal;
266 Short_t *signal;
267 AliITSChannelDaSSD *strip;
268 Long_t ovev, ev;
269 if (!fModules) return kFALSE;
270 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
271 if (!fModules[modind]) {
272 Error("AliITSHandleDaSSD", "Error CalculatePedestal(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
273 return kFALSE;
274 }
275 for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
276 if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
277 if (!(signal = strip->GetSignal())) {
278 Error("AliITSHandleDaSSD", "Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
279 return kFALSE;
280 }
281 pedestal = 0.0f;
282 ovev = 0l;
283 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
284 if (SignalOutOfRange(signal[ev])) ovev += 1;
285// else pedestal += signal[ev];
286 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
287 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
288// if ((Long_t n = strip->GetEventsNumber() - ovev)) pedestal /= static_cast<Float_t>(n);
289// else return kFALSE;
290 strip->SetPedestal(pedestal);
291 }
292 }
293 return kTRUE;
294}
295
296
297
298Bool_t AliITSHandleDaSSD::CalculateNoise()
299{
223dda26 300// Calculates Noise
f67db810 301 AliITSChannelDaSSD *strip;
302 Short_t *signal;
303 Float_t noise;
304 Long_t ovev, n;
305 if (!fModules) return kFALSE;
306 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
307 if (!fModules[modind]) {
308 Error("AliITSHandleDaSSD", "Error CalculateNoise(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
309 return kFALSE;
310 }
311 for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
312 if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
313 if (!(signal = strip->GetSignal())) {
314 Error("AliITSHandleDaSSD", "Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
315 return kFALSE;
316 }
317 Double_t nsum = 0.0L;
318 ovev = 0l;
319 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
320 if (SignalOutOfRange(signal[ev])) ovev += 1;
321 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
322// else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal()), 2) - nsum) / static_cast<Double_t>(ev - ovev)
323// : pow((signal[ev] - strip->GetPedestal()), 2);
324 }
325// noise = sqrt(nsum);
326 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
327 else noise = AliITSChannelDaSSD::GetUndefinedValue();
328 strip->SetNoise(noise);
329 }
330 }
331 return kTRUE;
332}
333
334
335
336Bool_t AliITSHandleDaSSD::CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm)
337{
223dda26 338// Calculates CM
f67db810 339 AliITSChannelDaSSD *strip = NULL;
340 Short_t *signal;
341 Long_t ovstr, evn, n;
342 if ((stripind + AliITSModuleDaSSD::GetStripsPerChip()) > fModules[modind]->GetNumberOfStrips()) return kFALSE;
343 if (!(strip = fModules[modind]->GetStrip(stripind))) return kFALSE;
344 evn = fModules[modind]->GetStrip(stripind)->GetEventsNumber();
345 for (Long_t ev = 0; ev < evn; ev++) {
346 Double_t cmsum = 0.0L;
347 ovstr = 0l;
348 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
349 if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
350 if (!(signal = strip->GetSignal())) {
351 Error("AliITSHandleDaSSD", "Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
352 return kFALSE;
353 }
354 if (SignalOutOfRange(signal[ev])) ovstr += 1;
355 else cmsum += (signal[ev] - strip->GetPedestal());
356 }
357 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm[ev] = cmsum / (Float_t)(n);
358 else cm[ev] = 0.0;
359 }
360 return kTRUE;
361}
362
363
364
365Bool_t AliITSHandleDaSSD::CalculateNoiseCM()
366{
223dda26 367// Calculates Noise with CM correction
f67db810 368 Short_t *signal;
369 AliITSChannelDaSSD *strip = NULL;
370 Float_t noise, *cm = NULL;
371 Long_t ovev, n;
372 if (!fModules) return kFALSE;
373 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
374 if (!fModules[modind]) {
375 Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD", modind);
376 return kFALSE;
377 }
378 for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
379 if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
380 if (!(signal = strip->GetSignal())) {
381 Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
382 return kFALSE;
383 }
384 if (!(strind % AliITSModuleDaSSD::GetStripsPerChip())) {
385 if (!cm) {
00e18e8f 386 cm = new (nothrow) Float_t [strip->GetEventsNumber()];
387 if (!cm) {
f67db810 388 Warning("AliITSHandleDaSSD", "Noise calculation with common mode correction failed becouse of memory allocation problems.");
389 return kFALSE;
00e18e8f 390 }
f67db810 391 }
392// calculate cm;
393 if (!CalculateCM(modind, strind, cm)) return kFALSE;
394 }
395// calculate noise;
396 Double_t nsum = 0.0L;
397 ovev = 0l;
398 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
399 if (SignalOutOfRange(signal[ev])) ovev += 1;
400 else nsum += pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
401// else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2) - nsum) / static_cast<Double_t>(ev - ovev)
402// : pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
403 }
404// noise = sqrt(nsum);
405 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
406 else noise = AliITSChannelDaSSD::GetUndefinedValue();
407 strip->SetNoise(noise);
408 }
409 }
410 if (cm) delete [] cm;
411 return kTRUE;
412}
413
414
415
416TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
223dda26 417{
418// Fill in the array for OCDB
f67db810 419 TObjArray *ldcc;
420 if (!fModules) return NULL;
421 ldcc = new TObjArray(fNumberOfModules, 0);
422 for (Int_t i = 0; i < fNumberOfModules; i++) {
423 if (!fModules[i]) {
424 delete ldcc;
425 return NULL;
426 }
223dda26 427 ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
f67db810 428 }
429 ldcc->Compress();
430 return ldcc;
431}
432
433
434Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
435{
223dda26 436// Save Calibration data locally
f67db810 437 ostringstream dadatafilename;
438 TObjArray *ldcc;
439 if (!fModules) return kFALSE;
440 ldcc = new TObjArray(fNumberOfModules, 0);
441 for (Int_t i = 0; i < fNumberOfModules; i++) {
442 if (!fModules[i]) {
443 delete ldcc;
444 return kFALSE;
445 }
223dda26 446 ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
f67db810 447 }
448 ldcc->Compress();
449 dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
450 dafname = dadatafilename.str();
451 TFile *fileRun = new TFile (dadatafilename.str().data(),"RECREATE");
452 if (fileRun->IsZombie()) {
453 Error("AliITSHandleDaSSD", "SaveCalibrationSSDLDC() error open file %s", dadatafilename.str().data());
454 ldcc->Delete();
455 delete fileRun;
456 return kFALSE;
457 }
458 fileRun->WriteTObject(ldcc);
459 fileRun->Close();
460 ldcc->Delete();
461 delete fileRun;
462 return kTRUE;
463}