]>
Commit | Line | Data |
---|---|---|
170c35f1 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, 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 | ||
0bc7827a | 18 | //////////////////////////////////////////////////////////////////////////// |
19 | // // | |
20 | // Example: fill pedestal with Gaussian noise // | |
21 | // // | |
22 | // AliTRDCalibPadStatus ped; // | |
23 | // ped.TestEvent(numberofevent); // | |
24 | // // | |
25 | // // Method without histo // | |
26 | // ped.Analyse(); // | |
27 | // // | |
28 | // // Create the histo of the AliTRDCalROC // | |
29 | // TH2F * histo2dm = ped.GetCalRocMean(0,kFALSE)->MakeHisto2D(); // | |
30 | // histo2dm->Scale(10.0); // | |
31 | // TH1F * histo1dm = ped.GetCalRocMean(0,kFALSE)->MakeHisto1D(); // | |
32 | // histo1dm->Scale(10.0); // | |
33 | // TH2F * histo2ds = ped.GetCalRocSquares(0,kFALSE)->MakeHisto2D(); // | |
34 | // histo2ds->Scale(10.0); // | |
35 | // TH1F * histo1ds = ped.GetCalRocSquares(0,kFALSE)->MakeHisto1D(); // | |
36 | // histo1ds->Scale(10.0) // | |
37 | // // | |
38 | // // Draw output // | |
39 | // TCanvas* c1 = new TCanvas; // | |
40 | // c1->Divide(2,2); // | |
41 | // c1->cd(1); // | |
42 | // histo2dm->Draw("colz"); // | |
43 | // c1->cd(2); // | |
44 | // histo1dm->Draw(); // | |
45 | // c1->cd(3); // | |
46 | // histo2ds->Draw("colz"); // | |
47 | // c1->cd(4); // | |
48 | // histo1ds->Draw(); // | |
49 | // // | |
50 | // // Method with histo // | |
51 | // ped.AnalyseHisto(); // | |
52 | // // | |
53 | // // Take the histo // | |
54 | // TH1F *histo = ped.GetHisto(31); // | |
55 | // histo->SetEntries(1); // | |
56 | // histo->Draw(); // | |
1785640c | 57 | // |
58 | // Authors: | |
59 | // R. Bailhache (R.Bailhache@gsi.de, rbailhache@ikf.uni-frankfurt.de) | |
60 | // J. Book (jbook@ikf.uni-frankfurt.de) | |
61 | // // | |
0bc7827a | 62 | //////////////////////////////////////////////////////////////////////////// |
170c35f1 | 63 | |
6bbdc11a | 64 | |
170c35f1 | 65 | //Root includes |
66 | #include <TObjArray.h> | |
170c35f1 | 67 | #include <TH2F.h> |
68 | #include <TString.h> | |
69 | #include <TMath.h> | |
170c35f1 | 70 | #include <TRandom.h> |
6bbdc11a | 71 | |
72 | //#include <TRandom.h> | |
170c35f1 | 73 | #include <TDirectory.h> |
74 | #include <TFile.h> | |
f162af62 | 75 | |
170c35f1 | 76 | //AliRoot includes |
3a0f6479 | 77 | #include <AliMathBase.h> |
170c35f1 | 78 | #include "AliRawReader.h" |
79 | #include "AliRawReaderRoot.h" | |
80 | #include "AliRawReaderDate.h" | |
f162af62 | 81 | |
3a0f6479 | 82 | //header file |
e4db522f | 83 | #include "AliLog.h" |
3a0f6479 | 84 | #include "AliTRDCalibPadStatus.h" |
5e64ce0d | 85 | #include "AliTRDrawStreamBase.h" |
f162af62 | 86 | #include "AliTRDgeometry.h" |
3a0f6479 | 87 | #include "AliTRDCommonParam.h" |
170c35f1 | 88 | #include "./Cal/AliTRDCalROC.h" |
89 | #include "./Cal/AliTRDCalPadStatus.h" | |
289cc637 | 90 | #include "./Cal/AliTRDCalDet.h" |
91 | #include "./Cal/AliTRDCalPad.h" | |
170c35f1 | 92 | #include "./Cal/AliTRDCalSingleChamberStatus.h" |
170c35f1 | 93 | |
1785640c | 94 | #include "AliTRDrawFastStream.h" |
95 | #include "AliTRDdigitsManager.h" | |
96 | #include "AliTRDdigitsParam.h" | |
97 | #include "AliTRDSignalIndex.h" | |
98 | #include "AliTRDarraySignal.h" | |
99 | #include "AliTRDarrayADC.h" | |
100 | #include "AliTRDfeeParam.h" | |
101 | ||
fd50bb14 | 102 | #include "AliTRDrawStream.h" |
103 | ||
170c35f1 | 104 | #ifdef ALI_DATE |
105 | #include "event.h" | |
106 | #endif | |
107 | ||
170c35f1 | 108 | ClassImp(AliTRDCalibPadStatus) /*FOLD00*/ |
109 | ||
110 | //_____________________________________________________________________ | |
111 | AliTRDCalibPadStatus::AliTRDCalibPadStatus() : /*FOLD00*/ | |
112 | TObject(), | |
f162af62 | 113 | fGeo(0), |
170c35f1 | 114 | fAdcMin(0), |
d95484e4 | 115 | fAdcMax(21), |
170c35f1 | 116 | fDetector(-1), |
cf46274d | 117 | fNumberOfTimeBins(0), |
170c35f1 | 118 | fCalRocArrayMean(540), |
119 | fCalRocArrayRMS(540), | |
e4db522f | 120 | fCalRocArrayMeand(540), |
121 | fCalRocArrayRMSd(540), | |
122 | fHistoArray(540) | |
170c35f1 | 123 | { |
124 | // | |
125 | // default constructor | |
126 | // | |
f162af62 | 127 | |
128 | fGeo = new AliTRDgeometry(); | |
129 | ||
170c35f1 | 130 | } |
131 | ||
132 | //_____________________________________________________________________ | |
133 | AliTRDCalibPadStatus::AliTRDCalibPadStatus(const AliTRDCalibPadStatus &ped) : /*FOLD00*/ | |
134 | TObject(ped), | |
f162af62 | 135 | fGeo(0), |
170c35f1 | 136 | fAdcMin(ped.GetAdcMin()), |
137 | fAdcMax(ped.GetAdcMax()), | |
138 | fDetector(ped.fDetector), | |
cf46274d | 139 | fNumberOfTimeBins(ped.fNumberOfTimeBins), |
170c35f1 | 140 | fCalRocArrayMean(540), |
141 | fCalRocArrayRMS(540), | |
e4db522f | 142 | fCalRocArrayMeand(540), |
143 | fCalRocArrayRMSd(540), | |
144 | fHistoArray(540) | |
170c35f1 | 145 | { |
146 | // | |
147 | // copy constructor | |
148 | // | |
149 | for (Int_t idet = 0; idet < 540; idet++){ | |
170c35f1 | 150 | const AliTRDCalROC *calRocMean = (AliTRDCalROC*)ped.fCalRocArrayMean.UncheckedAt(idet); |
151 | const AliTRDCalROC *calRocRMS = (AliTRDCalROC*)ped.fCalRocArrayRMS.UncheckedAt(idet); | |
e4db522f | 152 | const AliTRDCalROC *calRocMeand = (AliTRDCalROC*)ped.fCalRocArrayMeand.UncheckedAt(idet); |
153 | const AliTRDCalROC *calRocRMSd = (AliTRDCalROC*)ped.fCalRocArrayRMSd.UncheckedAt(idet); | |
170c35f1 | 154 | const TH2F *hped = (TH2F*)ped.fHistoArray.UncheckedAt(idet); |
155 | ||
170c35f1 | 156 | if ( calRocMean != 0x0 ) fCalRocArrayMean.AddAt(new AliTRDCalROC(*calRocMean), idet); |
157 | if ( calRocRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTRDCalROC(*calRocRMS), idet); | |
158 | ||
e4db522f | 159 | if ( calRocMeand != 0x0 ) fCalRocArrayMeand.AddAt(new AliTRDCalROC(*calRocMeand), idet); |
160 | if ( calRocRMSd != 0x0 ) fCalRocArrayRMSd.AddAt(new AliTRDCalROC(*calRocRMSd), idet); | |
161 | ||
170c35f1 | 162 | if ( hped != 0x0 ){ |
163 | TH2F *hNew = new TH2F(*hped); | |
164 | hNew->SetDirectory(0); | |
165 | fHistoArray.AddAt(hNew,idet); | |
166 | } | |
167 | ||
168 | } | |
f162af62 | 169 | if (fGeo) { |
170 | delete fGeo; | |
171 | } | |
172 | fGeo = new AliTRDgeometry(); | |
170c35f1 | 173 | } |
f162af62 | 174 | |
170c35f1 | 175 | //_____________________________________________________________________ |
176 | AliTRDCalibPadStatus& AliTRDCalibPadStatus::operator = (const AliTRDCalibPadStatus &source) | |
177 | { | |
178 | // | |
179 | // assignment operator | |
180 | // | |
181 | if (&source == this) return *this; | |
182 | new (this) AliTRDCalibPadStatus(source); | |
183 | ||
184 | return *this; | |
185 | } | |
186 | //_____________________________________________________________________ | |
187 | AliTRDCalibPadStatus::~AliTRDCalibPadStatus() /*FOLD00*/ | |
188 | { | |
189 | // | |
190 | // destructor | |
191 | // | |
1ca79a00 | 192 | fCalRocArrayMean.Delete(); |
193 | fCalRocArrayRMS.Delete(); | |
194 | fCalRocArrayMeand.Delete(); | |
195 | fCalRocArrayRMSd.Delete(); | |
196 | fHistoArray.Delete(); | |
f162af62 | 197 | if (fGeo) { |
198 | delete fGeo; | |
199 | } | |
170c35f1 | 200 | } |
8799e123 | 201 | //_____________________________________________________________________ |
202 | void AliTRDCalibPadStatus::Destroy() | |
203 | { | |
204 | // | |
205 | // Destroy | |
206 | // | |
207 | fCalRocArrayMean.Delete(); | |
208 | fCalRocArrayRMS.Delete(); | |
209 | fCalRocArrayMeand.Delete(); | |
210 | fCalRocArrayRMSd.Delete(); | |
211 | fHistoArray.Delete(); | |
212 | } | |
170c35f1 | 213 | //_____________________________________________________________________ |
214 | Int_t AliTRDCalibPadStatus::UpdateHisto(const Int_t icdet, /*FOLD00*/ | |
e4db522f | 215 | const Int_t icRow, |
216 | const Int_t icCol, | |
217 | const Int_t csignal, | |
218 | const Int_t crowMax, | |
219 | const Int_t ccold, | |
220 | const Int_t icMcm) | |
170c35f1 | 221 | { |
e4db522f | 222 | // |
223 | // Signal filling methode | |
224 | // | |
170c35f1 | 225 | Int_t nbchannel = icRow+icCol*crowMax; |
e4db522f | 226 | |
227 | // now the case of double read channel | |
228 | if(ccold > 0){ | |
229 | nbchannel = (((ccold-1)*8+ icMcm)*crowMax+icRow)+144*crowMax; | |
230 | //printf("nbchannel %d, ccold %d, icMcm %d, crowMax %d, icRow %d\n",nbchannel,ccold,icMcm,crowMax,icRow); | |
231 | } | |
170c35f1 | 232 | |
233 | // fast filling methode. | |
234 | // Attention: the entry counter of the histogram is not increased | |
235 | // this means that e.g. the colz draw option gives an empty plot | |
1785640c | 236 | |
170c35f1 | 237 | Int_t bin = 0; |
1785640c | 238 | |
d95484e4 | 239 | if ( !(((Int_t)csignal>=fAdcMax ) || ((Int_t)csignal<fAdcMin)) ) |
170c35f1 | 240 | bin = (nbchannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1); |
1785640c | 241 | |
d95484e4 | 242 | //GetHisto(icdet,kTRUE)->Fill(csignal,nbchannel); |
170c35f1 | 243 | |
244 | GetHisto(icdet,kTRUE)->GetArray()[bin]++; | |
245 | ||
246 | return 0; | |
247 | } | |
248 | //_____________________________________________________________________ | |
1785640c | 249 | Int_t AliTRDCalibPadStatus::UpdateHisto2(const Int_t icdet, /*FOLD00*/ |
250 | const Int_t icRow, | |
251 | const Int_t icCol, | |
252 | const Int_t csignal, | |
253 | const Int_t crowMax, | |
254 | const Int_t ccold, | |
255 | const Int_t icMcm, | |
256 | const Int_t icRob | |
257 | ) | |
258 | { | |
259 | // | |
260 | // Signal filling methode | |
261 | // | |
262 | Int_t nbchannel = icRow+icCol*crowMax; | |
263 | Int_t mCm = icMcm%4; | |
264 | Int_t rOb = icRob%2; | |
265 | ||
266 | // now the case of double read channel | |
267 | if(ccold > 0){ | |
268 | nbchannel = (((ccold-1)*8+ (mCm+rOb*4))*crowMax+icRow)+144*crowMax; | |
269 | //printf("nbchannel %d, ccold %d, icMcm %d, crowMax %d, icRow %d\n",nbchannel,ccold,icMcm,crowMax,icRow); | |
270 | } | |
271 | ||
272 | // fast filling methode. | |
273 | // Attention: the entry counter of the histogram is not increased | |
274 | // this means that e.g. the colz draw option gives an empty plot | |
275 | ||
276 | Int_t bin = 0; | |
277 | ||
278 | if ( !(((Int_t)csignal>=fAdcMax ) || ((Int_t)csignal<fAdcMin)) ) | |
279 | bin = (nbchannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1); | |
280 | ||
281 | //GetHisto(icdet,kTRUE)->Fill(csignal,nbchannel); | |
282 | ||
283 | GetHisto(icdet,kTRUE)->GetArray()[bin]++; | |
284 | ||
285 | return 0; | |
286 | } | |
287 | //_____________________________________________________________________ | |
5e64ce0d | 288 | Int_t AliTRDCalibPadStatus::ProcessEvent(AliTRDrawStreamBase *rawStream, Bool_t nocheck) |
170c35f1 | 289 | { |
290 | // | |
e4db522f | 291 | // Event Processing loop - AliTRDRawStreamCosmic |
3a0f6479 | 292 | // 0 time bin problem or zero suppression |
293 | // 1 no input | |
294 | // 2 input | |
1785640c | 295 | // |
296 | ||
297 | // | |
8799e123 | 298 | // Raw version number: |
299 | // [3,31] non zero suppressed | |
300 | // 2,4 and [32,63] zero suppressed | |
301 | // | |
170c35f1 | 302 | |
3a0f6479 | 303 | Int_t withInput = 1; |
170c35f1 | 304 | |
413153cb | 305 | rawStream->SetSharedPadReadout(kTRUE); |
e4db522f | 306 | |
cf46274d | 307 | if(!nocheck) { |
8799e123 | 308 | |
309 | // Check the raw version and if all have the same number of timebins. | |
310 | ||
cf46274d | 311 | while (rawStream->Next()) { |
8799e123 | 312 | |
cf46274d | 313 | Int_t rawversion = rawStream->GetRawVersion(); // current raw version |
8799e123 | 314 | //printf("Raw version is %d\n",rawversion); |
315 | ||
316 | // Could eventually change, have to check with time | |
317 | if((rawversion < 3) || (rawversion > 31)) { | |
e4db522f | 318 | AliInfo(Form("this is not no-zero-suppressed data, the version is %d",rawversion)); |
319 | return 0; | |
320 | } | |
cf46274d | 321 | Int_t idetector = rawStream->GetDet(); // current detector |
322 | Int_t iRow = rawStream->GetRow(); // current row | |
323 | Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax | |
324 | Int_t iCol = rawStream->GetCol(); // current col | |
d95484e4 | 325 | Int_t iADC = 21-rawStream->GetADC(); // current ADC |
8799e123 | 326 | |
327 | // It goes in the opposite direction | |
e4db522f | 328 | Int_t col = 0; |
329 | if(iADC == 1) col = 1; | |
330 | else { | |
331 | col = TMath::Max(0,(Int_t)(iADC-19)); | |
332 | if(col > 0) col++; | |
333 | } | |
334 | Int_t mcm = (Int_t)(iCol/18); // current group of 18 col pads | |
335 | if(col > 1) mcm -= 1; | |
336 | if(col ==1) mcm += 1; | |
337 | ||
8799e123 | 338 | // printf to check |
e4db522f | 339 | //Bool_t shared = rawStream->IsCurrentPadShared(); |
340 | //printf("ADC %d, iCol %d, col %d, mcm %d, shared %d\n",iADC,iCol,col,mcm,(Int_t)shared); | |
341 | ||
8799e123 | 342 | // Take the signal |
cf46274d | 343 | Int_t *signal = rawStream->GetSignals(); // current ADC signal |
344 | Int_t nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data | |
345 | ||
e4db522f | 346 | if((fDetector != -1) && (nbtimebin != fNumberOfTimeBins)) { |
347 | AliInfo(Form("the number of time bins is %d, is different from the previous one %d",nbtimebin,fNumberOfTimeBins)); | |
348 | return 0; | |
349 | } | |
cf46274d | 350 | fNumberOfTimeBins = nbtimebin; |
8799e123 | 351 | fDetector = idetector; |
352 | ||
d95484e4 | 353 | for(Int_t k = 0; k < fNumberOfTimeBins; k++){ |
1785640c | 354 | if(signal[k]>0 && iCol != -1) UpdateHisto(idetector,iRow,iCol,signal[k],iRowMax,col,mcm); |
cf46274d | 355 | } |
356 | ||
3a0f6479 | 357 | withInput = 2; |
cf46274d | 358 | } |
359 | } | |
360 | else { | |
8799e123 | 361 | |
cf46274d | 362 | while (rawStream->Next()) { |
8799e123 | 363 | |
cf46274d | 364 | Int_t idetector = rawStream->GetDet(); // current detector |
365 | Int_t iRow = rawStream->GetRow(); // current row | |
366 | Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax | |
367 | Int_t iCol = rawStream->GetCol(); // current col | |
e4db522f | 368 | Int_t iADC = 21-rawStream->GetADC(); // current ADC |
8799e123 | 369 | |
370 | // It goes in the opposite direction | |
e4db522f | 371 | Int_t col = 0; |
372 | if(iADC == 1) col = 1; | |
373 | else { | |
374 | col = TMath::Max(0,(Int_t)(iADC-19)); | |
375 | if(col > 0) col++; | |
376 | } | |
377 | Int_t mcm = (Int_t)(iCol/18); // current group of 18 col pads | |
378 | if(col > 1) mcm -= 1; | |
379 | if(col ==1) mcm += 1; | |
380 | ||
8799e123 | 381 | // Take the signal |
cf46274d | 382 | Int_t *signal = rawStream->GetSignals(); // current ADC signal |
383 | Int_t nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data | |
384 | ||
d95484e4 | 385 | |
162a3e73 | 386 | //printf("det %d, row %d, signal[0] %d, signal[1] %d, signal [2] %d\n", idetector, iRow, signal[0], signal[1], signal[2]); |
387 | ||
d95484e4 | 388 | for(Int_t k = 0; k < nbtimebin; k++){ |
1785640c | 389 | if(signal[k]>0 && iCol != -1) { |
d95484e4 | 390 | UpdateHisto(idetector,iRow,iCol,signal[k],iRowMax,col,mcm); |
162a3e73 | 391 | //printf("Update with det %d, row %d, col %d, signal %d, rowmax %d, col %d, mcm %d\n",idetector,iRow,iCol,signal[n],iRowMax,col,mcm); |
392 | } | |
cf46274d | 393 | } |
394 | ||
3a0f6479 | 395 | withInput = 2; |
170c35f1 | 396 | } |
170c35f1 | 397 | } |
398 | ||
399 | return withInput; | |
400 | } | |
401 | //_____________________________________________________________________ | |
3a0f6479 | 402 | Int_t AliTRDCalibPadStatus::ProcessEvent(AliRawReader *rawReader, Bool_t nocheck) |
170c35f1 | 403 | { |
404 | // | |
405 | // Event processing loop - AliRawReader | |
406 | // | |
407 | ||
5e64ce0d | 408 | Int_t result; |
409 | ||
170c35f1 | 410 | rawReader->Select("TRD"); |
5e64ce0d | 411 | |
412 | AliTRDrawStreamBase *pstream = AliTRDrawStreamBase::GetRawStream(rawReader); | |
413 | ||
414 | result = ProcessEvent(pstream, nocheck); | |
415 | ||
416 | delete pstream; | |
170c35f1 | 417 | |
5e64ce0d | 418 | return result; |
170c35f1 | 419 | } |
3a0f6479 | 420 | |
170c35f1 | 421 | //_________________________________________________________________________ |
3a0f6479 | 422 | Int_t AliTRDCalibPadStatus::ProcessEvent( |
170c35f1 | 423 | #ifdef ALI_DATE |
6bbdc11a | 424 | const eventHeaderStruct *event, |
cf46274d | 425 | Bool_t nocheck |
170c35f1 | 426 | #else |
6bbdc11a | 427 | const eventHeaderStruct* /*event*/, |
cf46274d | 428 | Bool_t /*nocheck*/ |
170c35f1 | 429 | |
430 | #endif | |
3a433fc4 | 431 | ) |
170c35f1 | 432 | { |
433 | // | |
434 | // process date event | |
435 | // | |
436 | #ifdef ALI_DATE | |
437 | AliRawReader *rawReader = new AliRawReaderDate((void*)event); | |
cf46274d | 438 | Bool_t result=ProcessEvent(rawReader, nocheck); |
170c35f1 | 439 | delete rawReader; |
440 | return result; | |
441 | #else | |
442 | Fatal("AliTRDCalibPadStatus", "this class was compiled without DATE"); | |
443 | return 0; | |
444 | #endif | |
445 | ||
446 | } | |
3a0f6479 | 447 | |
1785640c | 448 | //_____________________________________________________________________ |
449 | Int_t AliTRDCalibPadStatus::ProcessEvent2(AliRawReader *rawReader) | |
450 | { | |
451 | // | |
452 | // Event Processing loop - AliTRDRawStreamCosmic | |
453 | // 0 time bin problem or zero suppression | |
454 | // 1 no input | |
455 | // 2 input | |
456 | // Raw version number: | |
457 | // [3,31] non zero suppressed | |
458 | // 2,4 and [32,63] zero suppressed | |
459 | // | |
460 | ||
461 | Int_t withInput = 1; | |
462 | ||
463 | AliTRDrawFastStream *rawStream = new AliTRDrawFastStream(rawReader); | |
09ea3770 | 464 | rawStream->SetNoErrorWarning(); |
1785640c | 465 | rawStream->SetSharedPadReadout(kTRUE); |
466 | ||
467 | AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE); | |
468 | digitsManager->CreateArrays(); | |
469 | ||
470 | AliTRDfeeParam *feeParam = AliTRDfeeParam::Instance(); | |
471 | ||
472 | Int_t det = 0; | |
473 | while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { //idetector | |
474 | if (digitsManager->GetIndexes(det)->HasEntry()) {//QA | |
475 | // printf("there is ADC data on this chamber!\n"); | |
476 | ||
477 | AliTRDarrayADC *digits = (AliTRDarrayADC *) digitsManager->GetDigits(det); //mod | |
478 | if (digits->HasData()) { //array | |
479 | ||
480 | AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det); | |
481 | if (indexes->IsAllocated() == kFALSE) { | |
482 | AliError("Indexes do not exist!"); | |
483 | break; | |
484 | } | |
485 | Int_t iRow = 0; | |
486 | Int_t iCol = 0; | |
487 | indexes->ResetCounters(); | |
488 | ||
489 | while (indexes->NextRCIndex(iRow, iCol)) { //column,row | |
490 | ||
491 | ||
492 | AliTRDdigitsParam *digitParam = (AliTRDdigitsParam *)digitsManager->GetDigitsParam(); | |
493 | ||
494 | Int_t mcm = 0; // MCM from AliTRDfeeParam | |
495 | Int_t rob = 0; // ROB from AliTRDfeeParam | |
496 | Int_t extCol = 0; // extended column from AliTRDfeeParam | |
497 | mcm = feeParam->GetMCMfromPad(iRow,iCol); | |
498 | rob = feeParam->GetROBfromPad(iRow,iCol); | |
499 | ||
500 | Int_t idetector = det; // current detector | |
501 | Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax | |
502 | ||
503 | Int_t adc = 20 - (iCol%18) -1; // current adc | |
504 | Int_t col = 0; // col!=0 ->Shared Pad | |
505 | extCol = feeParam->GetExtendedPadColFromADC(rob,mcm,adc); | |
506 | //printf(" iCol %d iRow %d iRowMax %d rob %d mcm %d adc %d extCol %d\n",iCol,iRow,iRowMax,rob,mcm,adc,extCol); | |
507 | ||
508 | // Signal for regular pads | |
a0446ff1 | 509 | Int_t nbtimebin = digitParam->GetNTimeBins(idetector); // number of time bins read from data |
1785640c | 510 | for(Int_t k = 0; k < nbtimebin; k++){ |
511 | Short_t signal = 0; | |
512 | signal = digits->GetData(iRow,iCol,k); | |
513 | ||
514 | if(signal>0) { | |
515 | UpdateHisto2(idetector,iRow,iCol,signal,iRowMax,col,mcm,rob); | |
516 | } | |
517 | } | |
518 | ||
519 | ||
520 | ||
521 | if((adc==3-1 || adc==20-1 || adc==19-1) && (iCol > 1 && iCol <142) /* && fSharedPadsOn*/ ) { //SHARED PADS | |
522 | ||
523 | switch(adc) { | |
524 | case 2: | |
525 | adc = 20; //shared Pad adc | |
526 | mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm | |
527 | col = 1; | |
528 | break; | |
529 | case 19: | |
530 | adc = 1; //shared Pad adc | |
531 | mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm | |
532 | col = 2; | |
533 | break; | |
534 | case 18: | |
535 | adc = 0; //shared Pad adc | |
536 | mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm | |
537 | col = 3; | |
538 | break; | |
539 | } | |
540 | rob = feeParam->GetROBfromSharedPad(iRow,iCol); //shared Pad rob | |
541 | ||
542 | ||
543 | extCol = feeParam->GetExtendedPadColFromADC(rob,mcm,adc); //extended pad col via the shared pad rob,mcm and adc | |
544 | ||
545 | //printf("SHARED PAD --- iCol %d iRow %d rob %d mcm %d adc %d extCol %d col %d\n",iCol,iRow,rob,mcm,adc,extCol,col); | |
546 | for(Int_t k = 0; k < nbtimebin; k++){ | |
547 | Short_t signal = 0; | |
548 | signal = digits->GetDataByAdcCol(iRow,extCol,k); | |
549 | ||
550 | if(signal>0) { | |
551 | UpdateHisto2(idetector,iRow,iCol,signal,iRowMax,col,mcm,rob); | |
552 | } | |
553 | } | |
554 | } //shared pads end | |
555 | ||
556 | ||
557 | withInput = 2; | |
558 | }//column,row | |
559 | ||
560 | }//array | |
561 | }//QA | |
562 | digitsManager->ClearArrays(det); | |
563 | }//idetector | |
564 | delete digitsManager; | |
565 | delete rawStream; | |
566 | return withInput; | |
567 | } | |
568 | ||
fd50bb14 | 569 | //_____________________________________________________________________ |
570 | ||
571 | Int_t AliTRDCalibPadStatus::ProcessEvent3(AliRawReader *rawReader) | |
572 | { | |
573 | // | |
574 | // RawReader = AliTRDrawStream (Jochen Klein) | |
575 | // | |
576 | // Event Processing loop - AliTRDRawStreamCosmic | |
577 | // 0 time bin problem or zero suppression | |
578 | // 1 no input | |
579 | // 2 input | |
580 | // Raw version number: | |
581 | // [3,31] non zero suppressed | |
582 | // 2,4 and [32,63] zero suppressed | |
583 | // | |
584 | ||
585 | ||
586 | ||
587 | Int_t withInput = 1; | |
588 | ||
589 | AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE); | |
590 | digitsManager->CreateArrays(); | |
591 | ||
592 | AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader); | |
593 | rawStream->SetDigitsManager(digitsManager); | |
594 | //rawStream->SetNoErrorWarning(); | |
595 | //rawStream->SetSharedPadReadout(kTRUE); | |
596 | ||
597 | AliTRDfeeParam *feeParam = AliTRDfeeParam::Instance(); | |
598 | ||
599 | Int_t det = 0; | |
600 | while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { //idetector | |
601 | if (digitsManager->GetIndexes(det)->HasEntry()) {//QA | |
602 | // printf("there is ADC data on this chamber!\n"); | |
603 | ||
604 | AliTRDarrayADC *digits = (AliTRDarrayADC *) digitsManager->GetDigits(det); //mod | |
605 | if (digits->HasData()) { //array | |
606 | ||
607 | AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det); | |
608 | if (indexes->IsAllocated() == kFALSE) { | |
609 | AliError("Indexes do not exist!"); | |
610 | break; | |
611 | } | |
612 | Int_t iRow = 0; | |
613 | Int_t iCol = 0; | |
614 | indexes->ResetCounters(); | |
615 | ||
616 | while (indexes->NextRCIndex(iRow, iCol)) { //column,row | |
617 | ||
618 | AliTRDdigitsParam *digitParam = (AliTRDdigitsParam *)digitsManager->GetDigitsParam(); | |
619 | ||
620 | Int_t mcm = 0; // MCM from AliTRDfeeParam | |
621 | Int_t rob = 0; // ROB from AliTRDfeeParam | |
622 | Int_t extCol = 0; // extended column from AliTRDfeeParam | |
623 | mcm = feeParam->GetMCMfromPad(iRow,iCol); | |
624 | rob = feeParam->GetROBfromPad(iRow,iCol); | |
625 | ||
626 | Int_t idetector = det; // current detector | |
627 | Int_t iRowMax = 16; // current rowmax | |
628 | if(GetStack(det) == 2) iRowMax = 12; | |
629 | ||
630 | Int_t adc = 20 - (iCol%18) -1; // current adc | |
631 | Int_t col = 0; // col!=0 ->Shared Pad | |
632 | extCol = feeParam->GetExtendedPadColFromADC(rob,mcm,adc); | |
633 | //printf(" iCol %d iRow %d iRowMax %d rob %d mcm %d adc %d extCol %d\n",iCol,iRow,iRowMax,rob,mcm,adc,extCol); | |
634 | ||
635 | // Signal for regular pads | |
636 | Int_t nbtimebin = digitParam->GetNTimeBins(idetector); // number of time bins read from data | |
637 | for(Int_t k = 0; k < nbtimebin; k++){ | |
638 | Short_t signal = 0; | |
639 | signal = digits->GetData(iRow,iCol,k); | |
640 | ||
641 | if(signal>0) { | |
642 | UpdateHisto2(idetector,iRow,iCol,signal,iRowMax,col,mcm,rob); | |
643 | } | |
644 | } | |
645 | ||
646 | ||
647 | ||
648 | if((adc==3-1 || adc==20-1 || adc==19-1) && (iCol > 1 && iCol <142) ) { //SHARED PADS | |
649 | ||
650 | switch(adc) { | |
651 | case 2: | |
652 | adc = 20; //shared Pad adc | |
653 | mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm | |
654 | col = 1; | |
655 | break; | |
656 | case 19: | |
657 | adc = 1; //shared Pad adc | |
658 | mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm | |
659 | col = 2; | |
660 | break; | |
661 | case 18: | |
662 | adc = 0; //shared Pad adc | |
663 | mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm | |
664 | col = 3; | |
665 | break; | |
666 | } | |
667 | rob = feeParam->GetROBfromSharedPad(iRow,iCol); //shared Pad rob | |
668 | ||
669 | ||
670 | extCol = feeParam->GetExtendedPadColFromADC(rob,mcm,adc); //extended pad col via the shared pad rob,mcm and adc | |
671 | ||
672 | //printf("SHARED PAD --- iCol %d iRow %d rob %d mcm %d adc %d extCol %d col %d\n",iCol,iRow,rob,mcm,adc,extCol,col); | |
673 | for(Int_t k = 0; k < nbtimebin; k++){ | |
674 | Short_t signal = 0; | |
675 | signal = digits->GetDataByAdcCol(iRow,extCol,k); | |
676 | ||
677 | if(signal>0) { | |
678 | UpdateHisto2(idetector,iRow,iCol,signal,iRowMax,col,mcm,rob); | |
679 | } | |
680 | } | |
681 | } //shared pads end | |
682 | ||
683 | ||
684 | withInput = 2; | |
685 | }//column,row | |
686 | ||
687 | }//array | |
688 | }//QA | |
689 | digitsManager->ClearArrays(det); | |
690 | }//idetector | |
691 | delete digitsManager; | |
692 | delete rawStream; | |
693 | return withInput; | |
694 | ||
695 | } | |
696 | ||
697 | ||
170c35f1 | 698 | //_____________________________________________________________________ |
d95484e4 | 699 | Bool_t AliTRDCalibPadStatus::TestEventHisto(Int_t nevent, Int_t sm, Int_t ch) /*FOLD00*/ |
170c35f1 | 700 | { |
701 | // | |
702 | // Test event loop | |
703 | // fill one oroc and one iroc with random gaus | |
704 | // | |
705 | ||
170c35f1 | 706 | gRandom->SetSeed(0); |
707 | ||
289cc637 | 708 | for (Int_t ism=sm; ism<sm+1; ism++){ |
d95484e4 | 709 | for (Int_t ich=ch; ich < ch+1; ich++){ |
170c35f1 | 710 | for (Int_t ipl=0; ipl < 6; ipl++){ |
f162af62 | 711 | for(Int_t irow = 0; irow < fGeo->GetRowMax(ipl,ich,ism); irow++){ |
712 | for(Int_t icol = 0; icol < fGeo->GetColMax(ipl); icol++){ | |
170c35f1 | 713 | for (Int_t iTimeBin=0; iTimeBin<(30*nevent); iTimeBin++){ |
d95484e4 | 714 | Int_t signal=TMath::Nint(gRandom->Gaus(10,1.5)); |
e4db522f | 715 | if ( signal>0 )UpdateHisto((ipl+ich*6+ism*6*5),irow,icol,signal,fGeo->GetRowMax(ipl,ich,ism),0,0); |
170c35f1 | 716 | } |
717 | } | |
718 | } | |
719 | } | |
720 | } | |
721 | } | |
722 | return kTRUE; | |
723 | } | |
3a0f6479 | 724 | |
170c35f1 | 725 | //_____________________________________________________________________ |
726 | TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, TObjArray *arr, /*FOLD00*/ | |
727 | Int_t nbinsY, Float_t ymin, Float_t ymax, | |
a6e0ebfe | 728 | const Char_t *type, Bool_t force) |
170c35f1 | 729 | { |
730 | // | |
731 | // return pointer to histogram | |
732 | // if force is true create a new histogram if it doesn't exist allready | |
733 | // | |
734 | if ( !force || arr->UncheckedAt(det) ) | |
735 | return (TH2F*)arr->UncheckedAt(det); | |
736 | ||
737 | // if we are forced and histogram doesn't yes exist create it | |
738 | Char_t name[255], title[255]; | |
739 | ||
37b0cf5e | 740 | sprintf(name,"hCalib%s%.3d",type,det); |
170c35f1 | 741 | sprintf(title,"%s calibration histogram detector %.2d;ADC channel;Channel (pad)",type,det); |
742 | ||
3a0f6479 | 743 | |
053767a4 | 744 | Int_t nbchannels = fGeo->GetRowMax(GetLayer(det),GetStack(det),GetSector(det))*fGeo->GetColMax(GetLayer(det)); |
e4db522f | 745 | |
746 | // we will add 3*8*rowMax channels at the end for the double counted | |
053767a4 | 747 | nbchannels += 3*8*(fGeo->GetRowMax(GetLayer(det),GetStack(det),GetSector(det))); |
e4db522f | 748 | |
170c35f1 | 749 | |
750 | // new histogram with calib information. One value for each pad! | |
751 | TH2F* hist = new TH2F(name,title, | |
752 | nbinsY, ymin, ymax, | |
753 | nbchannels,0,nbchannels | |
754 | ); | |
755 | hist->SetDirectory(0); | |
756 | arr->AddAt(hist,det); | |
757 | return hist; | |
758 | } | |
3a0f6479 | 759 | |
170c35f1 | 760 | //_____________________________________________________________________ |
761 | TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, Bool_t force) /*FOLD00*/ | |
762 | { | |
763 | // | |
764 | // return pointer to histogram | |
765 | // if force is true create a new histogram if it doesn't exist allready | |
766 | // | |
767 | TObjArray *arr = &fHistoArray; | |
d95484e4 | 768 | return GetHisto(det, arr, fAdcMax-fAdcMin, fAdcMin-0.5, fAdcMax-0.5, "Pedestal", force); |
170c35f1 | 769 | } |
3a0f6479 | 770 | |
170c35f1 | 771 | //_____________________________________________________________________ |
cf46274d | 772 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRoc(Int_t det, TObjArray* arr, Bool_t force) /*FOLD00*/ |
170c35f1 | 773 | { |
774 | // | |
775 | // return pointer to ROC Calibration | |
776 | // if force is true create a new AliTRDCalROC if it doesn't exist allready | |
777 | // | |
778 | if ( !force || arr->UncheckedAt(det) ) | |
779 | return (AliTRDCalROC*)arr->UncheckedAt(det); | |
780 | ||
781 | // if we are forced and histogram doesn't yes exist create it | |
782 | ||
783 | // new AliTRDCalROC. One value for each pad! | |
053767a4 | 784 | AliTRDCalROC *croc = new AliTRDCalROC(GetLayer(det),GetStack(det)); |
170c35f1 | 785 | arr->AddAt(croc,det); |
786 | return croc; | |
787 | } | |
788 | //_____________________________________________________________________ | |
e4db522f | 789 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMean(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 | 790 | { |
791 | // | |
792 | // return pointer to Carge ROC Calibration | |
793 | // if force is true create a new histogram if it doesn't exist allready | |
794 | // | |
e4db522f | 795 | TObjArray *arr = &fCalRocArrayMean; |
796 | return GetCalRoc(det, arr, force); | |
170c35f1 | 797 | } |
3a0f6479 | 798 | |
170c35f1 | 799 | //_____________________________________________________________________ |
e4db522f | 800 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMS(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 | 801 | { |
802 | // | |
803 | // return pointer to Carge ROC Calibration | |
804 | // if force is true create a new histogram if it doesn't exist allready | |
805 | // | |
e4db522f | 806 | TObjArray *arr = &fCalRocArrayRMS; |
807 | return GetCalRoc(det, arr, force); | |
170c35f1 | 808 | } |
809 | //_____________________________________________________________________ | |
e4db522f | 810 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMeand(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 | 811 | { |
812 | // | |
813 | // return pointer to Carge ROC Calibration | |
814 | // if force is true create a new histogram if it doesn't exist allready | |
815 | // | |
e4db522f | 816 | TObjArray *arr = &fCalRocArrayMeand; |
cf46274d | 817 | return GetCalRoc(det, arr, force); |
170c35f1 | 818 | } |
3a0f6479 | 819 | |
170c35f1 | 820 | //_____________________________________________________________________ |
e4db522f | 821 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMSd(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 | 822 | { |
823 | // | |
824 | // return pointer to Carge ROC Calibration | |
825 | // if force is true create a new histogram if it doesn't exist allready | |
826 | // | |
e4db522f | 827 | TObjArray *arr = &fCalRocArrayRMSd; |
cf46274d | 828 | return GetCalRoc(det, arr, force); |
170c35f1 | 829 | } |
3a0f6479 | 830 | |
170c35f1 | 831 | //_____________________________________________________________________ |
832 | void AliTRDCalibPadStatus::AnalyseHisto() /*FOLD00*/ | |
833 | { | |
834 | // | |
835 | // Calculate calibration constants | |
836 | // | |
837 | ||
838 | Int_t nbinsAdc = fAdcMax-fAdcMin; | |
839 | ||
d95484e4 | 840 | TVectorD param(4); |
170c35f1 | 841 | TMatrixD dummy(3,3); |
842 | ||
0bc7827a | 843 | Float_t *arrayHP=0; |
170c35f1 | 844 | |
845 | ||
846 | for (Int_t idet=0; idet<540; idet++){ | |
847 | TH2F *hP = GetHisto(idet); | |
848 | if ( !hP ) { | |
849 | continue; | |
850 | } | |
851 | ||
d95484e4 | 852 | //printf("Entries for %d\n",idet); |
853 | ||
170c35f1 | 854 | AliTRDCalROC *rocMean = GetCalRocMean(idet,kTRUE); |
855 | AliTRDCalROC *rocRMS = GetCalRocRMS(idet,kTRUE); | |
856 | ||
0bc7827a | 857 | arrayHP = hP->GetArray(); |
170c35f1 | 858 | Int_t nChannels = rocMean->GetNchannels(); |
859 | ||
860 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ | |
861 | Int_t offset = (nbinsAdc+2)*(iChannel+1)+1; | |
d95484e4 | 862 | Double_t ret = AliMathBase::FitGaus(arrayHP+offset,nbinsAdc,fAdcMin-0.5,fAdcMax-0.5,¶m,&dummy); |
863 | // if the fitting failed set noise and pedestal to 0 | |
6ace5fe2 | 864 | if ((ret==-4) || (ret==-1) || (ret==-2)) { |
170c35f1 | 865 | param[1]=0.0; |
866 | param[2]=0.0; | |
867 | } | |
868 | if((param[1]/10.0) > 65534.0) param[1] = 0.0; | |
869 | if((param[2]/10.0) > 65534.0) param[2] = 0.0; | |
870 | rocMean->SetValue(iChannel,param[1]/10.0); | |
871 | rocRMS->SetValue(iChannel,param[2]/10.0); | |
872 | } | |
e4db522f | 873 | |
874 | // here we analyse doubled read channels | |
875 | ||
876 | AliTRDCalROC *rocMeand = GetCalRocMeand(idet,kTRUE); | |
877 | AliTRDCalROC *rocRMSd = GetCalRocRMSd(idet,kTRUE); | |
878 | ||
879 | Int_t nrows = rocMeand->GetNrows(); | |
880 | Int_t shift = 144*nrows; | |
881 | Int_t total = shift+3*8*nrows; | |
882 | ||
883 | for (Int_t iChannel=shift; iChannel<total; iChannel++){ | |
884 | Int_t offset = (nbinsAdc+2)*(iChannel+1)+1; | |
d95484e4 | 885 | Double_t ret = AliMathBase::FitGaus(arrayHP+offset,nbinsAdc,fAdcMin-0.5,fAdcMax-0.5,¶m,&dummy); |
e4db522f | 886 | // if the fitting failed set noise and pedestal to 0 |
887 | if ((ret==-4) || (ret==-1) || (ret==-2)) { | |
888 | param[1]=0.0; | |
889 | param[2]=0.0; | |
890 | } | |
891 | if((param[1]/10.0) > 65534.0) param[1] = 0.0; | |
892 | if((param[2]/10.0) > 65534.0) param[2] = 0.0; | |
893 | ||
894 | // here we have to recalculate backward | |
895 | Int_t nb = iChannel-shift; | |
896 | Int_t row = nb%nrows; | |
897 | Int_t j = (Int_t)(nb/nrows); | |
898 | Int_t imcm = j%8; | |
899 | Int_t icol = (Int_t)(j/8); | |
900 | ||
901 | Int_t finalcol = 18*imcm; | |
902 | if(icol > 0) icol += 17; | |
903 | else icol = -1; | |
904 | finalcol += icol; | |
905 | ||
906 | Int_t channel = row+finalcol*nrows; | |
907 | ||
908 | //printf("iChannel %d, nrows %d, finalcol %d, row %d, channel %d\n",iChannel,nrows,finalcol,row,channel); | |
909 | if((finalcol < 0) || (finalcol >= 144)) continue; | |
910 | ||
911 | rocMeand->SetValue(channel,param[1]/10.0); | |
912 | rocRMSd->SetValue(channel,param[2]/10.0); | |
913 | } | |
914 | ||
170c35f1 | 915 | } |
e4db522f | 916 | |
170c35f1 | 917 | } |
3a0f6479 | 918 | |
170c35f1 | 919 | //_______________________________________________________________________________________ |
920 | AliTRDCalPadStatus* AliTRDCalibPadStatus::CreateCalPadStatus() | |
921 | { | |
922 | // | |
6ace5fe2 | 923 | // Create Pad Status out of Mean and RMS values |
37b0cf5e | 924 | // The chamber without data are masked, this is the corrected in the preprocessor |
170c35f1 | 925 | // |
926 | ||
927 | AliTRDCalPadStatus* obj = new AliTRDCalPadStatus("padstatus", "padstatus"); | |
928 | ||
929 | for (Int_t idet=0; idet<540; ++idet) | |
930 | { | |
931 | AliTRDCalSingleChamberStatus *calROC = obj->GetCalROC(idet); | |
932 | ||
e4db522f | 933 | |
37b0cf5e | 934 | if ( !GetCalRocMean(idet)) { |
170c35f1 | 935 | for(Int_t k = 0; k < calROC->GetNchannels(); k++){ |
37b0cf5e | 936 | calROC->SetStatus(k,AliTRDCalPadStatus::kNotConnected); |
170c35f1 | 937 | } |
170c35f1 | 938 | continue; |
939 | } | |
6ace5fe2 | 940 | |
37b0cf5e | 941 | |
942 | //Take the stuff | |
943 | AliTRDCalROC *calRocMean = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocMean(idet))); | |
944 | AliTRDCalROC *calRocRMS = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocRMS(idet))); | |
945 | ||
946 | //Take the stuff second chance | |
947 | AliTRDCalROC *calRocMeand = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocMeand(idet))); | |
948 | AliTRDCalROC *calRocRMSd = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocRMSd(idet))); | |
949 | ||
950 | calRocRMS->Unfold(); | |
951 | calRocRMSd->Unfold(); | |
952 | ||
953 | ||
170c35f1 | 954 | //Range |
37b0cf5e | 955 | Int_t row = calROC->GetNrows(); |
956 | Int_t col = calROC->GetNcols(); | |
6ace5fe2 | 957 | |
958 | Double_t rmsmean = calRocMean->GetRMS()*10.0; | |
959 | Double_t meanmean = calRocMean->GetMean()*10.0; | |
37b0cf5e | 960 | Double_t meansquares = calRocRMS->GetMean(); |
170c35f1 | 961 | |
37b0cf5e | 962 | |
963 | for(Int_t irow = 0; irow < row; irow++){ | |
170c35f1 | 964 | |
37b0cf5e | 965 | // for bridged pads |
966 | Float_t meanprevious = 0.0; | |
967 | Float_t rmsprevious = 0.0; | |
968 | Float_t mean = 0.0; | |
969 | Float_t rms = 0.0; | |
6ace5fe2 | 970 | |
37b0cf5e | 971 | for(Int_t icol = 0; icol < col; icol++){ |
972 | ||
973 | mean = calRocMean->GetValue(icol,irow)*10.0; | |
974 | rms = calRocRMS->GetValue(icol,irow); | |
975 | ||
976 | if(icol > 0) { | |
977 | meanprevious = calRocMean->GetValue((icol -1),irow)*10.0; | |
978 | rmsprevious = calRocRMS->GetValue((icol - 1),irow); | |
979 | } | |
980 | ||
981 | Bool_t pb = kFALSE; | |
982 | // masked if two noisy | |
983 | if((rms <= 0.0001) || (TMath::Abs(mean-meanmean)>(5*rmsmean)) || (TMath::Abs(rms)>(5.0*TMath::Abs(meansquares)))) { | |
984 | ||
985 | pb = kTRUE; | |
986 | // look at second chance | |
987 | Float_t meand = calRocMeand->GetValue(icol,irow)*10.0; | |
988 | Float_t rmsd = calRocRMSd->GetValue(icol,irow); | |
989 | ||
990 | if((rmsd <= 0.0001) || (TMath::Abs(meand-meanmean)>(5*rmsmean)) || (TMath::Abs(rmsd)>(5.0*TMath::Abs(meansquares)))) { | |
991 | if((rmsd <= 0.0001) && (rms <= 0.0001)) { | |
992 | calROC->SetStatus(icol,irow,AliTRDCalPadStatus::kNotConnected); | |
993 | } | |
994 | else { | |
995 | calROC->SetStatus(icol, irow, AliTRDCalPadStatus::kMasked); | |
996 | } | |
997 | } | |
998 | else { | |
999 | calROC->SetStatus(icol, irow, AliTRDCalPadStatus::kReadSecond); | |
1000 | } | |
1001 | } | |
e4db522f | 1002 | |
37b0cf5e | 1003 | |
1004 | // bridge if previous pad found something | |
1005 | if(!pb) { | |
1006 | if((meanprevious == mean) && (rmsprevious == rms) && (mean > 0.0001)) { | |
1007 | //printf("mean previous %f, mean %f, rms %f, rmsprevious %f, col %d\n",meanprevious,mean,rms,rmsprevious,icol); | |
1008 | calROC->SetStatus(icol -1 ,irow, AliTRDCalPadStatus::kPadBridgedRight); | |
1009 | calROC->SetStatus(icol ,irow, AliTRDCalPadStatus::kPadBridgedLeft); | |
1010 | } | |
e4db522f | 1011 | } |
37b0cf5e | 1012 | |
e4db522f | 1013 | } |
6ace5fe2 | 1014 | } |
37b0cf5e | 1015 | |
1016 | delete calRocMean; | |
1017 | delete calRocRMS; | |
1018 | delete calRocMeand; | |
1019 | delete calRocRMSd; | |
1020 | ||
1021 | ||
170c35f1 | 1022 | } |
1023 | ||
1024 | return obj; | |
1025 | ||
1026 | } | |
289cc637 | 1027 | //_______________________________________________________________________________________ |
1028 | AliTRDCalPad* AliTRDCalibPadStatus::CreateCalPad() | |
1029 | { | |
1030 | // | |
1031 | // Create Pad Noise out of RMS values | |
1032 | // | |
1033 | ||
1034 | AliTRDCalPad* obj = new AliTRDCalPad("PadNoise", "PadNoise"); | |
1035 | ||
1036 | ||
1037 | for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det) { | |
1038 | ||
1039 | AliTRDCalROC *calROC22 = obj->GetCalROC(det); | |
1040 | ||
1041 | AliTRDCalROC *calRocRMS = ((AliTRDCalROC *)GetCalRocRMS(det,kTRUE)); | |
1042 | ||
1043 | for(Int_t k = 0; k < calROC22->GetNchannels(); k++){ | |
1044 | calROC22->SetValue(k,calRocRMS->GetValue(k)); | |
1045 | } | |
1046 | ||
1047 | } | |
1048 | ||
1049 | return obj; | |
1050 | ||
1051 | } | |
1052 | ||
1053 | //_______________________________________________________________________________________ | |
0bc7827a | 1054 | AliTRDCalDet* AliTRDCalibPadStatus::CreateCalDet() const |
289cc637 | 1055 | { |
1056 | // | |
1057 | // Create Det Noise correction factor | |
1058 | // | |
1059 | ||
1060 | AliTRDCalDet* obj = new AliTRDCalDet("DetNoise", "DetNoise (correction factor)"); | |
1061 | ||
1062 | for(Int_t l = 0; l < 540; l++){ | |
1063 | obj->SetValue(l,10.0); | |
1064 | } | |
1065 | ||
1066 | return obj; | |
1067 | ||
1068 | } | |
1069 | ||
170c35f1 | 1070 | //_____________________________________________________________________ |
1071 | void AliTRDCalibPadStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/ | |
1072 | { | |
1073 | // | |
1074 | // Write class to file | |
1075 | // | |
1076 | ||
1077 | TString sDir(dir); | |
1078 | TString option; | |
1079 | ||
1080 | if ( append ) | |
1081 | option = "update"; | |
1082 | else | |
1083 | option = "recreate"; | |
1084 | ||
1085 | TDirectory *backup = gDirectory; | |
1086 | TFile f(filename,option.Data()); | |
1087 | f.cd(); | |
1088 | if ( !sDir.IsNull() ){ | |
1089 | f.mkdir(sDir.Data()); | |
1090 | f.cd(sDir); | |
1091 | } | |
1092 | this->Write(); | |
1093 | f.Close(); | |
1094 | ||
1095 | if ( backup ) backup->cd(); | |
3a0f6479 | 1096 | } |
1097 | ||
6ace5fe2 | 1098 | //_____________________________________________________________________ |
1099 | void AliTRDCalibPadStatus::SetCalRocMean(AliTRDCalROC *mean, Int_t det) /*FOLD00*/ | |
1100 | { | |
1101 | // | |
1102 | // Put the AliTRDCalROC in the array fCalRocArrayMean | |
1103 | // | |
1104 | ||
1105 | ||
1106 | AliTRDCalROC *rocMean = GetCalRocMean(det,kTRUE); | |
1107 | ||
1108 | Int_t nChannels = rocMean->GetNchannels(); | |
1109 | ||
1110 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ | |
1111 | ||
1112 | rocMean->SetValue(iChannel,mean->GetValue(iChannel)); | |
1113 | ||
1114 | } | |
1115 | ||
1116 | } | |
1117 | ||
1118 | //_____________________________________________________________________ | |
1119 | void AliTRDCalibPadStatus::SetCalRocRMS(AliTRDCalROC *rms, Int_t det) /*FOLD00*/ | |
1120 | { | |
1121 | // | |
1122 | // Put the AliTRDCalROC in the array fCalRocArrayRMS | |
1123 | // | |
1124 | ||
1125 | ||
1126 | AliTRDCalROC *rocRms = GetCalRocRMS(det,kTRUE); | |
1127 | ||
1128 | Int_t nChannels = rocRms->GetNchannels(); | |
1129 | ||
1130 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ | |
1131 | ||
1132 | rocRms->SetValue(iChannel,rms->GetValue(iChannel)); | |
1133 | ||
1134 | } | |
1135 | ||
1136 | } | |
e4db522f | 1137 | //_____________________________________________________________________ |
1138 | void AliTRDCalibPadStatus::SetCalRocMeand(AliTRDCalROC *mean, Int_t det) /*FOLD00*/ | |
1139 | { | |
1140 | // | |
1141 | // Put the AliTRDCalROC in the array fCalRocArrayMean | |
1142 | // | |
6ace5fe2 | 1143 | |
e4db522f | 1144 | |
1145 | AliTRDCalROC *rocMean = GetCalRocMeand(det,kTRUE); | |
1146 | ||
1147 | Int_t nChannels = rocMean->GetNchannels(); | |
1148 | ||
1149 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ | |
1150 | ||
1151 | rocMean->SetValue(iChannel,mean->GetValue(iChannel)); | |
1152 | ||
1153 | } | |
1154 | ||
1155 | } | |
1156 | ||
1157 | //_____________________________________________________________________ | |
1158 | void AliTRDCalibPadStatus::SetCalRocRMSd(AliTRDCalROC *rms, Int_t det) /*FOLD00*/ | |
1159 | { | |
1160 | // | |
1161 | // Put the AliTRDCalROC in the array fCalRocArrayRMS | |
1162 | // | |
1163 | ||
1164 | ||
1165 | AliTRDCalROC *rocRms = GetCalRocRMSd(det,kTRUE); | |
1166 | ||
1167 | Int_t nChannels = rocRms->GetNchannels(); | |
1168 | ||
1169 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ | |
1170 | ||
1171 | rocRms->SetValue(iChannel,rms->GetValue(iChannel)); | |
1172 | ||
1173 | } | |
1174 | ||
1175 | } | |
3a0f6479 | 1176 | //_____________________________________________________________________________ |
053767a4 | 1177 | Int_t AliTRDCalibPadStatus::GetLayer(Int_t d) const |
170c35f1 | 1178 | { |
1179 | // | |
053767a4 | 1180 | // Reconstruct the layer number from the detector number |
170c35f1 | 1181 | // |
1182 | ||
1183 | return ((Int_t) (d % 6)); | |
1184 | ||
1185 | } | |
1186 | ||
1187 | //_____________________________________________________________________________ | |
053767a4 | 1188 | Int_t AliTRDCalibPadStatus::GetStack(Int_t d) const |
170c35f1 | 1189 | { |
1190 | // | |
1191 | // Reconstruct the chamber number from the detector number | |
1192 | // | |
1193 | ||
1194 | return ((Int_t) (d % 30) / 6); | |
1195 | ||
1196 | } | |
3a0f6479 | 1197 | |
170c35f1 | 1198 | //_____________________________________________________________________________ |
1199 | Int_t AliTRDCalibPadStatus::GetSector(Int_t d) const | |
1200 | { | |
1201 | // | |
1202 | // Reconstruct the sector number from the detector number | |
1203 | // | |
1204 | ||
1205 | return ((Int_t) (d / 30)); | |
1206 | ||
1207 | } |