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