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