Coding conventions
[u/mrichter/AliRoot.git] / ITS / AliITSHandleDaSSD.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 ///
20 /// This class provides ITS SSD data handling
21 /// used by DA. 
22 ///
23 ///////////////////////////////////////////////////////////////////////////////
24
25 #include <Riostream.h> 
26 #include "AliITSHandleDaSSD.h"
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"
37
38
39 ClassImp(AliITSHandleDaSSD)
40
41 using namespace std;
42
43
44 AliITSHandleDaSSD::AliITSHandleDaSSD() :
45   fNumberOfModules(0),
46   fModules(NULL),
47   fLdcId(0),
48   fRunId(0)
49 {
50 // Default constructor
51 }
52
53
54 AliITSHandleDaSSD::AliITSHandleDaSSD(const Int_t numberofmodules) :
55   fNumberOfModules(0),
56   fModules(NULL),
57   fLdcId(0),
58   fRunId(0)
59 {
60 // Constructor allocates memory for AliITSModuleDaSSD objects
61   if (numberofmodules > fgkNumberOfSSDModules) 
62       cout << "ALICE ITS SSD contains " <<  fgkNumberOfSSDModules << "modules!"<< endl;
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);
69      fNumberOfModules = 0;
70      fModules = NULL;
71   }
72 }
73
74
75 AliITSHandleDaSSD::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
88 AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
89 {
90 // assignment operator
91
92   Fatal("operator =", "assignment operator not implemented");
93   return *this;
94 }
95
96
97 AliITSHandleDaSSD::~AliITSHandleDaSSD()
98 {
99 // Default destructor 
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
112 AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
113 {
114 // Retrieve AliITSModuleDaSSD object from the array
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
129 AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
130 {
131 // Retrieve AliITSChannalDaSSD object from the array
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
146 Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
147
148 // Assign array element with AliITSModuleDaSSD object
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
159 Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
160 {
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);
172      fNumberOfModules = 0;
173      fModules = NULL;
174   }
175   return kFALSE;
176 }
177
178
179 Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
180 {
181 // Reads raw data from file
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   }
193   rawreaderdate->SelectEvents(-1);
194   while (rawreaderdate->NextEvent()) {
195     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
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
239 Bool_t AliITSHandleDaSSD::RelocateModules()
240 {
241 // Relocate memory for AliITSModuleDaSSD object array
242   Int_t         nm = 0;
243   AliITSModuleDaSSD **marray = NULL;
244   for (Int_t modind = 0; modind < fNumberOfModules; modind++)
245     if (fModules[modind]) nm += 1;
246   if (nm == fNumberOfModules) return kTRUE;
247   marray = new (nothrow) AliITSModuleDaSSD* [nm];
248   if (!marray) {
249     Error("AliITSHandleDaSSD", "Error relocating memory for %i AliITSModuleDaSSD* objects!", nm);
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
262 Bool_t AliITSHandleDaSSD::CalculatePedestal()
263 {
264 // Calculates Pedestal
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
298 Bool_t AliITSHandleDaSSD::CalculateNoise()
299 {
300 // Calculates Noise
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
336 Bool_t AliITSHandleDaSSD::CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm)
337 {
338 // Calculates CM
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
365 Bool_t  AliITSHandleDaSSD::CalculateNoiseCM()
366 {
367 // Calculates Noise with CM correction
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) {
386           try { 
387             cm = new Float_t [strip->GetEventsNumber()];  }
388           catch (bad_alloc&) {
389             Warning("AliITSHandleDaSSD", "Noise calculation with common mode correction failed becouse of memory allocation problems.");
390             return kFALSE; 
391           }  
392         }
393 // calculate cm;
394         if (!CalculateCM(modind, strind, cm)) return kFALSE;
395       }
396 // calculate noise;     
397       Double_t nsum = 0.0L;
398       ovev = 0l;
399       for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
400         if (SignalOutOfRange(signal[ev])) ovev += 1;
401         else nsum += pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
402 //      else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2) - nsum) / static_cast<Double_t>(ev - ovev)
403 //                                : pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
404       } 
405 //      noise =  sqrt(nsum);
406       if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
407       else  noise = AliITSChannelDaSSD::GetUndefinedValue();
408       strip->SetNoise(noise);
409       }
410     }
411   if (cm) delete [] cm;
412   return kTRUE;
413 }
414
415
416
417 TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
418 {
419 // Fill in the array for OCDB 
420   TObjArray *ldcc;
421   if (!fModules) return NULL;
422   ldcc = new TObjArray(fNumberOfModules, 0);
423   for (Int_t i = 0; i < fNumberOfModules; i++) {
424     if (!fModules[i]) {
425       delete ldcc;
426       return NULL;
427     }
428     ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
429   }
430   ldcc->Compress();
431   return ldcc;
432 }
433
434
435 Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
436 {
437 // Save Calibration data locally
438   ostringstream   dadatafilename;
439   TObjArray      *ldcc;
440   if (!fModules) return kFALSE;
441   ldcc = new TObjArray(fNumberOfModules, 0);
442   for (Int_t i = 0; i < fNumberOfModules; i++) {
443     if (!fModules[i]) {
444       delete ldcc;
445       return kFALSE;
446     }
447     ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
448   }
449   ldcc->Compress();
450   dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
451   dafname = dadatafilename.str();
452   TFile *fileRun = new TFile (dadatafilename.str().data(),"RECREATE");
453   if (fileRun->IsZombie()) {
454     Error("AliITSHandleDaSSD", "SaveCalibrationSSDLDC() error open file %s", dadatafilename.str().data());
455     ldcc->Delete();
456     delete fileRun;
457     return kFALSE;
458   }
459   fileRun->WriteTObject(ldcc);
460   fileRun->Close();
461   ldcc->Delete();
462   delete fileRun;
463   return kTRUE;
464 }