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