299c3800361164ba3f20f4dc5ba8907284ce5766
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibChamberStatus.cxx
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->SetNoErrorWarning();
266   rawStream->SetSharedPadReadout(kFALSE);
267
268   AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
269   digitsManager->CreateArrays();
270   
271   Int_t det    = 0;
272   while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { 
273
274     //nextchamber loop
275     
276     // do the QA analysis
277     if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
278       // printf("there is ADC data on this chamber!\n");
279       
280       AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det);
281       if (indexes->IsAllocated() == kFALSE) {
282         // AliError("Indexes do not exist!");
283         break;
284       }
285       
286       Int_t iRow  = 0;
287       Int_t iCol  = 0;
288       indexes->ResetCounters();
289       
290       while (indexes->NextRCIndex(iRow, iCol)){
291         Int_t iMcm        = (Int_t)(iCol/18);   // current group of 18 col pads
292         
293         Int_t layer = AliTRDgeometry::GetLayer(det);
294         Int_t sm    = AliTRDgeometry::GetSector(det);
295         Int_t stac  = AliTRDgeometry::GetStack(det);
296         Double_t rphi = 0.5;
297         if(iMcm > 3) rphi = 1.5;
298
299         Double_t val[4] = {sm,layer,stac,rphi}; 
300         fHnSparseI->Fill(&val[0]); 
301         notEmpty = kTRUE;
302         
303         //---------//
304         //  Debug  //
305         if(fDebugLevel > 0) {
306           Int_t detector = AliTRDgeometry::GetDetector(layer,stac,sm);
307           Double_t valu[3] = {nevents_physics,detector,rphi};
308           fHnSparseEvtDet->Fill(&valu[0]); 
309         }
310         //  Debug  //
311         //---------//
312       }
313       
314     }
315     digitsManager->ClearArrays(det);
316   }
317
318   if(notEmpty) fCounterEventNotEmpty++;
319
320   if(digitsManager) delete digitsManager;
321   if(rawStream) delete rawStream;
322    
323 }
324 //_____________________________________________________________________
325 Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /*FOLD00*/
326 {
327   //
328   //  Test event loop
329   // fill the fHnSparseI with entries
330   //
331   
332   AliTRDgeometry geo;
333
334
335   for(Int_t ievent=0; ievent<nevent; ievent++){
336     for (Int_t ism=0; ism<18; ism++){
337       for (Int_t istack=0; istack<5; istack++){
338         for (Int_t ipl=0; ipl<6; ipl++){
339           for (Int_t icol=0; icol<geo.GetColMax(ipl); icol++){
340             Int_t side = 0;
341             if(icol > 72) side = 1;
342             Double_t val[4] = {ism,ipl,istack,side}; 
343             fHnSparseI->Fill(&val[0]); 
344           }
345         }
346       }
347     }
348   }
349   
350   return kTRUE;
351
352 }
353 //_____________________________________________________________________
354 void AliTRDCalibChamberStatus::AnalyseHisto() /*FOLD00*/
355 {
356     //
357     //  Create the AliTRDCalChamberStatus according to the fHnSparseI
358     //
359
360   if(fCalChamberStatus) delete fCalChamberStatus;
361   fCalChamberStatus = new AliTRDCalChamberStatus();
362
363   // Check if enough events to say something
364   if(fCounterEventNotEmpty < 30) {
365     // Say all installed
366     for (Int_t ism=0; ism<18; ism++) {
367       for (Int_t ipl=0; ipl<6; ipl++) {
368         for (Int_t istack=0; istack<5; istack++) {
369           // layer, stack, sector
370           Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
371           fCalChamberStatus->SetStatus(det,1);
372         }
373       }
374     }
375     return;
376   }
377
378   // Mask out all chambers
379   for (Int_t ism=0; ism<18; ism++) {
380     for (Int_t ipl=0; ipl<6; ipl++) {
381       for (Int_t istack=0; istack<5; istack++) {
382         // layer, stack, sector
383         Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
384         fCalChamberStatus->SetStatus(det,2);
385       }
386     }
387   }
388
389   // Unmask good chambers 
390   Int_t coord[4];
391   for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
392     
393     fHnSparseI->GetBinContent(bin,coord);
394     // layer, stack, sector
395     Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1);
396
397     //
398     // Check which halfchamber side corresponds to the bin number (0=A, 1=B)
399     // Change the status accordingly
400     //
401
402     switch(fCalChamberStatus->GetStatus(detector)) 
403       {    
404       case 1: break;  // no changes
405       case 2: 
406         if(coord[3]-1==0) {
407           fCalChamberStatus->SetStatus(detector,4); break;      // only SideB is masked
408         }
409         else {
410           fCalChamberStatus->SetStatus(detector,3); break;      // only SideA is masked
411         }
412       case 3:  fCalChamberStatus->SetStatus(detector,1); break;  // unmask SideA
413       case 4:  fCalChamberStatus->SetStatus(detector,1); break;  // unmask SideB
414       }
415   }
416
417
418 }
419 //_____________________________________________________________________
420 void AliTRDCalibChamberStatus::CheckEORStatus(AliTRDCalDCS *calDCS) /*FOLD00*/
421 {
422   //
423   //  Correct the AliTRDCalChamberStatus according to the AliTRDCalDCS
424   //  Using globale state of the HalfChamberMerger (HCM)
425   //
426   
427   for(Int_t det = 0; det < 540; det++) {
428     AliTRDCalDCSFEE* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det);
429     if(!calDCSFEEEOR) { continue;}
430     
431     // MCM Global State Machine State Definitions
432     //  low_power =  0,
433     //  test      =  1,
434     //  wait_pre  =  3,
435     //  preproc   =  7,
436     //  zero_sp   =  8,
437     //  full_rd   =  9,
438     //  clear_st  = 11,
439     //  wait_L1   = 12,
440     //  tr_send   = 14,
441     //  tr_proc   = 15 
442
443     Int_t sm   = AliTRDgeometry::GetSector(det);
444     Int_t lay  = AliTRDgeometry::GetLayer(det);
445     Int_t stac = AliTRDgeometry::GetStack(det);
446     
447     Int_t stateA = calDCSFEEEOR->GetMCMGlobalState(4,17); // HCM Side A
448     Int_t stateB = calDCSFEEEOR->GetMCMGlobalState(5,17); // HCM Side B
449     Int_t rphi = -1;
450
451     //printf("DCS: stateA %d \t stateB %d \n",stateA,stateB);
452     if(stateA!=3 && stateA!=9) rphi = 1;
453     Double_t vals[4] = {sm,lay,stac,rphi};
454     if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]);
455     
456     if(stateB!=3 && stateB!=9) rphi = 2;
457     vals[3] = rphi;
458     if(rphi!=-1) fHnSparseHCM->Fill(&vals[0]);
459
460     //---------//
461     //  Debug  //
462     if(fDebugLevel > 0) {
463       if( ((fCalChamberStatus->GetStatus(det) <= 1) && (stateA!=3 && stateA!=9)) || 
464           ((fCalChamberStatus->GetStatus(det) <= 1) && (stateB!=3 && stateB!=9)) || 
465           ((fCalChamberStatus->GetStatus(det) == 2) && (stateA==3 || stateA==9)) || 
466           ((fCalChamberStatus->GetStatus(det) == 2) && (stateB==3 || stateB==9)) ||
467           ((fCalChamberStatus->GetStatus(det) == 3) && (stateA==3 || stateA==9)) ||
468           ((fCalChamberStatus->GetStatus(det) == 3) && (stateB!=3 && stateB!=9)) ||
469           ((fCalChamberStatus->GetStatus(det) == 4) && (stateB==3 || stateB==9)) ||
470           ((fCalChamberStatus->GetStatus(det) == 4) && (stateA!=3 && stateA!=9)) )
471         {
472           //printf(" Different half chamber status in DCS and DATA!!\n");
473           Double_t val[4] = {sm,lay,stac,1};
474           fHnSparseDebug->Fill(&val[0]); 
475           
476           if(rphi!=-1) {  // error in DCS information
477             // Fill MCM status map
478             for(Int_t ii = 0; ii < 8; ii++) { //ROB loop
479               for(Int_t i = 0; i < 16; i++) { //MCM loop
480                 Double_t valss[6] = {sm,lay,stac,ii,i
481                                      ,calDCSFEEEOR->GetMCMGlobalState(ii,i)};
482                 fHnSparseMCM->Fill(&valss[0]);
483               }
484             } 
485           }
486         }
487     }
488     //---------//
489     //  Debug  //
490
491     //////////////////////////////////////////
492     // Change the status according to DCS
493     ///////////////////////////////////////////
494
495     // First put bad status if seen by DCS
496     /////////////////////////////////////////
497     if(stateA!=3 && stateA!=9 && stateB!=3 && stateB!=9) {
498       // completely masked from DCS
499       fCalChamberStatus->SetStatus(det,2);
500     }
501     if((stateA!=3 && stateA!=9) && (stateB==3 || stateB==9)) {
502       // Only A side masked from DCS
503       if(fCalChamberStatus->GetStatus(det) != 3) {
504         // But not from Data 
505         if(fCalChamberStatus->GetStatus(det) == 4) fCalChamberStatus->SetStatus(det,2);
506         if(fCalChamberStatus->GetStatus(det) <= 1) fCalChamberStatus->SetStatus(det,3);
507       }
508     }
509     if((stateA==3 || stateA==9) && (stateB!=3 && stateB!=9)) {
510       // Only B side masked from DCS
511       if(fCalChamberStatus->GetStatus(det) != 4) {
512         // But not from Data 
513         if(fCalChamberStatus->GetStatus(det) == 3) fCalChamberStatus->SetStatus(det,2);
514         if(fCalChamberStatus->GetStatus(det) <= 1) fCalChamberStatus->SetStatus(det,4);
515       }
516     }
517
518     // Then release in case of error 3 from DCS
519     /////////////////////////////////////////////
520     if(fCalChamberStatus->GetStatus(det)==2) {
521       if((stateA==3) && (stateB==3)) fCalChamberStatus->SetStatus(det,1);
522       if((stateA==3) && (stateB!=3)) fCalChamberStatus->SetStatus(det,4);
523       if((stateA!=3) && (stateB==3)) fCalChamberStatus->SetStatus(det,3);
524     }
525     if((fCalChamberStatus->GetStatus(det)==3) && (stateA==3)) fCalChamberStatus->SetStatus(det,1);
526     if((fCalChamberStatus->GetStatus(det)==4) && (stateB==3)) fCalChamberStatus->SetStatus(det,1);
527     
528   }
529
530 }
531
532 //_____________________________________________________________________________________
533 void AliTRDCalibChamberStatus::Add(AliTRDCalibChamberStatus *calibChamberStatus) /*FOLD00*/
534 {
535     //
536     //  Add the THnSparseI of this calibChamberStatus
537     //
538
539   fCounterEventNotEmpty += calibChamberStatus->GetNumberEventNotEmpty();
540
541   THnSparseI *hnSparseI = calibChamberStatus->GetSparseI();
542   if(!hnSparseI) return;
543
544   if(!fHnSparseI) {
545     fHnSparseI = (THnSparseI *) hnSparseI->Clone();
546   }
547   else {
548     fHnSparseI->Add(hnSparseI);
549   }
550   
551
552 }
553 //_____________________________________________________________________
554 void AliTRDCalibChamberStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
555 {
556     //
557     //  Write class to file
558     //
559
560     TString sDir(dir);
561     TString option;
562
563     if ( append )
564         option = "update";
565     else
566         option = "recreate";
567
568     TDirectory *backup = gDirectory;
569     TFile f(filename,option.Data());
570     f.cd();
571     if ( !sDir.IsNull() ){
572         f.mkdir(sDir.Data());
573         f.cd(sDir);
574     }
575     this->Write();
576     f.Close();
577
578     if ( backup ) backup->cd();
579 }
580