Procedures for half chamber status (Julian)
[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->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