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