6c1053a8 |
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 | //////////////////////////////////////////////////////////////////////////// |
17 | // // |
18 | // AliTRDCalibChamberStatus: to determine which half chambers are off // |
19 | // Produce a AliTRDCalChamberStatus calibration object // |
20 | // Check with the AliTRDCalDCSFEE info // |
21 | // // |
22 | // // |
23 | // Authors: // |
24 | // J. Book (jbook@ikf.uni-frankfurt.de) // |
25 | // R. Bailhache (rbailhache@ikf.uni-frankfurt.de) // |
26 | // // |
27 | //////////////////////////////////////////////////////////////////////////// |
28 | |
29 | |
30 | //Root includes |
31 | #include <THnSparse.h> |
32 | |
33 | #include <TDirectory.h> |
34 | #include <TFile.h> |
35 | |
36 | //AliRoot includes |
37 | #include "AliRawReader.h" |
38 | |
39 | //header file |
40 | #include "AliLog.h" |
41 | #include "AliTRDCalibChamberStatus.h" |
42 | #include "AliTRDgeometry.h" |
43 | #include "AliTRDdigitsManager.h" |
44 | #include "AliTRDSignalIndex.h" |
45 | #include "AliTRDrawFastStream.h" |
46 | #include "./Cal/AliTRDCalChamberStatus.h" |
47 | #include "./Cal/AliTRDCalDCS.h" |
48 | #include "./Cal/AliTRDCalDCSFEE.h" |
49 | |
50 | #ifdef ALI_DATE |
51 | #include "event.h" |
52 | #endif |
53 | |
54 | ClassImp(AliTRDCalibChamberStatus) /*FOLD00*/ |
55 | |
56 | //_____________________________________________________________________ |
57 | AliTRDCalibChamberStatus::AliTRDCalibChamberStatus() : /*FOLD00*/ |
58 | TObject(), |
59 | fDetector(-1), |
60 | fNumberOfTimeBins(0), |
61 | fCounterEventNotEmpty(0), |
62 | fCalChamberStatus(0x0), |
63 | fHnSparseI(0x0), |
64 | fHnSparseHCM(0x0), |
65 | fHnSparseEvtDet(0x0), |
66 | fHnSparseDebug(0x0), |
67 | fHnSparseMCM(0x0), |
68 | fDebugLevel(0) |
69 | { |
70 | // |
71 | // default constructor |
72 | // |
73 | |
74 | } |
75 | //_____________________________________________________________________ |
76 | AliTRDCalibChamberStatus::AliTRDCalibChamberStatus(const AliTRDCalibChamberStatus &ped) : /*FOLD00*/ |
77 | TObject(ped), |
78 | fDetector(ped.fDetector), |
79 | fNumberOfTimeBins(ped.fNumberOfTimeBins), |
80 | fCounterEventNotEmpty(ped.fCounterEventNotEmpty), |
81 | fCalChamberStatus(ped.fCalChamberStatus), |
82 | fHnSparseI(ped.fHnSparseI), |
83 | fHnSparseHCM(ped.fHnSparseHCM), |
84 | fHnSparseEvtDet(ped.fHnSparseEvtDet), |
85 | fHnSparseDebug(ped.fHnSparseDebug), |
86 | fHnSparseMCM(ped.fHnSparseMCM), |
87 | fDebugLevel(ped.fDebugLevel) |
88 | { |
89 | // |
90 | // copy constructor |
91 | // |
92 | |
93 | } |
94 | //_____________________________________________________________________ |
95 | AliTRDCalibChamberStatus& AliTRDCalibChamberStatus::operator = (const AliTRDCalibChamberStatus &source) |
96 | { |
97 | // |
98 | // assignment operator |
99 | // |
100 | if (&source == this) return *this; |
101 | new (this) AliTRDCalibChamberStatus(source); |
102 | |
103 | return *this; |
104 | } |
105 | //_____________________________________________________________________ |
106 | AliTRDCalibChamberStatus::~AliTRDCalibChamberStatus() /*FOLD00*/ |
107 | { |
108 | // |
109 | // destructor |
110 | // |
111 | if(fCalChamberStatus){ |
112 | delete fCalChamberStatus; |
113 | } |
114 | if(fHnSparseI) { |
115 | delete fHnSparseI; |
116 | } |
117 | if(fHnSparseHCM) { |
118 | delete fHnSparseHCM; |
119 | } |
120 | if(fHnSparseEvtDet) { |
121 | delete fHnSparseEvtDet; |
122 | } |
123 | if(fHnSparseDebug) { |
124 | delete fHnSparseDebug; |
125 | } |
126 | if(fHnSparseMCM) { |
127 | delete fHnSparseMCM; |
128 | } |
129 | } |
130 | |
131 | //_____________________________________________________________________ |
132 | void AliTRDCalibChamberStatus::Init() |
133 | { |
134 | // |
135 | // Init the different THnSparse |
136 | // |
137 | // |
138 | |
139 | // |
140 | // Init the fHnSparseI |
141 | // |
142 | |
143 | //create the map |
144 | Int_t thnDimEvt[4]; // sm, layer, stack, halfchamber |
145 | thnDimEvt[0] = 18; |
146 | thnDimEvt[1] = 6; |
147 | thnDimEvt[2] = 5; |
148 | thnDimEvt[3] = 2; |
149 | //arrays for lower bounds : |
150 | Double_t* binEdgesEvt[4]; |
151 | for(Int_t ivar = 0; ivar < 4; ivar++) |
152 | binEdgesEvt[ivar] = new Double_t[thnDimEvt[ivar] + 1]; |
153 | //values for bin lower bounds |
154 | for(Int_t i=0; i<=thnDimEvt[0]; i++) binEdgesEvt[0][i]= 0.0 + (18.0)/thnDimEvt[0]*(Double_t)i; |
155 | for(Int_t i=0; i<=thnDimEvt[1]; i++) binEdgesEvt[1][i]= 0.0 + (6.0)/thnDimEvt[1]*(Double_t)i; |
156 | for(Int_t i=0; i<=thnDimEvt[2]; i++) binEdgesEvt[2][i]= 0.0 + (5.0)/thnDimEvt[2]*(Double_t)i; |
157 | for(Int_t i=0; i<=thnDimEvt[3]; i++) binEdgesEvt[3][i]= 0.0 + (2.0)/thnDimEvt[3]*(Double_t)i; |
158 | |
159 | //create the THnSparse |
160 | fHnSparseI = new THnSparseI("NumberOfEntries","NumberOfEntries",4,thnDimEvt); |
161 | for (int k=0; k<4; k++) { |
162 | fHnSparseI->SetBinEdges(k,binEdgesEvt[k]); |
163 | } |
164 | fHnSparseI->Sumw2(); |
165 | |
166 | // |
167 | // Init the fHnSparseHCM (THnSparseI) |
168 | // |
169 | |
170 | //create the THnSparse |
171 | fHnSparseHCM = new THnSparseI("HCMerrors","HCMerrors",4,thnDimEvt); |
172 | for (int k=0; k<4; k++) { |
173 | fHnSparseHCM->SetBinEdges(k,binEdgesEvt[k]); |
174 | } |
175 | fHnSparseHCM->Sumw2(); |
176 | |
177 | |
178 | //---------// |
179 | // Debug // |
180 | if(fDebugLevel > 0) { |
181 | |
182 | // |
183 | // Init the fHnSparseEvtDet (THnSparseI) |
184 | // |
185 | |
186 | //create the map |
187 | Int_t thnDimEvts[3]; // event, detector, halfchamber |
188 | thnDimEvts[0] = 10000; |
189 | thnDimEvts[1] = 540; |
190 | thnDimEvts[2] = 2; |
191 | //arrays for lower bounds : |
192 | Double_t* binEdgesEvts[3]; |
193 | for(Int_t ivar = 0; ivar < 3; ivar++) |
194 | binEdgesEvts[ivar] = new Double_t[thnDimEvts[ivar] + 1]; |
195 | //values for bin lower bounds |
196 | for(Int_t i=0; i<=thnDimEvts[0]; i++) binEdgesEvts[0][i]= 0.0 + (10000.0)/thnDimEvts[0]*(Double_t)i; |
197 | for(Int_t i=0; i<=thnDimEvts[1]; i++) binEdgesEvts[1][i]= 0.0 + (540.0)/thnDimEvts[1]*(Double_t)i; |
198 | for(Int_t i=0; i<=thnDimEvts[2]; i++) binEdgesEvts[2][i]= 0.0 + (2.0)/thnDimEvts[2]*(Double_t)i; |
199 | |
200 | //create the THnSparse |
201 | fHnSparseEvtDet = new THnSparseI("NumberOfEntriesPerEvent","NumberOfEntriesPerEvent",3,thnDimEvts); |
202 | for (int k=0; k<3; k++) { |
203 | fHnSparseEvtDet->SetBinEdges(k,binEdgesEvts[k]); |
204 | } |
205 | fHnSparseEvtDet->Sumw2(); |
206 | |
207 | // |
208 | // Init the fHnSparseDebug (THnSparseI) |
209 | // |
210 | |
211 | //create the THnSparse |
212 | fHnSparseDebug = new THnSparseI("NumberOfDifferentDecisions","NumberOfDifferentDecisions",4,thnDimEvt); |
213 | for (int k=0; k<4; k++) { |
214 | fHnSparseDebug->SetBinEdges(k,binEdgesEvt[k]); |
215 | } |
216 | fHnSparseDebug->Sumw2(); |
217 | |
218 | // |
219 | // Init the fHnSparseMCM (THnSparseI) |
220 | // |
221 | |
222 | //create the map |
223 | Int_t thnDimEvtt[6]; // sm, layer, stack, ROB, MCM |
224 | thnDimEvtt[0] = 18; |
225 | thnDimEvtt[1] = 6; |
226 | thnDimEvtt[2] = 5; |
227 | thnDimEvtt[3] = 8; |
228 | thnDimEvtt[4] = 16; |
229 | thnDimEvtt[5] = 16; |
230 | //arrays for lower bounds : |
231 | Double_t* binEdgesEvtt[6]; |
232 | for(Int_t ivar = 0; ivar < 6; ivar++) |
233 | binEdgesEvtt[ivar] = new Double_t[thnDimEvtt[ivar] + 1]; |
234 | //values for bin lower bounds |
235 | for(Int_t i=0; i<=thnDimEvtt[0]; i++) binEdgesEvtt[0][i]= 0.0 + (18.0)/thnDimEvtt[0]*(Double_t)i; |
236 | for(Int_t i=0; i<=thnDimEvtt[1]; i++) binEdgesEvtt[1][i]= 0.0 + (6.0)/thnDimEvtt[1]*(Double_t)i; |
237 | for(Int_t i=0; i<=thnDimEvtt[2]; i++) binEdgesEvtt[2][i]= 0.0 + (5.0)/thnDimEvtt[2]*(Double_t)i; |
238 | for(Int_t i=0; i<=thnDimEvtt[3]; i++) binEdgesEvtt[3][i]= 0.0 + (8.0)/thnDimEvtt[3]*(Double_t)i; |
239 | for(Int_t i=0; i<=thnDimEvtt[4]; i++) binEdgesEvtt[4][i]= 0.0 + (16.0)/thnDimEvtt[4]*(Double_t)i; |
240 | for(Int_t i=0; i<=thnDimEvtt[5]; i++) binEdgesEvtt[5][i]= 0.0 + (16.0)/thnDimEvtt[5]*(Double_t)i; |
241 | |
242 | //create the THnSparse |
243 | fHnSparseMCM = new THnSparseI("MCMerrorDCS","MCMerrorDCS",6,thnDimEvtt); |
244 | for (int k=0; k<6; k++) { |
245 | fHnSparseMCM->SetBinEdges(k,binEdgesEvtt[k]); |
246 | } |
247 | fHnSparseMCM->Sumw2(); |
248 | |
249 | } |
250 | // Debug // |
251 | //---------// |
252 | |
253 | } |
254 | //_____________________________________________________________________ |
255 | void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics) |
256 | { |
257 | // |
258 | // Event Processing loop |
259 | // |
260 | // |
261 | |
262 | Bool_t notEmpty = kFALSE; |
263 | |
264 | AliTRDrawFastStream *rawStream = new AliTRDrawFastStream(rawReader); |
265 | rawStream->SetSharedPadReadout(kFALSE); |
266 | |
267 | AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE); |
268 | digitsManager->CreateArrays(); |
269 | |
270 | Int_t det = 0; |
271 | while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { |
272 | |
273 | //nextchamber loop |
274 | |
275 | // do the QA analysis |
276 | if (digitsManager->GetIndexes(det)->HasEntry()) {//QA |
277 | // printf("there is ADC data on this chamber!\n"); |
278 | |
279 | AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det); |
280 | if (indexes->IsAllocated() == kFALSE) { |
281 | // AliError("Indexes do not exist!"); |
282 | break; |
283 | } |
284 | |
285 | Int_t iRow = 0; |
286 | Int_t iCol = 0; |
287 | indexes->ResetCounters(); |
288 | |
289 | while (indexes->NextRCIndex(iRow, iCol)){ |
290 | Int_t iMcm = (Int_t)(iCol/18); // current group of 18 col pads |
291 | |
292 | Int_t layer = AliTRDgeometry::GetLayer(det); |
293 | Int_t sm = AliTRDgeometry::GetSector(det); |
294 | Int_t stac = AliTRDgeometry::GetStack(det); |
295 | Double_t rphi = 0.5; |
296 | if(iMcm > 3) rphi = 1.5; |
297 | |
298 | Double_t val[4] = {sm,layer,stac,rphi}; |
299 | fHnSparseI->Fill(&val[0]); |
300 | notEmpty = kTRUE; |
301 | |
302 | //---------// |
303 | // Debug // |
304 | if(fDebugLevel > 0) { |
305 | Int_t detector = AliTRDgeometry::GetDetector(layer,stac,sm); |
306 | Double_t valu[3] = {nevents_physics,detector,rphi}; |
307 | fHnSparseEvtDet->Fill(&valu[0]); |
308 | } |
309 | // Debug // |
310 | //---------// |
311 | } |
312 | |
313 | } |
314 | digitsManager->ClearArrays(det); |
315 | } |
316 | |
317 | if(notEmpty) fCounterEventNotEmpty++; |
318 | |
319 | if(digitsManager) delete digitsManager; |
320 | if(rawStream) delete rawStream; |
321 | |
322 | } |
323 | //_____________________________________________________________________ |
324 | Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /*FOLD00*/ |
325 | { |
326 | // |
327 | // Test event loop |
328 | // fill the fHnSparseI with entries |
329 | // |
330 | |
331 | AliTRDgeometry geo; |
332 | |
333 | |
334 | for(Int_t ievent=0; ievent<nevent; ievent++){ |
335 | for (Int_t ism=0; ism<18; ism++){ |
336 | for (Int_t istack=0; istack<5; istack++){ |
337 | for (Int_t ipl=0; ipl<6; ipl++){ |
338 | for (Int_t icol=0; icol<geo.GetColMax(ipl); icol++){ |
339 | Int_t side = 0; |
340 | if(icol > 72) side = 1; |
341 | Double_t val[4] = {ism,ipl,istack,side}; |
342 | fHnSparseI->Fill(&val[0]); |
343 | } |
344 | } |
345 | } |
346 | } |
347 | } |
348 | |
349 | return kTRUE; |
350 | |
351 | } |
352 | //_____________________________________________________________________ |
353 | void AliTRDCalibChamberStatus::AnalyseHisto() /*FOLD00*/ |
354 | { |
355 | // |
356 | // Create the AliTRDCalChamberStatus according to the fHnSparseI |
357 | // |
358 | |
359 | if(fCalChamberStatus) delete fCalChamberStatus; |
360 | fCalChamberStatus = new AliTRDCalChamberStatus(); |
361 | |
362 | // Check if enough events to say something |
363 | if(fCounterEventNotEmpty < 30) { |
364 | // Say all installed |
365 | for (Int_t ism=0; ism<18; ism++) { |
366 | for (Int_t ipl=0; ipl<6; ipl++) { |
367 | for (Int_t istack=0; istack<5; istack++) { |
368 | // layer, stack, sector |
369 | Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism); |
370 | fCalChamberStatus->SetStatus(det,1); |
371 | } |
372 | } |
373 | } |
374 | return; |
375 | } |
376 | |
377 | // Mask out all chambers |
378 | for (Int_t ism=0; ism<18; ism++) { |
379 | for (Int_t ipl=0; ipl<6; ipl++) { |
380 | for (Int_t istack=0; istack<5; istack++) { |
381 | // layer, stack, sector |
382 | Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism); |
383 | fCalChamberStatus->SetStatus(det,2); |
384 | } |
385 | } |
386 | } |
387 | |
388 | // Unmask good chambers |
389 | Int_t coord[4]; |
390 | for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) { |
391 | |
392 | fHnSparseI->GetBinContent(bin,coord); |
393 | // layer, stack, sector |
394 | Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1); |
395 | |
396 | // |
397 | // Check which halfchamber side corresponds to the bin number (0=A, 1=B) |
398 | // Change the status accordingly |
399 | // |
400 | |
401 | switch(fCalChamberStatus->GetStatus(detector)) |
402 | { |
403 | case 1: break; // no changes |
404 | case 2: |
405 | if(coord[3]-1==0) { |
406 | fCalChamberStatus->SetStatus(detector,4); break; // only SideB is masked |
407 | } |
408 | else { |
409 | fCalChamberStatus->SetStatus(detector,3); break; // only SideA is masked |
410 | } |
411 | case 3: fCalChamberStatus->SetStatus(detector,1); break; // unmask SideA |
412 | case 4: fCalChamberStatus->SetStatus(detector,1); break; // unmask SideB |
413 | } |
414 | } |
415 | |
416 | |
417 | } |
418 | //_____________________________________________________________________ |
419 | void AliTRDCalibChamberStatus::CheckEORStatus(AliTRDCalDCS *calDCS) /*FOLD00*/ |
420 | { |
421 | // |
422 | // Correct the AliTRDCalChamberStatus according to the AliTRDCalDCS |
423 | // Using globale state of the HalfChamberMerger (HCM) |
424 | // |
425 | |
426 | for(Int_t det = 0; det < 540; det++) { |
427 | AliTRDCalDCSFEE* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det); |
428 | if(!calDCSFEEEOR) { continue;} |
429 | |
430 | // MCM Global State Machine State Definitions |
431 | // low_power = 0, |
432 | // test = 1, |
433 | // wait_pre = 3, |
434 | // preproc = 7, |
435 | // zero_sp = 8, |
436 | // full_rd = 9, |
437 | // clear_st = 11, |
438 | // wait_L1 = 12, |
439 | // tr_send = 14, |
440 | // tr_proc = 15 |
441 | |
442 | Int_t sm = AliTRDgeometry::GetSector(det); |
443 | Int_t lay = AliTRDgeometry::GetLayer(det); |
444 | Int_t stac = AliTRDgeometry::GetStack(det); |
445 | |
446 | Int_t stateA = calDCSFEEEOR->GetMCMGlobalState(4,17); // HCM Side A |
447 | Int_t stateB = calDCSFEEEOR->GetMCMGlobalState(5,17); // HCM Side B |
448 | Int_t rphi = -1; |
449 | |
450 | //printf("DCS: stateA %d \t stateB %d \n",stateA,stateB); |
451 | if(stateA!=3 && stateA!=9) rphi = 1; |
452 | Double_t vals[4] = {sm,lay,stac,rphi}; |
453 | if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]); |
454 | |
455 | if(stateB!=3 && stateB!=9) rphi = 2; |
456 | vals[3] = rphi; |
457 | if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]); |
458 | |
459 | //---------// |
460 | // Debug // |
461 | if(fDebugLevel > 0) { |
462 | if( (fCalChamberStatus->GetStatus(det) <= 1) && (stateA!=3 && stateA!=9) || |
463 | (fCalChamberStatus->GetStatus(det) <= 1) && (stateB!=3 && stateB!=9) || |
464 | (fCalChamberStatus->GetStatus(det) >= 2) && (stateA==3 || stateA==9) || |
465 | (fCalChamberStatus->GetStatus(det) >= 2) && (stateB==3 || stateB==9) ) |
466 | { |
467 | //printf(" Different half chamber status in DCS and DATA!!\n"); |
468 | Double_t val[4] = {sm,lay,stac,1}; |
469 | fHnSparseDebug->Fill(&val[0]); |
470 | |
471 | if(rphi!=-1) { // error in DCS information |
472 | // Fill MCM status map |
473 | for(Int_t ii = 0; ii < 8; ii++) { //ROB loop |
474 | for(Int_t i = 0; i < 16; i++) { //MCM loop |
475 | Double_t valss[6] = {sm,lay,stac,ii,i |
476 | ,calDCSFEEEOR->GetMCMGlobalState(ii,i)}; |
477 | fHnSparseMCM->Fill(&valss[0]); |
478 | } |
479 | } |
480 | } |
481 | } |
482 | } |
483 | //---------// |
484 | // Debug // |
485 | } |
486 | |
487 | } |
488 | |
489 | //_____________________________________________________________________________________ |
490 | void AliTRDCalibChamberStatus::Add(AliTRDCalibChamberStatus *calibChamberStatus) /*FOLD00*/ |
491 | { |
492 | // |
493 | // Add the THnSparseI of this calibChamberStatus |
494 | // |
495 | |
496 | fCounterEventNotEmpty += calibChamberStatus->GetNumberEventNotEmpty(); |
497 | |
498 | THnSparseI *hnSparseI = calibChamberStatus->GetSparseI(); |
499 | if(!hnSparseI) return; |
500 | |
501 | if(!fHnSparseI) { |
502 | fHnSparseI = (THnSparseI *) hnSparseI->Clone(); |
503 | } |
504 | else { |
505 | fHnSparseI->Add(hnSparseI); |
506 | } |
507 | |
508 | |
509 | } |
510 | //_____________________________________________________________________ |
511 | void AliTRDCalibChamberStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/ |
512 | { |
513 | // |
514 | // Write class to file |
515 | // |
516 | |
517 | TString sDir(dir); |
518 | TString option; |
519 | |
520 | if ( append ) |
521 | option = "update"; |
522 | else |
523 | option = "recreate"; |
524 | |
525 | TDirectory *backup = gDirectory; |
526 | TFile f(filename,option.Data()); |
527 | f.cd(); |
528 | if ( !sDir.IsNull() ){ |
529 | f.mkdir(sDir.Data()); |
530 | f.cd(sDir); |
531 | } |
532 | this->Write(); |
533 | f.Close(); |
534 | |
535 | if ( backup ) backup->cd(); |
536 | } |
537 | |
538 | |