Procedures for half chamber status (Julian)
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibChamberStatus.cxx
CommitLineData
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
54ClassImp(AliTRDCalibChamberStatus) /*FOLD00*/
55
56//_____________________________________________________________________
57AliTRDCalibChamberStatus::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//_____________________________________________________________________
76AliTRDCalibChamberStatus::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//_____________________________________________________________________
95AliTRDCalibChamberStatus& 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//_____________________________________________________________________
106AliTRDCalibChamberStatus::~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//_____________________________________________________________________
132void 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//_____________________________________________________________________
255void 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//_____________________________________________________________________
324Bool_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//_____________________________________________________________________
353void 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//_____________________________________________________________________
419void 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//_____________________________________________________________________________________
490void 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//_____________________________________________________________________
511void 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