Add a protection againts runs with missing DCS information in the OCDB
[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 AliTRDCalDCSFEEv2 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 #include <TAxis.h>
36 #include <TH2F.h>
37 #include <TStyle.h>
38 #include <TCanvas.h>
39
40 //AliRoot includes
41 #include "AliRawReader.h"
42
43 //header file
44 #include "AliLog.h"
45 #include "AliTRDCalibChamberStatus.h"
46 #include "AliTRDgeometry.h"
47 #include "AliTRDfeeParam.h"
48 #include "AliTRDdigitsManager.h"
49 #include "AliTRDSignalIndex.h"
50 #include "AliTRDpadPlane.h"
51 #include "./Cal/AliTRDCalChamberStatus.h"
52 #include "./Cal/AliTRDCalDCSv2.h"
53 #include "./Cal/AliTRDCalDCSFEEv2.h"
54
55 #include "AliTRDrawStream.h"
56 #include "AliTRDseedV1.h"
57 #include "AliTRDcluster.h"
58
59 #ifdef ALI_DATE
60 #include "event.h"
61 #endif
62
63 ClassImp(AliTRDCalibChamberStatus) /*FOLD00*/
64
65 //_____________________________________________________________________
66 AliTRDCalibChamberStatus::AliTRDCalibChamberStatus() : /*FOLD00*/
67   TObject(),
68   fDetector(-1),
69   fNumberOfTimeBins(0),
70   fCounterEventNotEmpty(0),
71   fCalChamberStatus(0x0),
72   fHnSparseI(0x0),
73   fHnSparseHCM(0x0),
74   fHnSparseEvtDet(0x0),
75   fHnSparseDebug(0x0),
76   fHnSparseMCM(0x0),
77   fC1(0x0),
78   fDebugLevel(0)
79 {
80     //
81     // default constructor
82     //
83
84 }
85 //_____________________________________________________________________
86 AliTRDCalibChamberStatus::AliTRDCalibChamberStatus(const AliTRDCalibChamberStatus &ped) : /*FOLD00*/
87   TObject(ped),
88   fDetector(ped.fDetector),
89   fNumberOfTimeBins(ped.fNumberOfTimeBins),
90   fCounterEventNotEmpty(ped.fCounterEventNotEmpty),
91   fCalChamberStatus(ped.fCalChamberStatus),
92   fHnSparseI(ped.fHnSparseI),
93   fHnSparseHCM(ped.fHnSparseHCM),
94   fHnSparseEvtDet(ped.fHnSparseEvtDet),
95   fHnSparseDebug(ped.fHnSparseDebug),  
96   fHnSparseMCM(ped.fHnSparseMCM),
97   fC1(ped.fC1),
98   fDebugLevel(ped.fDebugLevel)
99 {
100     //
101     // copy constructor
102     //
103   
104 }
105 //_____________________________________________________________________
106 AliTRDCalibChamberStatus& AliTRDCalibChamberStatus::operator = (const  AliTRDCalibChamberStatus &source)
107 {
108   //
109   // assignment operator
110   //
111   if (&source == this) return *this;
112   new (this) AliTRDCalibChamberStatus(source);
113
114   return *this;
115 }
116 //_____________________________________________________________________
117 AliTRDCalibChamberStatus::~AliTRDCalibChamberStatus() /*FOLD00*/
118 {
119   //
120   // destructor
121   //
122   if(fCalChamberStatus){
123     delete fCalChamberStatus;
124   }
125   if(fHnSparseI) {
126     delete fHnSparseI;
127   }
128   if(fHnSparseHCM) {
129     delete fHnSparseHCM;
130   }
131   if(fHnSparseEvtDet) {
132     delete fHnSparseEvtDet;
133   }
134   if(fHnSparseDebug) {
135     delete fHnSparseDebug;
136   }
137   if(fHnSparseMCM) {
138    delete fHnSparseMCM;
139   }
140   if(fC1) {
141    delete fC1;
142   }
143 }
144
145 //_____________________________________________________________________
146 void AliTRDCalibChamberStatus::Init() 
147 {
148   //
149   // Init the different THnSparse
150   //
151   //
152
153   //
154   // Init the fHnSparseI
155   //
156
157   //create the map
158   Int_t thnDimEvt[4]; // sm, layer, stack, halfchamber
159   thnDimEvt[0] = 18;
160   thnDimEvt[1] = 6;
161   thnDimEvt[2] = 5;
162   thnDimEvt[3] = 2;
163   //arrays for lower bounds :
164   Double_t* binEdgesEvt[4];
165   for(Int_t ivar = 0; ivar < 4; ivar++)
166     binEdgesEvt[ivar] = new Double_t[thnDimEvt[ivar] + 1];
167   //values for bin lower bounds
168   for(Int_t i=0; i<=thnDimEvt[0]; i++) binEdgesEvt[0][i]= 0.0  + (18.0)/thnDimEvt[0]*(Double_t)i;
169   for(Int_t i=0; i<=thnDimEvt[1]; i++) binEdgesEvt[1][i]= 0.0  + (6.0)/thnDimEvt[1]*(Double_t)i;
170   for(Int_t i=0; i<=thnDimEvt[2]; i++) binEdgesEvt[2][i]= 0.0  + (5.0)/thnDimEvt[2]*(Double_t)i;
171   for(Int_t i=0; i<=thnDimEvt[3]; i++) binEdgesEvt[3][i]= 0.0  + (2.0)/thnDimEvt[3]*(Double_t)i;
172   
173   //create the THnSparse
174   fHnSparseI = new THnSparseI("NumberOfEntries","NumberOfEntries",4,thnDimEvt);
175   for (int k=0; k<4; k++) {
176     fHnSparseI->SetBinEdges(k,binEdgesEvt[k]);
177   }
178   fHnSparseI->Sumw2();
179
180   //
181   // Init the fHnSparseHCM (THnSparseI)
182   //
183
184   //create the THnSparse
185   fHnSparseHCM = new THnSparseI("HCMerrors","HCMerrors",4,thnDimEvt);
186   for (int k=0; k<4; k++) {
187     fHnSparseHCM->SetBinEdges(k,binEdgesEvt[k]);
188   }
189   fHnSparseHCM->Sumw2();
190
191
192   //---------//
193   //  Debug  //
194   if(fDebugLevel > 0) {
195   
196     //
197     // Init the fHnSparseEvtDet (THnSparseI)
198     //
199     
200     //create the map
201     Int_t thnDimEvts[3]; // event, detector, halfchamber
202     thnDimEvts[0] = 10000;
203     thnDimEvts[1] = 540;
204     thnDimEvts[2] = 2;
205     //arrays for lower bounds :
206     Double_t* binEdgesEvts[3];
207     for(Int_t ivar = 0; ivar < 3; ivar++)
208       binEdgesEvts[ivar] = new Double_t[thnDimEvts[ivar] + 1];
209     //values for bin lower bounds
210     for(Int_t i=0; i<=thnDimEvts[0]; i++) binEdgesEvts[0][i]= 0.0  + (10000.0)/thnDimEvts[0]*(Double_t)i;
211     for(Int_t i=0; i<=thnDimEvts[1]; i++) binEdgesEvts[1][i]= 0.0  + (540.0)/thnDimEvts[1]*(Double_t)i;
212     for(Int_t i=0; i<=thnDimEvts[2]; i++) binEdgesEvts[2][i]= 0.0  + (2.0)/thnDimEvts[2]*(Double_t)i;
213     
214     //create the THnSparse
215     fHnSparseEvtDet = new THnSparseI("NumberOfEntriesPerEvent","NumberOfEntriesPerEvent",3,thnDimEvts);
216     for (int k=0; k<3; k++) {
217       fHnSparseEvtDet->SetBinEdges(k,binEdgesEvts[k]);
218     }
219     fHnSparseEvtDet->Sumw2();
220
221     //
222     // Init the fHnSparseDebug (THnSparseI)
223     //
224     
225     //create the THnSparse
226     fHnSparseDebug = new THnSparseI("NumberOfDifferentDecisions","NumberOfDifferentDecisions",4,thnDimEvt);
227     for (int k=0; k<4; k++) {
228       fHnSparseDebug->SetBinEdges(k,binEdgesEvt[k]);
229     }
230     fHnSparseDebug->Sumw2();
231         
232     //
233     // Init the fHnSparseMCM (THnSparseI)
234     //
235     
236     //create the map
237     Int_t thnDimEvtt[6]; // sm, layer, stack, ROB, MCM
238     thnDimEvtt[0] = 18;
239     thnDimEvtt[1] = 6;
240     thnDimEvtt[2] = 5;
241     thnDimEvtt[3] = 8;
242     thnDimEvtt[4] = 18;
243     thnDimEvtt[5] = 18;
244     //arrays for lower bounds :
245     Double_t* binEdgesEvtt[6];
246     for(Int_t ivar = 0; ivar < 6; ivar++)
247       binEdgesEvtt[ivar] = new Double_t[thnDimEvtt[ivar] + 1];
248     //values for bin lower bounds
249     for(Int_t i=0; i<=thnDimEvtt[0]; i++) binEdgesEvtt[0][i]= 0.0  + (18.0)/thnDimEvtt[0]*(Double_t)i;
250     for(Int_t i=0; i<=thnDimEvtt[1]; i++) binEdgesEvtt[1][i]= 0.0  + (6.0)/thnDimEvtt[1]*(Double_t)i;
251     for(Int_t i=0; i<=thnDimEvtt[2]; i++) binEdgesEvtt[2][i]= 0.0  + (5.0)/thnDimEvtt[2]*(Double_t)i;
252     for(Int_t i=0; i<=thnDimEvtt[3]; i++) binEdgesEvtt[3][i]= 0.0  + (8.0)/thnDimEvtt[3]*(Double_t)i;
253     for(Int_t i=0; i<=thnDimEvtt[4]; i++) binEdgesEvtt[4][i]= 0.0  + (18.0)/thnDimEvtt[4]*(Double_t)i;
254     for(Int_t i=0; i<=thnDimEvtt[5]; i++) binEdgesEvtt[5][i]= 0.0  + (18.0)/thnDimEvtt[5]*(Double_t)i;
255     
256     //create the THnSparse
257     fHnSparseMCM = new THnSparseI("MCMerrorDCS","MCMerrorDCS",6,thnDimEvtt);
258     for (int k=0; k<6; k++) {
259       fHnSparseMCM->SetBinEdges(k,binEdgesEvtt[k]);
260     }
261     fHnSparseMCM->Sumw2();
262   
263   }
264   //  Debug  //
265   //---------//
266
267 }
268 //_____________________________________________________________________
269 void AliTRDCalibChamberStatus::ProcessTrack(const AliTRDtrackV1 * trdTrack)
270 {
271   //
272   // Track Processing to get half chamber status
273   //
274   //
275   
276   
277   const AliTRDseedV1 *tracklet = 0x0;
278   AliTRDcluster *cluster;
279   //////////////////////////////////////
280   // Loop tracklets
281   ///////////////////////////////////// 
282   for(Int_t itr = 0; itr < 6; ++itr){
283         
284     if(!(tracklet = trdTrack->GetTracklet(itr))) continue;
285     if(!tracklet->IsOK()) continue;
286   
287     // Loop on clusters
288     for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
289       if((cluster = tracklet->GetClusters(ic))) {
290         //printf("ic %d\n",ic);
291         break;
292       }
293     }
294     if(!cluster) continue;
295     
296     Int_t det     = cluster->GetDetector();       
297     Int_t layer   = AliTRDgeometry::GetLayer(det);
298     Int_t sm      = AliTRDgeometry::GetSector(det);
299     Int_t stac    = AliTRDgeometry::GetStack(det);
300     
301     Int_t col     = cluster->GetPadCol();
302     Int_t iMcm    = (Int_t)(col/18);   // current group of 18 col pads
303     Double_t rphi = 0.5;
304     if(iMcm > 3) rphi = 1.5;
305           
306     Double_t val[4] = {sm,layer,stac,rphi}; 
307     if(fHnSparseI->GetBinContent((const Int_t*)val)<2147483646) fHnSparseI->Fill(&val[0]); 
308   }
309   
310 }
311 //_____________________________________________________________________
312 void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics)
313 {
314   //
315   // Event Processing loop with AliTRDrawStream
316   //
317   //
318   
319   Bool_t notEmpty = kFALSE;
320     
321   AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
322   digitsManager->CreateArrays();
323   
324   AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader);
325   rawStream->SetDigitsManager(digitsManager);
326   //  rawStream->SetNoErrorWarning();
327   //  rawStream->SetSharedPadReadout(kFALSE);
328
329   
330   Int_t det    = 0;
331   while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { 
332
333     //nextchamber loop
334     
335     // do the QA analysis
336     if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
337       // printf("there is ADC data on this chamber!\n");
338       
339       AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det);
340       if (indexes->IsAllocated() == kFALSE) {
341         // AliError("Indexes do not exist!");
342         break;
343       }
344       
345       Int_t iRow  = 0;
346       Int_t iCol  = 0;
347       indexes->ResetCounters();
348       
349       while (indexes->NextRCIndex(iRow, iCol)){
350         Int_t iMcm        = (Int_t)(iCol/18);   // current group of 18 col pads
351         
352         Int_t layer = AliTRDgeometry::GetLayer(det);
353         Int_t sm    = AliTRDgeometry::GetSector(det);
354         Int_t stac  = AliTRDgeometry::GetStack(det);
355         Double_t rphi = 0.5;
356         if(iMcm > 3) rphi = 1.5;
357
358         Double_t val[4] = {sm,layer,stac,rphi}; 
359         fHnSparseI->Fill(&val[0]); 
360         notEmpty = kTRUE;
361         
362         //---------//
363         //  Debug  //
364         if(fDebugLevel > 0) {
365           Int_t detector = AliTRDgeometry::GetDetector(layer,stac,sm);
366           Double_t valu[3] = {nevents_physics,detector,rphi};
367           fHnSparseEvtDet->Fill(&valu[0]); 
368         }
369         //  Debug  //
370         //---------//
371       }
372       
373     }
374     digitsManager->ClearArrays(det);
375   }
376
377   if(notEmpty) fCounterEventNotEmpty++;
378
379   delete digitsManager;
380   delete rawStream;
381    
382 }
383 //_____________________________________________________________________
384 Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /*FOLD00*/
385 {
386   //
387   //  Test event loop
388   // fill the fHnSparseI with entries
389   //
390   
391   AliTRDgeometry geo;
392
393
394   for(Int_t ievent=0; ievent<nevent; ievent++){
395     for (Int_t ism=0; ism<18; ism++){
396       for (Int_t istack=0; istack<5; istack++){
397         for (Int_t ipl=0; ipl<6; ipl++){
398           for (Int_t icol=0; icol<geo.GetColMax(ipl); icol++){
399             Int_t side = 0;
400             if(icol > 72) side = 1;
401             Double_t val[4] = {ism,ipl,istack,side}; 
402             fHnSparseI->Fill(&val[0]); 
403           }
404         }
405       }
406     }
407   }
408   
409   return kTRUE;
410
411 }
412 //_____________________________________________________________________
413 void AliTRDCalibChamberStatus::AnalyseHisto(Int_t limit, Double_t chamberlimit) /*FOLD00*/
414 {
415   //
416   //  Create the AliTRDCalChamberStatus according to the fHnSparseI
417   //
418   
419   if(fCalChamberStatus) delete fCalChamberStatus;
420   fCalChamberStatus = new AliTRDCalChamberStatus();
421
422   //printf("test0\n");
423
424   // Check if enough events/tracklets per halfchamber to say something
425   Double_t mean=0.0; //number of tracklets per HCS
426   Int_t coord2[4];
427   for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
428     //if(fHnSparseI->GetBinContent(bin,coord2)==0.0) printf(" bin shouldnt be empty!!\n");
429     mean+=fHnSparseI->GetBinContent(bin,coord2);
430   }
431   if(fHnSparseI->GetNbins() > 0.0) mean/=fHnSparseI->GetNbins();
432   //printf(" mean tracklets per halfchamber %.3e \n",mean);
433   if((fCounterEventNotEmpty < limit) && (mean < limit)) {
434     // Say all good
435     for (Int_t idet=0; idet<540; idet++) {
436       fCalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kGood);
437     }
438     return;
439   }
440
441   //printf("test1\n");
442
443   // set all chambers to NoData
444   for (Int_t idet=0; idet<540; idet++) {
445     fCalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kNoData);
446   }
447
448   // set status according to fHnSparseI 
449   Int_t coord[4];
450   for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
451     
452     Double_t content = fHnSparseI->GetBinContent(bin,coord);
453     
454                 // layer, stack, sector
455     Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1);
456     
457                 if(content<chamberlimit*mean) {
458                         //printf("Number of entries for detector %03d-%s: %.3e -> %.3f \n",detector,(coord[3]-1==0?"A":"B"),content,content/mean);                      
459                         continue;
460                 }
461     //
462     // Check which halfchamber side corresponds to the bin number (0=A, 1=B)
463     // Change the status accordingly
464     //
465     if(coord[3]-1==0) { // HCS-A
466       fCalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
467       fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoDataHalfChamberSideA); // A has data
468       //fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoData); 
469     }
470     else { //HCS-B
471       fCalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
472       fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoDataHalfChamberSideB); // B has data
473       //fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoData); 
474     }
475   }
476
477   // printf
478   //for (Int_t idet=0; idet<540; idet++) {
479   //  if(fCalChamberStatus->IsNoData(idet)) printf("No Data: chamber %d\n",idet);
480   //}
481
482
483 }
484 //_____________________________________________________________________
485 void AliTRDCalibChamberStatus::CheckEORStatus(const AliTRDCalDCSv2 *calDCS) /*FOLD00*/
486 {
487   //
488   //  Correct the AliTRDCalChamberStatus according to the AliTRDCalDCSv2
489   //  Using globale state of the HalfChamberMerger (HCM)
490   //
491   for(Int_t det = 0; det < 540; det++) {
492     AliTRDCalDCSFEEv2* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det);
493
494     if(!calDCSFEEEOR) continue;
495     
496     // MCM Global State Machine State Definitions
497     //  low_power =  0,
498     //  test      =  1,
499     //  wait_pre  =  3,
500     //  preproc   =  7,
501     //  zero_sp   =  8,
502     //  full_rd   =  9,
503     //  clear_st  = 11,
504     //  wait_L1   = 12,
505     //  tr_send   = 14,
506     //  tr_proc   = 15 
507
508     Int_t sm   = AliTRDgeometry::GetSector(det);
509     Int_t lay  = AliTRDgeometry::GetLayer(det);
510     Int_t stac = AliTRDgeometry::GetStack(det);
511     
512     Int_t stateA = 0;   // 0=bad, 1=good state
513     Int_t stateB = 0;
514
515     // loop over all mcm to define DCS-HCS
516     for(Int_t ii = 0; ii < 8; ii++) { //ROB loop
517       for(Int_t i = 0; i < 18; i++) { //MCM loop
518         
519         Int_t side = ii%2;  // 0=sideA, 1=sideB
520         Int_t cstate = calDCSFEEEOR->GetMCMGlobalState(ii,i); //current mcm state
521         
522         if(cstate==3) {
523           switch(side) {
524           case 0: stateA=1; break;
525           case 1: stateB=1; break; 
526           }
527         }
528       }
529     }
530
531     //---------//
532     //  Debug  //
533     if(fDebugLevel > 0) {
534       if( ((fCalChamberStatus->GetStatus(det) <= 1) && (stateA==0 || stateB==0)) || 
535           ((fCalChamberStatus->GetStatus(det) == 2) && (stateA==1 || stateB==1)) || 
536           ((fCalChamberStatus->GetStatus(det) == 3) && (stateA==1 || stateB==0)) ||
537           ((fCalChamberStatus->GetStatus(det) == 4) && (stateB==0 || stateB==1))  )
538         {
539           //printf(" Different half chamber status in DCS and DATA!!\n");
540           Double_t val[4] = {sm,lay,stac,1};
541           fHnSparseDebug->Fill(&val[0]); 
542           
543           // Fill MCM status map
544           for(Int_t ii = 0; ii < 8; ii++) { //ROB loop
545             for(Int_t i = 0; i < 18; i++) { //MCM loop
546               Double_t valss[6] = {sm,lay,stac,ii,i
547                                    ,calDCSFEEEOR->GetMCMGlobalState(ii,i)};
548               fHnSparseMCM->Fill(&valss[0]);
549               
550             } 
551           }
552         }
553     }
554     //---------//
555     //  Debug  //
556
557     //---------------------------------------
558     // Change the status according to DCS
559     //---------------------------------------
560     Int_t statusData = fCalChamberStatus->GetStatus(det);
561     switch(statusData) 
562       {
563       case 1: 
564         if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS
565         if(stateA==1 && stateB==0) fCalChamberStatus->SetStatus(det,4); // Only B side masked from DCS
566         if(stateA==0 && stateB==1) fCalChamberStatus->SetStatus(det,3); // Only A side masked from DCS
567         if(stateA==1 && stateB==1) fCalChamberStatus->SetStatus(det,1);
568         break;
569       case 2: // completely masked from DATA
570         if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS
571         break;
572       case 3: // Only A side masked from DATA
573         if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS
574         if(stateA==1 && stateB==0) fCalChamberStatus->SetStatus(det,2); // Only B side masked from DCS
575         if(stateA==0 && stateB==1) fCalChamberStatus->SetStatus(det,3); // Only A side masked from DCS
576         if(stateA==1 && stateB==1) fCalChamberStatus->SetStatus(det,3);
577         break;
578       case 4: // Only B side masked from DATA
579         if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS
580         if(stateA==1 && stateB==0) fCalChamberStatus->SetStatus(det,4); // Only B side masked from DCS
581         if(stateA==0 && stateB==1) fCalChamberStatus->SetStatus(det,2); // Only A side masked from DCS
582         if(stateA==1 && stateB==1) fCalChamberStatus->SetStatus(det,4);
583         break;
584       }
585     
586   }
587
588 }
589
590 //_____________________________________________________________________________________
591 void AliTRDCalibChamberStatus::Add(const AliTRDCalibChamberStatus *calibChamberStatus) /*FOLD00*/
592 {
593     //
594     //  Add the THnSparseI of this calibChamberStatus
595     //
596
597   fCounterEventNotEmpty += calibChamberStatus->GetNumberEventNotEmpty();
598
599   THnSparseI *hnSparseI = calibChamberStatus->GetSparseI();
600   if(!hnSparseI) return;
601
602   if(!fHnSparseI) {
603     fHnSparseI = (THnSparseI *) hnSparseI->Clone();
604   }
605   else {
606     fHnSparseI->Add(hnSparseI);
607   }
608   
609
610 }
611 //_____________________________________________________________________
612 void AliTRDCalibChamberStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
613 {
614     //
615     //  Write class to file
616     //
617
618     TString sDir(dir);
619     TString option;
620
621     if ( append )
622         option = "update";
623     else
624         option = "recreate";
625
626     TDirectory *backup = gDirectory;
627     TFile f(filename,option.Data());
628     f.cd();
629     if ( !sDir.IsNull() ){
630         f.mkdir(sDir.Data());
631         f.cd(sDir);
632     }
633     this->Write();
634     f.Close();
635
636     if ( backup ) backup->cd();
637 }
638 //_____________________________________________________________________________
639 TH2D* AliTRDCalibChamberStatus::PlotSparseI(Int_t sm,Int_t side) 
640 {
641   //
642   // Plot number of entries for supermodule sm 
643   // as a function of layer and stack
644   //
645
646   if(!fHnSparseI) return 0x0;
647   
648   fHnSparseI->GetAxis(0)->SetRange(sm+1,sm+1); 
649   fHnSparseI->GetAxis(3)->SetRange(side+1,side+1);  
650   TH2D *h2 = fHnSparseI->Projection(1,2);
651  
652
653   return h2;
654
655 }
656 //_____________________________________________________________________
657 TH2F *AliTRDCalibChamberStatus::MakeHisto2DSmPlEORStatus(const AliTRDCalDCSv2 *calDCS, Int_t sm, Int_t pl) /*FOLD00*/
658 {
659   //
660   //  Plot globale state of the HalfChamberMerger (HCM)
661   //
662   AliTRDfeeParam *paramfee = AliTRDfeeParam::Instance();
663
664   AliTRDgeometry *trdGeo = new AliTRDgeometry();
665   AliTRDpadPlane *padPlane0 = trdGeo->GetPadPlane(pl,0);        // layer,stack
666   Double_t row0    = padPlane0->GetRow0();
667   Double_t col0    = padPlane0->GetCol0();
668
669   char  name[1000];
670   snprintf(name,1000,"%s DCS status sm %d pl %d",GetTitle(),sm,pl);
671   TH2F * his = new TH2F( name, name, 88,-TMath::Abs(row0),TMath::Abs(row0)
672                                    ,148,-TMath::Abs(col0),TMath::Abs(col0));
673
674
675   // Where we begin
676   Int_t offsetsmpl = 30*sm+pl;
677   Int_t nstack = 5;
678   Int_t ncols = 144;
679
680   for (Int_t k = 0; k < nstack; k++){
681     Int_t det = offsetsmpl+k*6;
682     Int_t stac = AliTRDgeometry::GetStack(det);
683     AliTRDCalDCSFEEv2* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det);
684     if(!calDCSFEEEOR) { continue;}
685     for (Int_t icol=0; icol<ncols; icol++){
686       Int_t nrows = 16;
687       if(stac==2) nrows = 12;
688       for (Int_t irow=0; irow<nrows; irow++){
689         Int_t binz     = 0;
690         Int_t kb       = 5-1-k;
691         Int_t krow     = nrows-1-irow;
692         Int_t kcol     = ncols-1-icol;
693         if(kb > 2) binz = 16*(kb-1)+12+krow+1+2*(kb+1);
694         else binz = 16*kb+krow+1+2*(kb+1); 
695         Int_t biny = kcol+1+2;
696         // Take the value
697         Int_t mcm = paramfee->GetMCMfromPad(irow,icol);
698         Int_t rob = paramfee->GetROBfromPad(irow,icol);
699         if(mcm < 0) AliWarning("Problem with mcm number");
700         Int_t state = calDCSFEEEOR->GetMCMGlobalState(rob,TMath::Abs(mcm)); 
701         his->SetBinContent(binz,biny,state);
702       }
703     }
704     for(Int_t icol = 1; icol < 147; icol++){
705       for(Int_t l = 0; l < 2; l++){
706         Int_t binz     = 0;
707         Int_t kb       = 5-1-k;
708         if(kb > 2) binz = 16*(kb-1)+12+1+2*(kb+1)-(l+1);
709         else binz = 16*kb+1+2*(kb+1)-(l+1); 
710         his->SetBinContent(binz,icol,16.0);
711       }
712     }
713   }
714   
715   for(Int_t icol = 1; icol < 147; icol++){
716     his->SetBinContent(88,icol,16.0);
717     his->SetBinContent(87,icol,16.0);
718   }
719   for(Int_t irow = 1; irow < 89; irow++){
720     his->SetBinContent(irow,1,16.0);
721     his->SetBinContent(irow,2,16.0);
722     his->SetBinContent(irow,147,16.0);
723     his->SetBinContent(irow,148,16.0);
724   }
725
726   his->SetXTitle("z (cm)");
727   his->SetYTitle("y (cm)");
728   his->SetMaximum(12);
729   his->SetMinimum(0.0);
730   his->SetStats(0);
731
732   return his;
733
734 }
735 //_____________________________________________________________________________
736 TCanvas* AliTRDCalibChamberStatus::PlotHistos2DSmEORStatus(AliTRDCalDCSv2 *calDCS, Int_t sm, const Char_t *name)
737 {
738   //
739   // Make 2D graph
740   //
741
742   gStyle->SetPalette(1);
743   fC1 = new TCanvas(name,name,50,50,600,800);
744   fC1->Divide(3,2);
745   fC1->cd(1);
746   MakeHisto2DSmPlEORStatus(calDCS,sm,0)->Draw("colz");
747   fC1->cd(2);
748   MakeHisto2DSmPlEORStatus(calDCS,sm,1)->Draw("colz");
749   fC1->cd(3);
750   MakeHisto2DSmPlEORStatus(calDCS,sm,2)->Draw("colz");
751   fC1->cd(4);
752   MakeHisto2DSmPlEORStatus(calDCS,sm,3)->Draw("colz");
753   fC1->cd(5);
754   MakeHisto2DSmPlEORStatus(calDCS,sm,4)->Draw("colz");
755   fC1->cd(6);
756   MakeHisto2DSmPlEORStatus(calDCS,sm,5)->Draw("colz");
757
758   return fC1;
759
760 }
761
762
763