TPC/AliTPCMonitor.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 $Log$
  18 Revision 1.3  2007/10/12 13:36:27  cvetan
  19 Coding convention fixes from Stefan
  20
  21 Revision 1.2  2007/09/18 09:44:45  cvetan
  22 Sorting out some issues concerning the compilation with and without DATE support
  23
  24 Revision 1.1  2007/09/17 10:23:31  cvetan
  25 New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
  26
  27 */
  28
  29 ////////////////////////////////////////////////////////////////////////
  30 ////
  31 //// AliTPCMonitor class
  32 ////
  33 //// Main class for TPC Monitor
  34 //// Monitor can handle rootified data, files and online streams in DATE format.
  35 //// The monitor GUI is started by the macro TPCMonitor.C
  36 ////
  37 //// In the The data are read in in two read cycles.
  38 //// If no sector is specified (sectorid==-1) all sectors are read and only the max value
  39 //// for each channel is stored in a global histogram for Side A and C.
  40 //// In this way the whole TPC can be read in at once.
  41 ////
  42 //// If the sector is specified  only one sector is read in and additional quantities
  43 //// e.g baseline and baseline rms are calculated and stored.
  44 ////
  45 //// Author: Stefan Kniege, IKF, Frankfurt
  46 ////
  47 ////
  48 /////////////////////////////////////////////////////////////////////////
  49
  50
  51
  52 #include "AliLog.h"
  53 #include "AliTPCMonitor.h"
  54 #include "AliTPCMonitorMappingHandler.h"
  55 #include "AliTPCMonitorDateFile.h"
  56 #include "AliTPCMonitorDateFormat.h"
  57 #include "AliTPCMonitorAltro.h"
  58 #include "AliTPCMonitorFFT.h"
  59 #include "AliRawReaderRoot.h"
  60 #include "AliRawReader.h"
  61 #include "AliRawEventHeaderBase.h"
  62 #include "TH2F.h"
  63 #include "TF1.h"
  64 #include "TMath.h"
  65 #include "TCanvas.h"
  66 #include "TH3S.h"
  67 #include "TLegend.h"
  68 #include "TROOT.h"
  69 #include "TDirectory.h"
  70 #include "TSystem.h"
  71 #include "TPaveText.h"
  72 #include "TFile.h"
  73 #include <Riostream.h>
  74 #include "AliTPCMonitorDateMonitor.h"
  75
  76 ClassImp(AliTPCMonitor)
  77
  78 //____________________________________________________________________________
  79 AliTPCMonitor::AliTPCMonitor(char* name, char* title) :
  80   AliTPCMonitorConfig(name,title),
  81   fPad(new Int_t*[GetMaxHwAddr()]),
  82   fPadMapHw(new Float_t[GetMaxHwAddr()]),
  83   fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
  84   fHistIROC(0),
  85   fHistOROC(0),
  86   fHistIROCIndex(0),
  87   fHistOROCIndex(0),
  88   fHistIROCTime(0),
  89   fHistOROCTime(0),
  90   fHistIROCClone(0),
  91   fHistOROCClone(0),
  92   fHistIROCRMS(0),
  93   fHistOROCRMS(0),
  94   fHistIROCBASE(0),
  95   fHistOROCBASE(0),
  96   fHistIROCSUM(0),
  97   fHistOROCSUM(0),
  98   fHistChannelTime(0),
  99   fHistAddrMapIndex(0),
 100   fHistAddrMaxAdc(0),
 101   fHistAddrBaseMean(0),
 102   fHistAddrMaxAdcX(0),
 103   fHistAddrAdcSum(0),
 104   fHistAddrBaseRms(0),
 105   fHistDistrSumIROC(0),
 106   fHistDistrMaxIROC(0),
 107   fHistDistrSumOROC(0),
 108   fHistDistrMaxOROC(0),
 109   fHistDistrBase2dIROC(0),
 110   fHistDistrBase2dOROC(0),
 111   fHistDistrBaseRmsIROC(0),
 112   fHistDistrBaseMeanIROC(0),
 113   fHistDistrBaseRmsOROC(0),
 114   fHistDistrBaseMeanOROC(0),
 115   fHistGlobalMaxA(0),
 116   fHistGlobalMaxC(0),
 117   fHistList(new TObjArray()),
 118
 119   fkNRowsIroc(63),
 120   fkNRowsOroc(96),
 121
 122   fkNPadsIroc(110),
 123   fkNPadsOroc(140),
 124   fkNPadMinIroc(-55),
 125   fkNPadMinOroc(-70),
 126   fkNPadMaxIroc(55),
 127   fkNPadMaxOroc(70),
 128   fVerb(0),
 129   fLastEv(0),
 130   fEventNumber(0),
 131   fEventNumberOld(0),
 132   fDisableFit(0),
 133   fExecGlob(0),
 134   fExecPlaneMax(0),
 135   fExecPadIrocRms(0),
 136   fExecPadOrocRms(0),
 137   fRunId(0),
 138   fEqId(0),
 139   fPadUsedRoc(-1),
 140   fPadUsedHwAddr(-1),
 141   fGdcId(0),
 142   fLdcId(0),
 143   fLdcIdOld(1),
 144   fMapEqidsSec(new Int_t*[36]),
 145   fMapEqidsRcu(new Int_t[1000]),
 146   fMirror(1),
 147   fChannelIter(0),
 148   fMapHand(0),
 149   fReaderROOT(0),
 150   fReaderDATE(0),
 151   fReaderDATEMon(0)
 152 {
 153   // Constructor
 154
 155   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i]       = new Int_t[GetTimeBins()];}
 156   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
 157   for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i]       = new Int_t[6];}
 158
 159   if (gDirectory)
 160     {
 161       if (!gDirectory->GetList())
 162         {
 163           Warning("Build","Current directory is not a valid directory");
 164           return;
 165         }
 166       AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(GetName());
 167       if(hold)
 168         {
 169           Warning("Build","Replacing existing histogram: %s (Potential memory leak).",GetName());
 170           gDirectory->GetList()->Remove(hold);
 171         }
 172       gDirectory->Append(this);
 173     }
 174   CreateHistos();
 175   SetEqIds();
 176
 177 }
 178
 179 //____________________________________________________________________________
 180 AliTPCMonitor::AliTPCMonitor(const AliTPCMonitor &monitor):
 181   AliTPCMonitorConfig(monitor.GetName(),monitor.GetTitle()),
 182   fPad(new Int_t*[GetMaxHwAddr()]),
 183   fPadMapHw(new Float_t[GetMaxHwAddr()]),
 184   fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
 185   fHistIROC(0),
 186   fHistOROC(0),
 187   fHistIROCIndex(0),
 188   fHistOROCIndex(0),
 189   fHistIROCTime(0),
 190   fHistOROCTime(0),
 191   fHistIROCClone(0),
 192   fHistOROCClone(0),
 193   fHistIROCRMS(0),
 194   fHistOROCRMS(0),
 195   fHistIROCBASE(0),
 196   fHistOROCBASE(0),
 197   fHistIROCSUM(0),
 198   fHistOROCSUM(0),
 199   fHistChannelTime(0),
 200   fHistAddrMapIndex(0),
 201   fHistAddrMaxAdc(0),
 202   fHistAddrBaseMean(0),
 203   fHistAddrMaxAdcX(0),
 204   fHistAddrAdcSum(0),
 205   fHistAddrBaseRms(0),
 206   fHistDistrSumIROC(0),
 207   fHistDistrMaxIROC(0),
 208   fHistDistrSumOROC(0),
 209   fHistDistrMaxOROC(0),
 210   fHistDistrBase2dIROC(0),
 211   fHistDistrBase2dOROC(0),
 212   fHistDistrBaseRmsIROC(0),
 213   fHistDistrBaseMeanIROC(0),
 214   fHistDistrBaseRmsOROC(0),
 215   fHistDistrBaseMeanOROC(0),
 216   fHistGlobalMaxA(0),
 217   fHistGlobalMaxC(0),
 218   fHistList(new TObjArray()),
 219   fkNRowsIroc(monitor.fkNRowsIroc),
 220   fkNRowsOroc(monitor.fkNRowsOroc),
 221   fkNPadsIroc(monitor.fkNPadsIroc),
 222   fkNPadsOroc(monitor.fkNPadsOroc),
 223   fkNPadMinIroc(monitor.fkNPadMinIroc),
 224   fkNPadMinOroc(monitor.fkNPadMinOroc),
 225   fkNPadMaxIroc(monitor.fkNPadMaxIroc),
 226   fkNPadMaxOroc(monitor.fkNPadMaxOroc),
 227   fVerb(monitor.fVerb),
 228   fLastEv(monitor.fLastEv),
 229   fEventNumber(monitor.fEventNumber),
 230   fEventNumberOld(monitor.fEventNumberOld),
 231   fDisableFit(monitor.fDisableFit),
 232   fExecGlob(monitor.fExecGlob),
 233   fExecPlaneMax(monitor.fExecPlaneMax),
 234   fExecPadIrocRms(monitor.fExecPadIrocRms),
 235   fExecPadOrocRms(monitor.fExecPadOrocRms),
 236   fRunId(monitor.fRunId),
 237   fEqId(monitor.fEqId),
 238   fPadUsedRoc(monitor.fPadUsedRoc),
 239   fPadUsedHwAddr(monitor.fPadUsedHwAddr),
 240   fGdcId(monitor.fGdcId),
 241   fLdcId(monitor.fLdcId),
 242   fLdcIdOld(monitor.fLdcIdOld),
 243   fMapEqidsSec(new Int_t*[36]),
 244   fMapEqidsRcu(new Int_t[1000]),
 245   fMirror(monitor.fMirror),
 246   fChannelIter(monitor.fChannelIter),
 247   fMapHand(monitor.fMapHand),
 248   fReaderROOT(monitor.fReaderROOT),
 249   fReaderDATE(monitor.fReaderDATE),
 250   fReaderDATEMon(monitor.fReaderDATEMon)
 251 {
 252   // copy constructor
 253
 254   fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
 255   fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
 256   fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
 257   fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
 258   fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
 259   fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
 260   fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
 261   fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
 262   fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
 263   fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
 264   fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
 265   fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
 266   fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
 267   fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
 268
 269   fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
 270
 271   fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
 272   fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
 273   fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
 274   fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
 275   fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
 276   fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
 277
 278
 279   fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
 280   fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
 281   fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
 282   fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
 283
 284   fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
 285   fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
 286   fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
 287   fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
 288   fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
 289   fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
 290
 291   fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
 292   fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
 293
 294   // fPad       = new Int_t*[monitor.GetMaxHwAddr()];
 295   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i]       = new Int_t[monitor.GetTimeBins()];}
 296
 297   //fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
 298   for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
 299
 300   //fPadMapHw  = new Float_t[monitor.GetMaxHwAddr()];
 301
 302   //fMapEqidsRcu   = new Int_t[1000];
 303   //fMapEqidsSec   = new Int_t*[36];
 304   for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i]       = new Int_t[6];}
 305   SetEqIds();
 306
 307   if (gDirectory)
 308     {
 309       if (!gDirectory->GetList())
 310         {
 311           Warning("Build","Current directory is not a valid directory");
 312
 313         }
 314       else
 315         {
 316           AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
 317           if(hold)
 318             {
 319               Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
 320               gDirectory->GetList()->Remove(hold);
 321             }
 322           gDirectory->Append(this);
 323         }
 324      }
 325 }
 326
 327
 328 //____________________________________________________________________________
 329
 330 AliTPCMonitor &AliTPCMonitor:: operator= (const AliTPCMonitor& monitor)
 331 {
 332   // assigment operator
 333   if(this!=&monitor)
 334     {
 335       ((AliTPCMonitorConfig *)this)->operator=(monitor);
 336       fkNRowsIroc=monitor.fkNRowsIroc;
 337       fkNRowsOroc=monitor.fkNRowsOroc;
 338       fkNPadsIroc=monitor.fkNPadsIroc;
 339       fkNPadsOroc=monitor.fkNPadsOroc;
 340       fkNPadMinIroc=monitor.fkNPadMinIroc;
 341       fkNPadMinOroc=monitor.fkNPadMinOroc;
 342       fkNPadMaxIroc=monitor.fkNPadMaxIroc;
 343       fkNPadMaxOroc=monitor.fkNPadMaxOroc;
 344       fVerb=monitor.fVerb;
 345       fLastEv=monitor.fLastEv;
 346       fEventNumber=monitor.fEventNumber;
 347       fEventNumberOld=monitor.fEventNumberOld;
 348       fDisableFit=monitor.fDisableFit;
 349       fExecGlob=monitor.fExecGlob;
 350       fExecPlaneMax=monitor.fExecPlaneMax;
 351       fExecPadIrocRms=monitor.fExecPadIrocRms;
 352       fExecPadOrocRms=monitor.fExecPadOrocRms;
 353       fRunId=monitor.fRunId;
 354       fEqId=monitor.fEqId;
 355       fPadUsedRoc=monitor.fPadUsedRoc;
 356       fPadUsedHwAddr=monitor.fPadUsedHwAddr;
 357       fGdcId=monitor.fGdcId;
 358       fLdcId=monitor.fLdcId;
 359       fLdcIdOld=monitor.fLdcIdOld;
 360       fMapHand=monitor.fMapHand;
 361       fReaderROOT=monitor.fReaderROOT;
 362       fReaderDATE=monitor.fReaderDATE;
 363
 364
 365       fHistList = new TObjArray();
 366       fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
 367       fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
 368       fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
 369       fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
 370       fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
 371       fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
 372       fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
 373       fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
 374       fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
 375       fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
 376       fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
 377       fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
 378       fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
 379       fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
 380
 381       fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
 382
 383       fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
 384       fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
 385       fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
 386       fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
 387       fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
 388       fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
 389
 390
 391       fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
 392       fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
 393       fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
 394       fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
 395
 396       fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
 397       fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
 398       fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
 399       fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
 400       fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
 401       fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
 402
 403       fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
 404       fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
 405
 406       fPad       = new Int_t*[monitor.GetMaxHwAddr()];
 407       for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i]       = new Int_t[monitor.GetTimeBins()];}
 408
 409       fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
 410       for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
 411
 412       fPadMapHw  = new Float_t[monitor.GetMaxHwAddr()];
 413
 414       fMapEqidsRcu   = new Int_t[1000];
 415       fMapEqidsSec   = new Int_t*[36];
 416       for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i]       = new Int_t[6];}
 417       SetEqIds();
 418
 419       if (gDirectory)
 420         {
 421           if (!gDirectory->GetList())
 422             {
 423               Warning("Build","Current directory is not a valid directory");
 424               return  *this;
 425             }
 426           AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
 427           if(hold)
 428             {
 429               Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
 430               gDirectory->GetList()->Remove(hold);
 431             }
 432           gDirectory->Append(this);
 433         }
 434       fReaderDATEMon=monitor.fReaderDATEMon;
 435     }
 436   return *this;
 437 }
 438
 439
 440 //____________________________________________________________________________
 441 AliTPCMonitor::~AliTPCMonitor()
 442 {
 443   // Destructor
 444
 445   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPad[i] ;}
 446   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPadMapRCU[i];}
 447   delete[] fPadMapHw ;
 448   DeleteHistos();
 449 }
 450
 451 //____________________________________________________________________________
 452 void AliTPCMonitor::CreateHistos()
 453 {
 454   // Create histograms to be displayed
 455
 456   if(fVerb) cout << " create new ones " << endl;
 457   fHistIROC            = new TH2F("fHistIROC"            ,"fHistIROC"           ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROC);
 458   fHistOROC            = new TH2F("fHistOROC"            ,"fHistOROC"           ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROC);
 459
 460   fHistIROCIndex       = new TH2S("fHistIROCIndex"       ,"fHistIROCIndex"      ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCIndex);
 461   fHistOROCIndex       = new TH2S("fHistOROCIndex"       ,"fHistOROCIndex"      ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCIndex);
 462
 463   fHistIROCTime        = new TH2F("fHistIROCTime"        ,"fHistIROCTime"       ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCTime);
 464   fHistOROCTime        = new TH2F("fHistOROCTime"        ,"fHistOROCTime"       ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCTime);
 465
 466   fHistIROCRMS         = new TH2F("fHistIROCRMS"         ,"fHistIROCRMS"        ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCRMS);
 467   fHistOROCRMS         = new TH2F("fHistOROCRMS"         ,"fHistOROCRMS"        ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCRMS);
 468
 469   fHistIROCSUM         = new TH2F("fHistIROCSUM"         ,"fHistIROCSUM"        ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCSUM);
 470   fHistOROCSUM         = new TH2F("fHistOROCSUM"         ,"fHistOROCSUM"        ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCSUM);
 471
 472   fHistIROCBASE        = new TH2F("fHistIROCBASE"        ,"fHistIROCBASE"       ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCBASE);
 473   fHistOROCBASE        = new TH2F("fHistOROCBASE"        ,"fHistOROCBASE"       ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCBASE);
 474
 475
 476   fHistChannelTime     = new TH2F("fHistChannelTime"     ,"fHistChannelTime"    ,GetNumOfChannels(),0,GetNumOfChannels(),GetTimeBins(),0,GetTimeBins());fHistList->Add(fHistChannelTime);
 477   fHistAddrMapIndex    = new TH1F("fHistAddrMapIndex"    ,"fHistAddrMapIndex"   ,GetMaxHwAddr()    ,0,GetMaxHwAddr());                                  fHistList->Add(fHistAddrMapIndex);
 478   fHistAddrMaxAdc      = new TH1F("fHistAddrMaxAdc"      ,"fHistAddrMaxAdc"     ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrMaxAdc);
 479   fHistAddrMaxAdcX     = new TH1F("fHistAddrMaxAdcX"     ,"fHistAddrMaxAdcX"    ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrMaxAdcX);
 480   fHistAddrBaseMean    = new TH1F("fHistAddrBaseMean"    ,"fHistAddrBaseMean"   ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrBaseMean);
 481   fHistAddrAdcSum      = new TH1F("fHistAddrAdcSum"      ,"fHistAddrAdcSum"     ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrAdcSum);
 482   fHistAddrBaseRms     = new TH1F("fHistAddrBaseRms"     ,"fHistAddrBaseRms"    ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrBaseRms);
 483   fHistDistrSumIROC    = new TH1F("fHistDistrSumIROC"    ,"fHistDistrSumIROC"   ,400,0.0,4000.0);                                                       fHistList->Add(fHistDistrSumIROC);
 484   fHistDistrMaxIROC    = new TH1F("fHistDistrMaxIROC"    ,"fHistDistrMaxIROC"   ,500,0.0,1000.0);                                                       fHistList->Add(fHistDistrMaxIROC);
 485   fHistDistrSumOROC    = new TH1F("fHistDistrSumOROC"    ,"fHistDistrSumOROC"   ,400,0.0,4000.0);                                                       fHistList->Add(fHistDistrSumOROC);
 486   fHistDistrMaxOROC    = new TH1F("fHistDistrMaxOROC"    ,"fHistDistrMaxOROC"   ,500,0.0,1000.0);                                                       fHistList->Add(fHistDistrMaxOROC);
 487
 488   fHistDistrBase2dIROC = new TH2F("fHistDistrBase2dIROC" ,"fHistDistrBase2dIROC",100,0.0,100.0,100,0.0,10.0);                                           fHistList->Add(fHistDistrBase2dIROC);
 489   fHistDistrBase2dOROC = new TH2F("fHistDistrBase2dOROC" ,"fHistDistrBase2dOROC",100,0.0,100.0,100,0.0,10.0);                                           fHistList->Add(fHistDistrBase2dOROC);
 490
 491   fHistGlobalMaxA      = new TH2S("SIDE A"               ,"SIDE A"              ,500,-3000,3000,500,-3000,3000);                                        fHistList->Add(fHistGlobalMaxA);
 492   fHistGlobalMaxC      = new TH2S("SIDE C"               ,"SIDE C"              ,500,-3000,3000,500,-3000,3000);                                        fHistList->Add(fHistGlobalMaxC);
 493
 494   ResetArrays();
 495 }
 496 //____________________________________________________________________________
 497 Int_t AliTPCMonitor::ProcessEvent()
 498 {
 499   // Process Event
 500   // Depending on the value of the sector id all sectors (sectorid == -1) are processed.
 501   //
 502   // In this case only the maximum values are calculated per pad and filled to the global histograms
 503   // In a second loop the last processed(displayed) sector will be processed (sectorid!=-1)
 504   // again and the baseline rms and further quantities are calculated
 505   //
 506   // If only one sector should be processed SetProcOneSector(1) should be set.
 507   // In this case only the specified (last/last displayed) sector will be processed.
 508   //
 509   // If GetProcNextEvent()==0 the same event will be processed again
 510
 511
 512   Int_t sectorid = 0;
 513   Int_t retflag  = 0; // id of last sector + 1000,  or error flag
 514   if(GetProcNextEvent()==1 && fLastEv) { AliInfo("Last event already processed"); }
 515   if(GetProcNextEvent()==1) ResetSectorArray();
 516
 517
 518   if(GetProcNextEvent()==0 || GetProcOneSector()==1 ) sectorid = GetLastSector();
 519   else                                                sectorid = -1;
 520
 521   // first iteration
 522   retflag = ReadData(sectorid);
 523
 524   SetLastProcFile(GetFile());
 525
 526   if(retflag>=10 && retflag<1000){ AliError("Could not read event properly: Check file name and format or try next event");  return 0  ;}
 527
 528   DrawHists(3);
 529
 530   // second iteration
 531   if(sectorid==-1 && retflag >1000)
 532     {
 533       AliInfo("Second read cycle");
 534       SetProcNextEvent(0);
 535       if(GetLastSectorDisplayed()==-1) {sectorid =  GetLastSector()         ;    }
 536       else                             {sectorid =  GetLastSectorDisplayed();  SetLastSector(sectorid)           ;  }
 537       retflag = ReadData(sectorid);
 538     }
 539
 540   SetLastSectorDisplayed(sectorid)  ;
 541   fMapHand->ReadfecHwMap(GetLastSector());
 542   FillHistsPadPlane();
 543   DrawHists(1);
 544   SetEventProcessed(1);
 545   return retflag;
 546 }
 547
 548 //__________________________________________________________________
 549 Int_t AliTPCMonitor::ReadData(Int_t secid)
 550 {
 551   // Read Data File/Stream  for specified Format.
 552   // Payload will be extracted from either ROOT or DATE format
 553   // and passed to FillHistsDecode for decoding of the adc information
 554
 555   Int_t format = GetFormat();
 556
 557
 558   //if(format==2 && !gSystem->Getenv("DATE_ROOT")) {   AliError("DATE not initialized on this system"); return  11;}
 559
 560   if(     format==0) {return  ReadDataROOT(secid);}
 561   else if(format==1) {return  ReadDataDATEFile(secid);}
 562   else if(format==2)
 563     {
 564       return  ReadDataDATEStream(secid);
 565     }
 566
 567   AliWarning("Function should already be left");
 568   return 11;
 569 }
 570 //__________________________________________________________________
 571 Int_t AliTPCMonitor::ReadDataDATEFile(Int_t secid)
 572 {
 573   // Read Data in Date format.
 574   // Date file and monitor will be handled in this function.
 575
 576   if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0;}
 577
 578 #ifdef ALI_DATE
 579   if(fReaderDATEMon) { delete fReaderDATEMon ; fReaderDATEMon=0;}
 580 #endif
 581
 582   Char_t*                  eventPtr = 0;
 583   AliTPCMonitorDateFormat* dateform = 0;
 584
 585   // Create objects //
 586   if( fReaderDATE==0 || ( fReaderDATE!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) )  )
 587     {
 588       cout << " Create new DATE file "<< endl;
 589       if(fReaderDATE)  { delete fReaderDATE ; fReaderDATE=0; }
 590       fReaderDATE = new AliTPCMonitorDateFile() ;
 591       fReaderDATE->SetName("fReaderDATE") ;
 592       fReaderDATE->OpenDateFile(GetFile()) ;
 593       fEventNumber =0;
 594     }
 595
 596   // Get Event pointer ///
 597   if(fReaderDATE->IsDateFileOpen() ==false )  { AliError("Could not open Date File"); return  11 ; }
 598   // Rewind event if new event number is smaller than old one
 599   if(fEventNumberOld>fEventNumber )           { fReaderDATE->ResetFilePos(); }
 600   while(GetProcNextEvent() || fEventNumber==0)
 601     {
 602       fReaderDATE->ReadEvent();
 603       eventPtr  = fReaderDATE->GetMemoryPointer();
 604       dateform = new AliTPCMonitorDateFormat(eventPtr);
 605       Int_t currentev =  dateform->GetEventID();
 606       if(fEventNumber <= currentev ){  break; }
 607     }
 608
 609   eventPtr  = fReaderDATE->GetMemoryPointer();
 610
 611   if(dateform==0) dateform = new AliTPCMonitorDateFormat(eventPtr);
 612   fEventNumber     =  dateform->GetEventID();
 613   fEventNumberOld  =  dateform->GetEventID();
 614
 615   if(fReaderDATE->IsLastEvent()) fLastEv =1;
 616   if(dateform->IsEventEndOfRun()) {  AliInfo("Event is end of run: eventType END_OF_RUN "); }
 617
 618   if(fReaderDATE->IsEventValid()       == false )   {AliInfo("Skipping Event because invalid");                     return 10;   }
 619   if(dateform->IsEventPhysicsEvent()   == false )   {AliInfo("Skipping Header/event because not Physics event");    return 12;   }
 620
 621   ResetHistos() ;
 622
 623   Int_t lastrcu = ReadDataDATESubEventLoop(dateform,secid);
 624
 625   delete dateform;
 626   if(fVerb) cout << " last rcu " << lastrcu << endl;
 627   return lastrcu;
 628 }
 629
 630
 631 #ifdef ALI_DATE
 632 //__________________________________________________________________
 633 Int_t AliTPCMonitor::ReadDataDATEStream(Int_t secid)
 634 {
 635   // Read Data from DATE stream.
 636   // Can also be used for DATE file.
 637
 638
 639   if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0;}
 640   if(fReaderDATE) { delete fReaderDATE    ; fReaderDATE   =0; }
 641
 642   Char_t*                  eventPtr         = 0;
 643
 644   AliTPCMonitorDateFormat* dateform =0 ;
 645
 646   // Create objects ///
 647   if((fReaderDATEMon==0 || ( fReaderDATEMon!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) )))
 648     {
 649       if(fReaderDATEMon!=0)
 650         {
 651           fReaderDATEMon->Logout();
 652           delete fReaderDATEMon;
 653         }
 654       fReaderDATEMon  = new AliTPCMonitorDateMonitor();
 655       fReaderDATEMon->SetName("DMon");
 656       Int_t status = fReaderDATEMon->OpenMonitoring(GetFile());
 657       if(status) {  AliError(Form("Could not read event online: Error: %s",fReaderDATEMon->DecodeError(status))); return 11; }
 658     }
 659
 660   if(GetProcNextEvent())
 661     {
 662       fReaderDATEMon->Free();
 663       Int_t status = fReaderDATEMon->GetEvent();
 664       if(status) {  AliError(Form("Could not read event online: Error: %s",fReaderDATEMon->DecodeError(status))); return 11 ;}
 665       //fReaderDATEMon->Logout();
 666     }
 667
 668   eventPtr  = fReaderDATEMon->GetEventPointerasChar();
 669
 670   if(dateform==0) dateform = new AliTPCMonitorDateFormat(eventPtr);
 671   fEventNumber     =  dateform->GetEventID();
 672   fEventNumberOld  =  dateform->GetEventID();
 673
 674   if(dateform->IsEventEndOfRun()) {  AliInfo("Event is end of run: eventType END_OF_RUN "); }
 675   if(dateform->IsEventPhysicsEvent()      == false  )  {AliInfo("Skipping Header/event because not Physics event");    return 12;   }
 676
 677   ResetHistos() ;
 678
 679   Int_t lastrcu = ReadDataDATESubEventLoop(dateform,secid);
 680
 681   delete dateform;
 682   if(fVerb) cout << " last rcu " << lastrcu << endl;
 683   return lastrcu;
 684 }
 685 #else
 686 //__________________________________________________________________
 687 Int_t AliTPCMonitor::ReadDataDATEStream(Int_t /*secid*/)
 688 {
 689   // Read Data from DATE stream.
 690   // Can also be used for DATE file.
 691   // In case DATE is not install
 692   // this method is dummy
 693
 694   AliError("DATE not initialized on this system");
 695   return  11;
 696 }
 697 #endif
 698
 699 Int_t AliTPCMonitor::ReadDataDATESubEventLoop(AliTPCMonitorDateFormat* dateform, Int_t secid)
 700 {
 701   // Loop over DATE Subevents
 702
 703   Bool_t                   exitSubEventLoop = false;
 704   Int_t                    lastrcuid      = 0;
 705   Int_t                    lasteq          = 0;
 706   Int_t                    start            = 1;
 707   Int_t                    rcupatch        = 0;
 708   Char_t*                  eventPtr         = 0;
 709   UInt_t*                  eventPtrUI       = 0;
 710
 711   fChannelIter =0;
 712
 713   while(exitSubEventLoop == false)
 714     {
 715       if(start==1) { dateform->GotoSubEventHeader()    ;  start=0;}
 716       else         { dateform->GotoNextSubEventHeader();          }
 717       if(dateform->IsLastSubEventHeader()) exitSubEventLoop = true;
 718
 719       if(fVerb) cout << " next subevent LDC " << (Int_t)dateform->GetSubEventLDC() <<  endl;
 720
 721       lasteq    = 0 ;
 722       Int_t neq  = 0 ;
 723
 724       while(lasteq==0)
 725         {
 726           if(neq ==0){ dateform->GotoFirstEquipment();}
 727           else       { dateform->GotoNextEquipment();}
 728
 729           fGdcId      = dateform->GetSubEventGDC() ;
 730           fLdcId      = dateform->GetSubEventLDC();
 731           fRunId      = dateform->GetEventRunID();
 732           fEqId       = dateform->GetEquipmentID();
 733           rcupatch   = GetRCUPatch(fRunId, fEqId);
 734           lastrcuid = (rcupatch+1000);
 735           neq++;
 736
 737           if(fLdcIdOld!=fLdcId &&  fChannelIter!=0) {
 738             if(secid==-1)
 739               {
 740                 FillGlobal(GetLastSector());
 741                 ResetArrays();
 742                 fChannelIter =0;
 743               }
 744             else
 745               {
 746                 return lastrcuid;
 747               }
 748           }
 749           fLdcIdOld = fLdcId ;
 750
 751
 752           if(dateform->IsLastEquipment() != false )  lasteq = 1;
 753
 754           eventPtr = dateform->GetFirstDataPointer();
 755           eventPtrUI = (UInt_t *) eventPtr;
 756           Int_t payload = dateform->GetPayloadSize(); // 40Bit words
 757
 758           if(fVerb)DumpHeader(dateform);
 759           if(fVerb) cout << "Check sector and fEqId  " << endl;
 760
 761           if(fVerb && secid >0 )
 762             {
 763               cout << "secid : "<< secid  << " fEqId "<<  fEqId << " equipment 0 form map  "  << endl;
 764               cout <<  fMapEqidsSec[secid][0] <<  endl;
 765               cout << " showed map_eqids " << endl;
 766             }
 767
 768           if(CheckEqId(secid,fEqId))
 769             {
 770               if(fVerb) cout << " init altro " << endl;
 771               AliTPCMonitorAltro* altro  = new AliTPCMonitorAltro((UInt_t *)eventPtrUI,(payload/4),1); //hier
 772               altro->SetWrite10Bit(GetWrite10Bit());
 773               altro->SetActFilename(GetFile());
 774               if(fVerb) cout << " allocated 10bit " << endl;
 775               altro->Allocate10BitArray();
 776               altro->Decodeto10Bit(fEqId);
 777               AliInfo(Form("Process eqid %i , patch %i ",fEqId,rcupatch%6));
 778               FillHistsDecode(altro,(rcupatch%6),secid);
 779               if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
 780               delete altro;
 781             }// if(CheckID)
 782         }// while last eq
 783       SetLastSector(rcupatch/6);
 784     }
 785   if(fChannelIter!=0 && secid==-1){ FillGlobal(GetLastSector()); }
 786   return lastrcuid;
 787
 788 }
 789 //__________________________________________________________________
 790 Int_t AliTPCMonitor::ReadDataROOT(Int_t secid)
 791 {
 792   // Read in data in ROOT format
 793   if(fReaderDATE){ delete fReaderDATE ; fReaderDATE=0;}
 794   fChannelIter =0;
 795   Int_t           lastrcuid   = 0;
 796   Int_t           rcupatch     = 0;
 797   Int_t           equipmentSize = 0;
 798   UChar_t*        eventPtr      = 0 ;
 799   UInt_t*         eventPtrUI    = 0 ;
 800   Int_t           evtype        = 0;
 801
 802   if(fReaderROOT==0 || ( fReaderROOT!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) )  )
 803     {
 804       if(fVerb) cout << "AliTPCMonitor::ReadDataROOT create new reader " << endl;
 805       if(fReaderROOT)  { delete fReaderROOT ; fReaderROOT=0; }
 806       fReaderROOT = new AliRawReaderRoot(GetFile());
 807       if(!fReaderROOT) { AliError("Could not initiate  AliRawReaderRoo "); return 10;}
 808       fEventNumber=0;
 809     }
 810
 811   // reset to beginning of the event
 812   fReaderROOT->Reset();
 813
 814   // Rewind event if new event number is smaller than old one
 815   if(fEventNumberOld>fEventNumber) fReaderROOT->RewindEvents();
 816
 817   while(GetProcNextEvent() || fEventNumber==0)
 818   {
 819     if(fVerb) cout << "AliTPCMonitor::ReadDataROOT get event " << endl;
 820     if(!fReaderROOT->NextEvent()) { AliError("Could not get next Event"); return 11 ;}
 821 //       Int_t currentev =  *(fReaderROOT->GetEventId());
 822       //!! think about
 823     Int_t currentev=fReaderROOT->GetEventIndex();
 824 //      break;
 825       // skip all events but physics, calibration and software trigger events!
 826     UInt_t eventType=fReaderROOT->GetType();
 827     if ( !(eventType==AliRawEventHeaderBase::kPhysicsEvent ||
 828            eventType==AliRawEventHeaderBase::kCalibrationEvent ||
 829            eventType==AliRawEventHeaderBase::kSystemSoftwareTriggerEvent ||
 830            eventType==AliRawEventHeaderBase::kDetectorSoftwareTriggerEvent) ) {
 831       if (fVerb) cout<< "Skipping event! Its neither of 'physics, calibration and software trigger event'" << endl;
 832       continue;
 833            }
 834            if(fEventNumber <= currentev ){  break; }
 835   }
 836
 837 //   fEventNumber     =  *(fReaderROOT->GetEventId());
 838 //   fEventNumberOld  =  *(fReaderROOT->GetEventId());
 839   fEventNumber = fReaderROOT->GetEventIndex();
 840   fEventNumberOld = fReaderROOT->GetEventIndex();
 841
 842   ResetHistos() ;
 843
 844   while(fReaderROOT->ReadHeader())
 845     {
 846       if(fVerb) cout << "AliTPCMonitor::ReadDataROOT read header " << endl;
 847       fGdcId        = fReaderROOT->GetGDCId() ;
 848       fLdcId        = fReaderROOT->GetLDCId() ;
 849       fRunId        = fReaderROOT->GetRunNumber() ;
 850       equipmentSize = fReaderROOT->GetEquipmentSize();
 851       fEqId         = fReaderROOT->GetEquipmentId();
 852       evtype        = fReaderROOT->GetType();
 853       rcupatch     = GetRCUPatch(fRunId, fEqId);
 854       lastrcuid   = (rcupatch+1000);
 855
 856       if(evtype==1)        { AliWarning(Form("EventType==1 in event %i ",fEventNumber)); return 10; }
 857       if(equipmentSize==0) { AliWarning(Form("Equipmentsize ==0  in event %i ",fEventNumber)); return 10; }
 858
 859       if(fVerb) DumpHeader(fReaderROOT);
 860
 861       if(fLdcIdOld!=fLdcId &&  fChannelIter!=0) {
 862         if(secid==-1)
 863           {
 864             FillGlobal(GetLastSector());
 865             ResetArrays();
 866             fChannelIter =0;
 867           }
 868         else
 869           {
 870             return lastrcuid;
 871           }
 872       }
 873       fLdcIdOld = fLdcId ;
 874
 875       if(CheckEqId(secid,fEqId))
 876         {
 877           fReaderROOT->ReadNextData(eventPtr);
 878           eventPtrUI = (UInt_t *) eventPtr;
 879           Int_t offset = 16;
 880           Int_t fsize = (Int_t)((equipmentSize/4) -offset) +1;
 881           AliTPCMonitorAltro* altro  = new AliTPCMonitorAltro((UInt_t *)eventPtrUI,fsize,2);
 882           altro->SetWrite10Bit(GetWrite10Bit());
 883           if(fVerb) cout << "AliTPCMonitor::ReadDataROOT Set Write10bit to " << GetWrite10Bit() << endl;
 884           altro->SetActFilename(GetFile());
 885           altro->Allocate10BitArray();
 886           altro->Decodeto10Bit(fEqId);
 887           AliInfo(Form("Process sector %i eqid %i , patch %i ",rcupatch/6,fEqId,rcupatch%6));
 888           FillHistsDecode(altro,(rcupatch%6),secid);
 889           if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
 890           delete altro;
 891         }
 892       SetLastSector(rcupatch/6);
 893     }
 894   if(fChannelIter!=0 && secid==-1) { FillGlobal(GetLastSector()); }
 895   return lastrcuid;
 896 }
 897
 898
 899 //____________________________________________________________________________
 900 void AliTPCMonitor::FillHistsDecode(AliTPCMonitorAltro* altro ,Int_t rcupatch, Int_t secid)
 901 {
 902   // Decode Channels, calculate base mean and rms depending on the
 903   // value of secid (see ProcessEvent) and fill histograms
 904
 905
 906   if(fVerb)   cout << "FillHistsDecode : rcupatch " << rcupatch << " id " << secid <<  endl;
 907   Int_t     timestamp        = 0;
 908   Int_t     sampleiter       = 0;
 909   Int_t     samplelength     = 0;
 910   Int_t     samplebins       = 0;
 911   Float_t   max               = 0;
 912   Float_t   maxx             = 0;
 913   Float_t   sum               = 0.0;
 914   Int_t     sumn              = 0;
 915   Int_t     blockpos         = 0;
 916   Int_t     hw                = 0;
 917   Int_t     nwords            = 0;
 918   Int_t     nextHwAddress     = 0;
 919   Int_t     ntime             = 0;
 920   Int_t     adc               = 0;
 921   Int_t     nextpos           = 0;
 922   Int_t     lastpos           = altro->Get10BitArraySize()-1;
 923   Short_t*  entries           = altro->Get10BitArray();
 924   Double_t  hrms             = 0.0;
 925   Double_t  hmean            = 0.0;
 926   Int_t     supnextpos        = 0;
 927 //  TH1D*     hbase             =  new TH1D("hbase","hbase",GetTimeBins(),0.5,(GetTimeBins()+0.5));
 928   Float_t  fbase[1000];
 929
 930
 931   while(lastpos>0)
 932     {
 933       nextpos    = altro->DecodeTrailer(lastpos);
 934       supnextpos = altro->GetNextTrailerPos();
 935       if(nextpos==-1) { break; }
 936       Int_t itimebin=0;  //timebins in this pad
 937
 938       lastpos               = nextpos;
 939       blockpos             = altro->GetTrailerBlockPos();
 940       hw                    = altro->GetTrailerHwAddress();
 941       nwords                = altro->GetTrailerNWords();
 942       nextHwAddress         = ( hw + (rcupatch<<12) );
 943       fPad[fChannelIter][0] = nextHwAddress ;
 944
 945       if(fPadMapHw[nextHwAddress]!=-1 )
 946       {
 947           //Int_t hw_before1 = fPad[fChannelIter-2][0];
 948           //Int_t hw_before2 = fPad[fChannelIter-3][0];
 949
 950           if(fVerb){ cout  <<"\n //// Ambiguous hwaddress "   << nextHwAddress << "  write 10bit files and check file for eqid : "  << fEqId << " /////// " << endl;}
 951           continue;
 952
 953           if( TMath::Abs(fPadMapRCU[nextHwAddress][4] - fChannelIter)==1)
 954             {
 955               if(fVerb) cout << "//// Difference to previous channel==1 : reset branch bit of hw from last channel to 1 " << endl;
 956               Int_t hwreset =  (nextHwAddress + (1<<11));
 957               fPad[fChannelIter-1][0] = hwreset;
 958
 959               fPadMapHw[hwreset]    =  fChannelIter-1  ;
 960               fPadMapRCU[hwreset][0]=  rcupatch      ;
 961               fPadMapRCU[hwreset][1]=  ((hwreset & AliTPCMonitorAltro::GetHwMaskBranch())    >> 11);
 962               fPadMapRCU[hwreset][2]=  ((hwreset & AliTPCMonitorAltro::GetHwMaskFEC())       >>7  );
 963               fPadMapRCU[hwreset][3]=  ( hwreset & AliTPCMonitorAltro::GetHwMaskFECChannel()      );
 964               fPadMapRCU[hwreset][4]=  fChannelIter-1;
 965               fPadMapRCU[hwreset][5]=  altro->GetTrailerPos();
 966             }
 967         }
 968
 969       fPadMapHw[nextHwAddress]    =  fChannelIter  ;
 970       fPadMapRCU[nextHwAddress][0]=  rcupatch     ;
 971       fPadMapRCU[nextHwAddress][1]=  ((nextHwAddress &  AliTPCMonitorAltro::GetHwMaskBranch())>> 11)    ;
 972       fPadMapRCU[nextHwAddress][2]=  ((nextHwAddress &  AliTPCMonitorAltro::GetHwMaskFEC())   >>7);
 973       fPadMapRCU[nextHwAddress][3]=  (nextHwAddress  &  AliTPCMonitorAltro::GetHwMaskFECChannel());
 974       fPadMapRCU[nextHwAddress][4]=  fChannelIter;
 975       fPadMapRCU[nextHwAddress][5]=  altro->GetTrailerPos();
 976
 977       timestamp    = 0;
 978       sampleiter   = 0;
 979       samplelength = 0;
 980       samplebins   = 0;
 981
 982       max           = 0.0;
 983       maxx         = 0.0;
 984       sum           = 0.0;
 985       sumn          = 0;
 986
 987 //      hbase->Reset();
 988
 989       for(Int_t iterwords = 0 ; iterwords< nwords ; iterwords++)
 990         {
 991           if(entries[blockpos-iterwords]==682) { continue; }
 992           if(entries[blockpos-iterwords]!=682 && sampleiter==0)
 993             {
 994               samplelength =  entries[blockpos-iterwords];
 995               sampleiter   =  samplelength;
 996               samplebins   =  0;
 997               timestamp    =  entries[blockpos-iterwords-1];
 998               iterwords++;
 999               sampleiter-=2;
1000             }
1001           else
1002             {
1003               ntime = timestamp-samplebins;
1004               adc   = entries[blockpos-iterwords];
1005               fPad[fChannelIter][ntime]  = adc;
1006 //if( (adc!=0)  && (ntime>=GetRangeBaseMin()  ) && (ntime<GetRangeBaseMax()    ))  {hbase->Fill(adc)        ;}
1007         if( (adc!=0)  && (ntime>=GetRangeBaseMin()  ) && (ntime<GetRangeBaseMax()    ))  {fbase[itimebin]=adc;itimebin++;}
1008         if( (adc>max) && (ntime>=GetRangeMaxAdcMin()) && (ntime<GetRangeMaxAdcMax()  ))  {max = adc;maxx = ntime ;}
1009               if(              (ntime>=GetRangeSumMin())    && (ntime<GetRangeSumMax()     ))  {sum+=adc; sumn++;}
1010               samplebins++;
1011               sampleiter--;
1012             }
1013         }
1014
1015 //      hmean = hbase->GetMean();
1016 //      hbase->GetXaxis()->SetRangeUser(hmean- hmean/3 , hmean + hmean/3);
1017 //      hmean =  hbase->GetMean();
1018 //      hrms  = hbase->GetRMS();
1019     if (itimebin>0){
1020       hmean = TMath::Mean(itimebin, fbase);
1021       hrms = TMath::RMS(itimebin, fbase);
1022     }
1023
1024       if(       GetPedestals()==1) fHistAddrMaxAdc->SetBinContent(  nextHwAddress,max- hmean);
1025       else                         fHistAddrMaxAdc->SetBinContent(  nextHwAddress,max        );
1026
1027       if(secid!=-1)
1028         {
1029           if(rcupatch<2)
1030             {
1031               fHistDistrBase2dIROC->Fill(hmean,hrms);
1032               fHistDistrSumIROC->Fill(sum);
1033               if(     GetPedestals()==1 ) { fHistDistrMaxIROC->Fill(max-hmean);  fHistDistrSumIROC->Fill(sum -sumn*hmean);}
1034               else                        { fHistDistrMaxIROC->Fill(max);         fHistDistrSumIROC->Fill(sum );}
1035             }
1036           else
1037             {
1038               fHistDistrBase2dOROC->Fill(hmean,hrms);
1039               fHistDistrSumOROC->Fill(sum);
1040               if(     GetPedestals()==1 ){ fHistDistrMaxOROC->Fill(max-hmean); fHistDistrSumOROC->Fill(sum -sumn*hmean);}
1041               else                       { fHistDistrMaxOROC->Fill(max);        fHistDistrSumOROC->Fill(sum)             ;}
1042             }
1043
1044           fHistAddrAdcSum->SetBinContent(  nextHwAddress,sum);
1045           fHistAddrMapIndex->SetBinContent(nextHwAddress,fChannelIter);
1046           fHistAddrBaseMean->SetBinContent(nextHwAddress,hmean);
1047           fHistAddrMaxAdcX->SetBinContent( nextHwAddress,maxx);
1048           fHistAddrBaseRms->SetBinContent( nextHwAddress,hrms);
1049         }
1050       fChannelIter++;
1051       if(nextpos<0)  { AliError("Error :  next pos < 0 "); break  ;}
1052     }
1053 //  delete hbase;
1054   return ;
1055 }
1056
1057
1058 //____________________________________________________________________________
1059 void AliTPCMonitor::FillHistsPadPlane()
1060 {
1061   // Fill 2Dim histograms for IROC and OROC (max , rms and sum)
1062
1063   if(fVerb)cout << "AliTPCMonitor::FillHistsPadPlane() Start  " << endl;
1064   if(fVerb)PrintConfig();
1065
1066   Int_t pad    = 0;
1067   Int_t row    = 0;
1068   Int_t padmax = 0;
1069   Int_t hwadd  = 0;
1070
1071   for(Int_t ch = 0; ch<fChannelIter; ch++)
1072     {
1073       hwadd=  fPad[ch][0];
1074       fHistChannelTime->SetCellContent(ch,0,hwadd);
1075
1076       for(Int_t bin = 1; bin <GetTimeBins(); bin++)
1077         {
1078           if( fHistChannelTime->GetCellContent(ch,bin)!=0)  cout << " cellcontent already set " << endl;
1079           if(     GetPedestals()==1 ) fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]- fHistAddrBaseMean->GetBinContent(hwadd)));
1080           else                        fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]));
1081         }
1082
1083       pad    = fMapHand->GetPad(   hwadd);
1084       row    = fMapHand->GetPadRow(hwadd);
1085       padmax = fMapHand->GetNumofPads(row);
1086
1087       if(row<63)
1088         {
1089           fHistIROC->SetCellContent(     row    +1 ,pad +55 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent(  hwadd));
1090           fHistIROCIndex->SetCellContent(row    +1 ,pad +55 -padmax/2 +1,ch);
1091           fHistIROCRMS->SetCellContent(  row    +1 ,pad +55 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
1092           fHistIROCBASE->SetCellContent( row    +1 ,pad +55 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
1093           fHistIROCSUM->SetCellContent(  row    +1 ,pad +55 -padmax/2 +1,fHistAddrAdcSum->GetBinContent(  hwadd));
1094         }
1095       else
1096         {
1097           fHistOROC->SetCellContent(     row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent(  hwadd));
1098           fHistOROCIndex->SetCellContent(row-63 +1 ,pad +70 -padmax/2 +1,ch);
1099           fHistOROCRMS->SetCellContent(  row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
1100           fHistOROCBASE->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
1101           fHistOROCSUM->SetCellContent(  row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrAdcSum->GetBinContent(  hwadd));
1102         }
1103     }
1104
1105   fHistChannelTime->GetXaxis()->SetRange(0,fChannelIter);
1106   fHistChannelTime->GetYaxis()->SetRange(0,GetTimeBins());
1107 }
1108
1109
1110
1111 //____________________________________________________________________________
1112 void AliTPCMonitor::ResetArrays()
1113 {
1114   // Reset data arrays
1115   for(Int_t row = 0 ; row < fkNRowsIroc; row++)
1116     {
1117     for(Int_t pad = 0 ; pad <  fkNPadsIroc ; pad++)
1118       {
1119         fHistIROCIndex->SetCellContent(row+1,pad+1,-1);
1120       }
1121     }
1122   for(Int_t row = 0 ; row < fkNRowsOroc; row++)
1123     {
1124     for(Int_t pad = 0 ; pad <  fkNPadsOroc ; pad++)
1125       {
1126         fHistOROCIndex->SetCellContent(row+1,pad+1,-1);
1127       }
1128     }
1129
1130   for(Int_t ch= 0; ch<GetMaxHwAddr(); ch++)
1131     {
1132       fHistAddrMaxAdcX->SetBinContent(ch,-1);
1133       fHistAddrMapIndex->SetBinContent(ch,-1);
1134       fHistAddrMaxAdc->SetBinContent(  ch, 0);
1135       fHistAddrBaseMean->SetBinContent(  ch, 0);
1136       fHistAddrAdcSum->SetBinContent(  ch, 0);
1137       fHistAddrBaseRms->SetBinContent(ch, 0);
1138     }
1139
1140   for(Int_t ch = 0; ch< GetNumOfChannels(); ch++)
1141     {
1142     for(Int_t bin = 0; bin< GetTimeBins(); bin++)
1143       {
1144         fPad[ch][bin] = 0;
1145       }
1146     }
1147   for(Int_t ch = 0; ch< GetMaxHwAddr(); ch++)
1148     {
1149       fPadMapHw[ch]=-1;
1150       fPadMapRCU[ch][0]=-1;
1151       fPadMapRCU[ch][1]=-1;
1152       fPadMapRCU[ch][2]=-1;
1153       fPadMapRCU[ch][3]=-1;
1154       fPadMapRCU[ch][4]=-1;
1155       fPadMapRCU[ch][5]=-1;
1156     }
1157   fPadUsedHwAddr=-1;
1158 }
1159
1160
1161 //____________________________________________________________________________
1162 void AliTPCMonitor::ResetHistos()
1163 {
1164   // Reset all but
1165   for(Int_t i =0; i<fHistList->GetEntries(); i++)
1166     {
1167       if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE A")==0) continue;
1168       if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE C")==0) continue;
1169       ((TH1*)fHistList->At(i))->Reset();
1170     }
1171   ResetArrays();
1172 }
1173
1174 //____________________________________________________________________________
1175 void AliTPCMonitor::DeleteHistos()
1176 {
1177   // Delete histograms
1178   for(Int_t i =0; i<fHistList->GetEntries(); i++)
1179     {
1180       delete (TH1*)fHistList->At(i);
1181     }
1182 }
1183
1184
1185 //__________________________________________________________________
1186 Int_t AliTPCMonitor::CheckEqId(Int_t secid,Int_t eqid)
1187 {
1188   // Check if equipment id corresponds to any  rcu patch in sector
1189   // Equipment ids changed during commisioning in 2006 (starting from run 704)
1190   // However Runids started from 0 again in 2007
1191   // Now only runids from commissioning in 2006 after runid 704 and all new ones are supported.
1192   // Comment in equipment check for runids < 704 if old runs should be processed
1193
1194   if(fVerb) cout << "AliTPCMonitor::CheckEqId  : SectorId  " << secid << " EquipmentId " << eqid  << " runid " << fRunId <<  endl;
1195   Int_t passed =1;
1196   //skip all eqids which do not belong to the TPC
1197   if ( eqid<768||eqid>983 ) return 0;
1198   //
1199   if(fRunId<704 && 0) // commented out --> runs with runid < 704 in 2006 are not recognized anymore
1200     {
1201       if( (secid>-1) && (secid<36) )   // if ( secid is in range) { take only specific eqids}  else { take all }
1202         {
1203           if(      (secid==13) && ( eqid!=408 && eqid!=409  &&  eqid!=509 && eqid!=512  && eqid!=513 && eqid!=517 )) {passed=0;}
1204           else if( (secid==4)  && ( eqid!=404 && eqid!=504  &&  eqid!=407 && eqid!=503  && eqid!=508 && eqid!=506 )) {passed=0;}
1205         }
1206       else                                                                   {if(fVerb) cout << "passed check "<< endl; }
1207     }
1208   else
1209     {
1210       if( (secid>-1) && (secid<36) )   // if ( secid is in range) { take only specific eqids}  else { take all }
1211         {
1212           if(eqid!=fMapEqidsSec[secid][0] && eqid!= fMapEqidsSec[secid][1] && eqid!=fMapEqidsSec[secid][2] &&
1213              eqid!=fMapEqidsSec[secid][3] && eqid!= fMapEqidsSec[secid][4] && eqid!=fMapEqidsSec[secid][5] )  {passed=0;}
1214         }
1215       else                                                                   {if(fVerb) cout << "passed check "<< endl;}
1216     }
1217
1218   return passed;
1219 }
1220
1221 //__________________________________________________________________
1222 void AliTPCMonitor::SetEqIds()
1223 {
1224   // Set mapping for equipment ids
1225   for(Int_t i = 0; i<36 ; i++)
1226     {
1227       for(Int_t j = 0; j<6; j++)
1228         {
1229           if(j<2) fMapEqidsSec[i][j]= 768+i*2+j;
1230           else    fMapEqidsSec[i][j]= 840+i*4+j-2;
1231         }
1232     }
1233
1234   for(Int_t i = 0; i<36 ; i++)
1235     {
1236       for(Int_t j = 0; j<6; j++)
1237         {
1238           if(j<2) fMapEqidsRcu[768+i*2+j]   = i*6 +j;
1239           else    fMapEqidsRcu[840+i*4+j-2] = i*6 +j;
1240         }
1241     }
1242 }
1243
1244 //__________________________________________________________________
1245 void AliTPCMonitor::FillGlobal(Int_t sector)
1246 {
1247
1248   // Fill global histograms with max adc for each channel
1249
1250   TH2S* hglob =0;
1251   if((sector/18) ==0) hglob =  fHistGlobalMaxA;
1252   else                hglob =  fHistGlobalMaxC;
1253
1254   Float_t  rotsec  = (2*TMath::Pi()/18.0);
1255   Float_t  rot     = (-rotsec*(sector%18)  +4*rotsec);
1256
1257   Float_t  m11     =    TMath::Cos(rot);
1258   Float_t  m12     =    TMath::Sin(rot);
1259   Float_t  m21     = -1*TMath::Sin(rot);
1260   Float_t  m22     =    TMath::Cos(rot);
1261
1262   Int_t    max     = 0; // use integer for global view
1263
1264   Double_t xval    = 0.0;
1265   Double_t yval    = 0.0;
1266
1267   Int_t    pad     = 0;
1268   Int_t    row     = 0;
1269   Int_t    padmax  = 0;
1270
1271   Float_t  xdr     = 0;
1272   Float_t  ydr     = 0;
1273
1274   for(Int_t hw = 0; hw<fHistAddrMaxAdc->GetNbinsX(); hw++)
1275     {
1276       max = (Int_t)fHistAddrMaxAdc->GetBinContent(hw);
1277       if(max!=-1)
1278         {
1279           pad    = fMapHand->GetPad(   hw);
1280           row    = fMapHand->GetPadRow(hw);
1281           padmax = fMapHand->GetNumofPads(row);
1282           if (sector%36>17) fMirror=-1;
1283           else fMirror=1;
1284           GetXY(xval ,yval , padmax,row ,pad);
1285           xdr    =  xval*m11 +yval*m12;
1286           ydr    =  xval*m21 +yval*m22;
1287           if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0)   hglob->Fill(xdr,ydr,(Int_t)max);
1288         }
1289     }
1290 }
1291
1292
1293 //__________________________________________________________________
1294 void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const
1295 {
1296   // Get x and y position of pad
1297
1298   if(row<63)
1299     {
1300       xval = fMirror*( 2*padmax -4*pad -2);
1301       yval = 852.25 +7.5*row;
1302     }
1303   else
1304     {
1305       xval = fMirror*( 3*padmax -6*pad -3);
1306       if((row-63)<63) {   yval = 10*(row-63) +1351;     }
1307       else            {   yval = 15*(row-63-64)+1993.5; }
1308     }
1309
1310 }
1311
1312 //__________________________________________________________________
1313 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
1314 {
1315   // Get pad number at given position in x
1316   Int_t pad    = 0;
1317
1318   if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1319   else       {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1320
1321   if(pad>=padmax) return -1;
1322   else            return pad ;
1323
1324 }
1325
1326 //__________________________________________________________________
1327 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
1328 {
1329
1330  // Get pad number at given position in x
1331
1332   Int_t padmax = fMapHand->GetNumofPads(row);
1333   Int_t pad    = 0;
1334
1335   if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1336   else       {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1337
1338   if(pad>=padmax) return -1;
1339   else            return pad ;
1340
1341 }
1342
1343 //__________________________________________________________________
1344 void AliTPCMonitor::DrawHists(Int_t histos)
1345 {
1346
1347   // Draw sets of histograms
1348   // histos==1 : 2Dim histos for MAX adc  and add executables
1349   // histos==2 : distributions max/rms/sum
1350   // histos==3 : global max adc for specified SideA/C
1351
1352
1353   if(fVerb)    cout << " Draw histos " << endl;
1354   Char_t cside[10];
1355   if(GetLastSector()/18==0 ) sprintf(cside,"A");
1356   else                       sprintf(cside,"C");
1357
1358   Char_t titleSEC[256];   sprintf(titleSEC   ,"Sector %i Side %s Run : %05i EventID %i "       ,GetLastSector()%18,cside,fRunId, fEventNumber);
1359   Char_t titleEvent[256]; sprintf(titleEvent ,"Time <-> Channles  %s"                          ,titleSEC);
1360   Char_t titleIROC[256];  sprintf(titleIROC  ,"IROC %s"                                        ,titleSEC);
1361   Char_t titleOROC[256];  sprintf(titleOROC  ,"OROC %s"                                        ,titleSEC);
1362
1363   Char_t titleMAX[256];   sprintf(titleMAX   ,"Max (timebin: %i,%i) %s"                        ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC);
1364   Char_t titleSUM[256];   sprintf(titleSUM   ,"Sum (timebin: %i,%i) %s"                        ,GetRangeSumMin()   ,GetRangeSumMax()   ,titleSEC);
1365   Char_t titleBASE[256];  sprintf(titleBASE  ,"Baseline RMS<->Mean  (timebin: %i-%i) %s"       ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC);
1366   Char_t titleMEAN[256];  sprintf(titleMEAN  ,"Baseline Mean (timebin: %i-%i) %s"              ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC);
1367   Char_t titleRMS[256] ;  sprintf(titleRMS   ,"Baseline RMS (timebin: %i-%i) %s"               ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC);
1368
1369   if(histos==1)
1370     {
1371       // IROC _______________________________________________________________
1372       TCanvas* ciroc = 0;
1373       ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1374       if(!ciroc)
1375         {
1376           ciroc = CreateCanvas("ciroc");
1377           fExecPlaneMax=0;
1378         }
1379       ciroc->cd();
1380
1381       fHistIROC->SetXTitle("row");
1382       fHistIROC->SetYTitle("pad");
1383       if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1384       else               fHistIROC->SetZTitle("max ADC ");
1385       fHistIROC->SetTitle(titleIROC);
1386       fHistIROC->SetMinimum(0.01);
1387       fHistIROC->Draw("COLZ");
1388       ciroc->UseCurrentStyle();
1389
1390
1391       fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)");       fHistIROCTime->SetYTitle("pad");      fHistIROCTime->SetTitle(titleIROC);
1392       fHistIROCRMS->SetXTitle("row");  fHistIROCRMS->SetZTitle( "baseline rms (ADC)");    fHistIROCRMS->SetYTitle("pad");       fHistIROCRMS->SetTitle(titleIROC);
1393
1394       // OROC
1395       TCanvas* coroc = 0;
1396       coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1397       if(!coroc) {
1398         coroc = CreateCanvas("coroc");
1399         fExecPlaneMax=0;
1400       }
1401       coroc->cd();
1402
1403       fHistOROC->SetXTitle("row");
1404       fHistOROC->SetYTitle("pad");
1405       if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1406       else               fHistOROC->SetZTitle("max ADC ");
1407       fHistOROC->SetTitle(titleOROC);
1408       fHistOROC->SetMinimum(0.01);
1409       fHistOROC->Draw("COLZ");
1410       coroc->UseCurrentStyle();
1411
1412
1413       fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC);
1414       fHistOROCRMS->SetXTitle("row");  fHistOROCRMS->SetZTitle("baseline rms (ADC)");          fHistOROCRMS->SetYTitle("pad");  fHistOROCRMS->SetTitle(titleOROC);
1415
1416       // SUM
1417       Char_t namesum[256] ; sprintf(namesum,"ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1418       fHistIROCSUM->SetXTitle("row");      fHistIROCSUM->SetZTitle(namesum);      fHistIROCSUM->SetYTitle("pad");      fHistIROCSUM->SetTitle(titleIROC);
1419       fHistOROCSUM->SetXTitle("row");      fHistOROCSUM->SetZTitle(namesum);      fHistOROCSUM->SetYTitle("pad");      fHistOROCSUM->SetTitle(titleOROC);
1420
1421       // BASE
1422       Char_t namebase[256] ; sprintf(namebase ,"base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1423       fHistIROCBASE->SetXTitle("row"); fHistIROCBASE->SetZTitle(namebase);  fHistIROCBASE->SetYTitle("pad");      fHistIROCBASE->SetTitle(titleIROC);
1424       fHistOROCBASE->SetXTitle("row"); fHistOROCBASE->SetZTitle(namebase);  fHistOROCBASE->SetYTitle("pad");      fHistOROCBASE->SetTitle(titleOROC);
1425
1426       if(fHistIROCClone) fHistIROCClone->Delete();
1427       if(fHistOROCClone) fHistOROCClone->Delete();
1428       fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1429       fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1430
1431       // Executables
1432       if(fExecPlaneMax==0)
1433         {
1434           Char_t carry1[100];
1435           sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1436           ciroc->AddExec("pad",carry1);
1437           coroc->AddExec("pad",carry1);
1438
1439           Char_t carry2[100];
1440           sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1441           ciroc->AddExec("row",carry2);
1442           coroc->AddExec("row",carry2);
1443           fExecPlaneMax=1;
1444         }
1445       coroc->Update();
1446       ciroc->Update();
1447     }
1448   else if(histos==2)
1449     {
1450       // MAX ADC distribution  ____________________________________________
1451       TCanvas* cmax = 0;
1452       cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1453       if(!cmax)  cmax = CreateCanvas("cmax");
1454
1455       cmax->cd();
1456       fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1457       fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1458       fHistDistrMaxIROC->SetYTitle("counts");
1459       fHistDistrMaxIROC->SetTitle(titleMAX);
1460       fHistDistrMaxIROC->Draw("");
1461       fHistDistrMaxOROC->SetLineColor(2);
1462       fHistDistrMaxOROC->Draw("same");
1463
1464       if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum())  fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1465
1466       TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1467       legio->SetFillColor(0);
1468       legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1469       legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1470       legio->Draw("same");
1471
1472       // ADC sum distribution
1473       TCanvas* csum = 0;
1474       csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1475       if(!csum)  csum = CreateCanvas("csum") ;
1476       csum->cd();
1477
1478       fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1479       fHistDistrSumIROC->SetYTitle("counts");
1480       fHistDistrSumIROC->SetTitle(titleSUM);
1481       fHistDistrSumIROC->Draw("");
1482       fHistDistrSumOROC->SetLineColor(2);
1483       fHistDistrSumOROC->Draw("same");
1484       if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum())  fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1485       legio->Draw("same");
1486
1487       // BASELINE MEAN distribution
1488       TCanvas* cbasemean = 0;
1489       cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1490       if(!cbasemean)  cbasemean = CreateCanvas("cbasemean");
1491       cbasemean->cd();
1492
1493       fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1494       fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1495       fHistDistrBaseMeanIROC->SetYTitle("counts");
1496       fHistDistrBaseMeanIROC->SetTitle(titleMEAN);
1497       fHistDistrBaseMeanIROC->Draw("");
1498
1499       fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1500       fHistDistrBaseMeanOROC->SetLineColor(2);
1501       fHistDistrBaseMeanOROC->Draw("same");
1502       if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum())   fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1503       legio->Draw("same");
1504
1505       TCanvas* cbaserms = 0;
1506       cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1507       if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1508       cbaserms->cd();
1509
1510       // BASELINE RMS distribution
1511       fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1512       fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1513       fHistDistrBaseRmsIROC->SetYTitle("counts");
1514       fHistDistrBaseRmsIROC->SetTitle(titleRMS);
1515       fHistDistrBaseRmsIROC->Draw("");
1516
1517       fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1518       fHistDistrBaseRmsOROC->SetLineColor(2);
1519       fHistDistrBaseRmsOROC->Draw("same");
1520       if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum())  fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1521       legio->Draw("same");
1522
1523       cmax->Update();
1524       csum->Update();
1525       cbasemean->Update();
1526       cbaserms->Update();
1527     }
1528   else  if(histos==3)
1529     {
1530       // GLOBAL MAX ADC _________________________________
1531       if(GetProcNextEvent()==1)
1532         {
1533           TCanvas* cglobA =0;
1534           TCanvas* cglobC =0;
1535
1536           if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1537           if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1538
1539           Char_t globtitle1[256]; sprintf(globtitle1,"SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1540           Char_t globtitle2[256]; sprintf(globtitle2,"SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1541
1542           fHistGlobalMaxA->SetTitle(globtitle1);
1543           fHistGlobalMaxC->SetTitle(globtitle2);
1544           fHistGlobalMaxA->SetXTitle("x/mm");
1545           fHistGlobalMaxA->SetYTitle("y/mm");
1546           fHistGlobalMaxC->SetXTitle("x/mm");
1547           fHistGlobalMaxC->SetYTitle("y/mm");
1548
1549           if(GetPedestals()==0)     {         fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)");   fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)");  }
1550           else                      {         fHistGlobalMaxA->SetZTitle("max adc ");                     fHistGlobalMaxC->SetZTitle("max adc ");                          }
1551
1552           fHistGlobalMaxA->SetMinimum(0.01);
1553           fHistGlobalMaxC->SetMinimum(0.01);
1554
1555           cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1556           cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1557
1558           Char_t nameom[256];
1559           sprintf(nameom,".x  %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1560
1561           if(fExecGlob==0)
1562             {
1563               if(fVerb)cout << " set exec " << nameom << endl;
1564               cglobC->AddExec("glob",nameom);
1565               cglobA->AddExec("glob",nameom);
1566               fExecGlob = 1;
1567             }
1568           else
1569             {
1570               cglobC->DeleteExec("glob");
1571               cglobA->DeleteExec("glob");
1572
1573               if(fVerb)  cout << " set exec " << nameom << endl;
1574               cglobC->AddExec("glob",nameom);
1575               cglobA->AddExec("glob",nameom);
1576
1577             }
1578           cglobC->Update();
1579           cglobA->Update();
1580         }
1581
1582     }
1583 }
1584
1585
1586
1587 //__________________________________________________________________
1588 void AliTPCMonitor::DrawRMSMap()
1589 {
1590   // Draw 2Dim rms histos for IROC and OROC
1591   // and set executables for canvases
1592
1593   TCanvas* crmsoroc =0;
1594   TCanvas* crmsiroc =0;
1595   if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc")))    crmsoroc    = CreateCanvas("crmsoroc");
1596   if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc")))    crmsiroc    = CreateCanvas("crmsiroc");
1597
1598   crmsiroc->cd();  fHistIROCRMS->Draw("COLZ");
1599   crmsoroc->cd();  fHistOROCRMS->Draw("COLZ");
1600
1601   Char_t carry1[100];  sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1602   Char_t carry2[100];  sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1603
1604   if(fExecPadIrocRms==0)
1605     {
1606       crmsiroc->AddExec("pad",carry1);
1607       crmsiroc->AddExec("row",carry2);
1608       fExecPadIrocRms=1;
1609     }
1610
1611   if(fExecPadOrocRms==0)
1612     {
1613       crmsoroc->AddExec("pad",carry1);
1614       crmsoroc->AddExec("row",carry2);
1615       fExecPadOrocRms=1;
1616     }
1617
1618   crmsiroc->Update();
1619   crmsoroc->Update();
1620
1621   DrawHists(2);
1622
1623 }
1624
1625 //__________________________________________________________________
1626 void AliTPCMonitor::ExecPad()
1627 {
1628
1629   // Executable for Pad
1630   // Show time profile for channel the mouse is pointing at
1631
1632   Int_t event = gPad->GetEvent();
1633   if (event != 51)   return;
1634
1635   TObject *select = gPad->GetSelected();
1636   if(!select)    return;
1637   if(!select->InheritsFrom("TH2")) { return;  }
1638   gPad->GetCanvas()->FeedbackMode(kTRUE);
1639
1640   // get position
1641   Int_t    px        = gPad->GetEventX();
1642   Int_t    py        = gPad->GetEventY();
1643   Float_t  upy       = gPad->AbsPixeltoY(py);
1644   Float_t  upx       = gPad->AbsPixeltoX(px);
1645   Float_t  y         = gPad->PadtoY(upy);
1646   Float_t  x         = gPad->PadtoX(upx);
1647
1648   Int_t    setrange  = 0;
1649
1650   TCanvas* cpad      = 0;
1651   //  Char_t   namehist[50];
1652   Char_t   projhist[60];
1653   Char_t   namesel[256];
1654   Char_t   namecanv[256];
1655
1656   Int_t    xbinmin  = 0;
1657   Int_t    xbinmax  = 0;
1658   Float_t  ybinmin  = 0;
1659   Float_t  ybinmax  = 0;
1660   Int_t    rocid     = 0;
1661
1662   // Check wich Canvas executed the event
1663   TH2S* fHistIndex=0;
1664   sprintf(namesel,select->GetName());
1665   if(strcmp(namesel,"fHistOROC")==0 || strcmp(namesel,"fHistOROCRMS")==0 || strcmp(namesel,"fHistOROCTime")==0 )
1666     {
1667       rocid = 1;
1668       fPadUsedRoc =1;
1669       sprintf(projhist,"ProjectionOROC");
1670       sprintf(namecanv,"coroc_ch");
1671       fHistIndex = fHistOROCIndex;
1672     }
1673   if(strcmp(namesel,"fHistIROC")==0 || strcmp(namesel,"fHistIROCRMS")==0 || strcmp(namesel,"fHistIROCTime")==0 )
1674     {
1675       rocid = 0;
1676       fPadUsedRoc=0;
1677       sprintf(projhist,"ProjectionIROC");
1678       sprintf(namecanv,"ciroc_ch");
1679       fHistIndex = fHistIROCIndex;
1680     }
1681
1682   // Check if Canvas already existed and get Ranges from former Prjection histogram
1683   if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1684     {
1685       cpad->cd();
1686       if(gROOT->Get(projhist))
1687         {
1688           setrange = 1;
1689           xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1690           xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1691           ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1692           ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1693           delete gROOT->Get("legfit");
1694           delete gROOT->Get("fg");
1695         }
1696     }
1697   else
1698     {
1699       cpad = CreateCanvas(namecanv); cpad->cd();
1700     }
1701
1702   // Get Bin
1703   Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1704   Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1705   Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1706   if(binchannel>30000 || binchannel<0) return;
1707
1708   if(gROOT->Get(projhist))  delete gROOT->Get(projhist);
1709   // Get Projection
1710   TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1711
1712   // Make title and Pave for channel Info
1713   Char_t title[256];
1714   Int_t npadRow , npad  , nhw , nmax , hwadd;
1715
1716   hwadd   = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1717   fPadUsedHwAddr = hwadd;
1718
1719   if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1720   else        npadRow = fMapHand->GetPadRow(hwadd)-63;
1721   npad                = fMapHand->GetPad(hwadd);
1722   nhw                 = hwadd;
1723   nmax                = (Int_t)hp->GetMaximum();
1724
1725
1726   TPaveText*  legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1727
1728   Int_t   connector   =  fMapHand->GetFECconnector(hwadd);
1729   Int_t   fecnr       =  fMapHand->GetFECfromHw(hwadd);
1730   Int_t   fecch       =  fMapHand->GetFECchannel(hwadd);
1731   Int_t   altrochip   =  fMapHand->GetAltro(hwadd);
1732   Int_t   altrochannel=  (fMapHand->GetAltroChannel(hwadd))%16;
1733   Int_t   fecloc      =  fMapHand->U2fGetFECinRCU(fecnr) ;
1734   Int_t   feclocbran  =  fMapHand->U2fGetFECinBranch(fecnr);
1735   Int_t   branch      =  fMapHand->U2fGetBranch(fecnr);
1736
1737
1738   Short_t fecget      = (hwadd & AliTPCMonitorAltro::GetHwMaskFEC())   >> 7;
1739   Short_t branchget   = (hwadd & AliTPCMonitorAltro::GetHwMaskBranch())>> 11;
1740
1741
1742   Char_t nstat1[100];  Char_t nstat2[100];  Char_t nstat3[100];  Char_t nstat4[100];
1743   Char_t nstat5[100];  Char_t nstat6[100];  Char_t nstat7[100];  Char_t nstat8[100];
1744
1745   sprintf(nstat1,"Branch (map) \t %i (%i) \n",branchget,branch);
1746   sprintf(nstat2,"Fec in patch \t %i \n",fecloc);
1747   sprintf(nstat8,"Fec in branch (map)\t %i (%i)\n",fecget,feclocbran);
1748   sprintf(nstat7,"Connector  \t %i \n",connector);
1749   sprintf(nstat3,"Fec No.   \t %i \n",fecnr);
1750   sprintf(nstat4,"Fec chan  \t %i \n",fecch);
1751   sprintf(nstat5,"Altro chip\t %i \n",altrochip);
1752   sprintf(nstat6,"Altro chan\t %i \n",altrochannel);
1753
1754   legstat->AddText(nstat1); legstat->AddText(nstat2);  legstat->AddText(nstat8);  legstat->AddText(nstat7);
1755   legstat->AddText(nstat3); legstat->AddText(nstat4);  legstat->AddText(nstat5);  legstat->AddText(nstat6);
1756
1757   sprintf(title,"Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1758
1759   hp->SetName(projhist);
1760   hp->SetTitleSize(0.04);
1761   hp->SetTitle(title);
1762   hp->SetYTitle("ADC");
1763   hp->SetXTitle("Timebin");
1764   hp->GetXaxis()->SetTitleColor(1);
1765
1766   if(setrange)
1767     {
1768       hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1769       hp->SetMinimum(ybinmin);
1770       hp->SetMaximum(ybinmax);
1771     }
1772   else
1773     {
1774       hp->SetMinimum(0.0);
1775       hp->SetMaximum(1000.0);
1776     }
1777
1778   cpad->cd();
1779   hp->Draw();
1780
1781   // Make Fit to peak
1782   if(GetPedestals() && fDisableFit==0)
1783     {
1784       Int_t maxx  =    (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1785       Float_t max  =  (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1786       Float_t base =  (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1787       if(base!=0)
1788         {
1789           if( ((max+base)/base)>1.2)
1790             {
1791               TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
1792               fg->SetParName(0,"Normalisation");
1793               fg->SetParName(1,"Minimum");
1794               fg->SetParName(2,"Width");
1795               fg->SetParName(3,"Base");
1796               fg->SetParameter(0,max);
1797               fg->SetParameter(1,maxx-2);
1798               fg->SetParameter(2,1.5);
1799               fg->FixParameter(3,0);
1800               fg->SetLineColor(4);
1801               fg->SetLineWidth(1);
1802               hp->Fit("fg","RQ");
1803
1804               TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1805               legfit->AddEntry("fg","#Gamma 4 fit","l");
1806               legfit->SetFillColor(0);
1807               legfit->SetName("legfit");
1808               legfit->Draw("same");
1809             }
1810         }
1811     }
1812   legstat->SetFillColor(0);
1813   legstat->Draw("same");
1814   cpad->Update();
1815   return;
1816 }
1817
1818 //__________________________________________________________________
1819 void AliTPCMonitor::ExecRow()
1820 {
1821
1822   // Executable for Pad
1823   // Show profile of max adc over given pad row
1824   // and 2dim histo  adc(pad-in-row,time bin)
1825
1826   Int_t event = gPad->GetEvent();
1827   if (event != 61)    return;
1828   gPad->cd();
1829   TObject *select = gPad->GetSelected();
1830   if(!select)    return;
1831   if(!select->InheritsFrom("TH2")) {   return;  }
1832
1833   Int_t rocid = 0;
1834   //  Char_t namehist[50];
1835   Char_t rowhist[60];
1836   Char_t rowhistsum[60];
1837   Char_t rowhistmax[60];
1838   Char_t rowhistxmax[60];
1839
1840   sprintf(rowhist,         "hrowtime");
1841   sprintf(rowhistxmax    ,"hxmax");
1842   sprintf(rowhistmax    , "hrowmax");
1843
1844   // get position
1845   Int_t   px  = gPad->GetEventX();
1846   Int_t   py  = gPad->GetEventY();
1847   Float_t upy = gPad->AbsPixeltoY(py);
1848   Float_t upx = gPad->AbsPixeltoX(px);
1849   Float_t y   = gPad->PadtoY(upy);
1850   Float_t x   = gPad->PadtoX(upx);
1851
1852   TCanvas*crowtime   = 0;
1853   TCanvas*crowmax    = 0;
1854   TCanvas*cxmax      = 0;
1855
1856   TH2S*  fHistIndex  = 0;
1857
1858   // ranges from already existing histos
1859   Int_t    rowtimexmin = 0;
1860   Int_t    rowtimexmax = 0;
1861   Int_t    rowtimeymin = 0;
1862   Int_t    rowtimeymax = 0;
1863   Float_t  rowtimezmin = 0;
1864   Float_t  rowtimezmax = 0;
1865
1866   Int_t    profrowxmin = 0;
1867   Int_t    profrowxmax = 0;
1868   Double_t profrowymin = 0;
1869   Double_t profrowymax = 0;
1870
1871   Int_t    profxxmin   = 0;
1872   Int_t    profxxmax   = 0;
1873   Double_t profxymin   = 0;
1874   Double_t profxymax   = 0;
1875
1876
1877   Int_t    setrange      = 0;
1878
1879
1880   if(     strcmp(select->GetName(),"fHistIROC")==0 || strcmp(select->GetName(),"fHistIROCRMS")==0 ) { fHistIndex = fHistIROCIndex;     rocid =1;   }
1881   else if(strcmp(select->GetName(),"fHistOROC")==0 || strcmp(select->GetName(),"fHistOROCRMS")==0 ) { fHistIndex = fHistOROCIndex;     rocid =2;   }
1882   else                                                                                  { cout << " not implemented for this histo " << endl; return; }
1883
1884   gPad->GetCanvas()->FeedbackMode(kTRUE);
1885
1886
1887
1888   // check if canvases exist //
1889   crowtime  = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1890   crowmax   = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1891   cxmax     = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
1892
1893   if(!crowtime)   crowtime   = CreateCanvas("crowtime") ;
1894   if(!crowmax)    crowmax    = CreateCanvas("crowmax")  ;
1895   if(!cxmax  )    cxmax      = CreateCanvas("cxmax")    ;
1896
1897   // check ranges of already existing histos
1898   if(gROOT->Get(rowhist))
1899     {
1900       rowtimexmin  = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1901       rowtimexmax  = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1902       rowtimeymin  = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1903       rowtimeymax  = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1904       rowtimezmin  = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1905       rowtimezmax  = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1906
1907       profrowxmin  = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1908       profrowxmax  = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1909       profrowymin  = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1910       profrowymax  = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
1911
1912       profxxmin    = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1913       profxxmax    = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1914       profxymin    = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1915       profxymax    = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
1916
1917       setrange =1;
1918
1919       delete gROOT->Get(rowhist);
1920       delete gROOT->Get(rowhistmax);
1921       delete gROOT->Get(rowhistsum);
1922       delete gROOT->Get("hxmax");
1923       delete gROOT->Get("legrow");
1924     }
1925
1926   // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1927   Int_t testy      = fHistIndex->GetYaxis()->FindBin(y);
1928   Int_t testx      = fHistIndex->GetXaxis()->FindBin(x);
1929   Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1930
1931   if(binchannel>30000)    return;
1932   if(binchannel<=0 ) { crowtime->Update() ;    crowmax->Update() ;    return ;  }
1933
1934   // get hwaddress
1935   Int_t hwadd     = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1936   Int_t row       = fMapHand->GetPadRow(hwadd);
1937   Int_t pad       = fMapHand->GetPad(hwadd)   ;
1938   Int_t numofpads =  fMapHand->GetNumofPads(row);
1939
1940   // create histos
1941   TH2F *hrowtime = new TH2F(rowhist     , ""  ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1942   TH1F *hrowmax  = new TH1F(rowhistmax , ""  ,numofpads,0,numofpads);
1943   TH1F *hxmax    = new TH1F(rowhistxmax, ""  ,159,0,159      );
1944
1945   // Row profile ///////////
1946   if(fVerb) cout << " Number of pads " << numofpads << endl;
1947   for(Int_t padnr = 0; padnr<numofpads;padnr++)
1948     {
1949       Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1950       Int_t channel   = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1951       if(channel==-1) continue;
1952
1953       hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1954       TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1955       for(Int_t time = 0;time<GetTimeBins();time++) {
1956
1957         Float_t val = hp->GetBinContent(time);
1958         hrowtime->SetCellContent(padnr+1,time+1,val);
1959       }
1960     }
1961
1962   // X profile  /////////////
1963   Double_t xval  = 0.0;
1964   Double_t yval  = 0.0;
1965   GetXY(xval,yval,numofpads,row,pad);
1966
1967   Int_t padnr = 0;
1968   Int_t hw    = 0;
1969   for(Int_t nrow = 0; nrow<159; nrow++)
1970     {
1971       padnr = GetPadAtX(xval,nrow);
1972       if(padnr>=0)
1973         {
1974           hw = fMapHand->GetPadAddInRow(nrow,padnr);
1975           if(fPadMapHw[hw]==-1){ continue                                                      ; }
1976           else                { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw))   ;     }
1977         }
1978     }
1979
1980   cxmax->cd();
1981   Char_t hxtitle[50] ; sprintf(hxtitle,"max adc in pads at x=%5.1f mm",xval);
1982   hxmax->SetTitle(hxtitle);
1983   hxmax->SetXTitle("row");
1984   if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1985   else                hxmax->SetYTitle("max adc ");
1986   hxmax->SetMinimum(0.01);
1987   hxmax->Draw("l");
1988
1989   if(setrange)
1990     {
1991       hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1992       hxmax->SetMinimum(profxymin);
1993       hxmax->SetMaximum(profxymax);
1994     }
1995
1996   cxmax->Update();
1997
1998   crowtime->cd();
1999   Char_t title[256];
2000   Char_t titlemax[256];
2001   if(rocid==1) {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row)   ;    sprintf(titlemax,"IROC  max/sum Row=%d",row   );}
2002   else         {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row-63);    sprintf(titlemax,"OROC  max/sum Row=%d",row-63);}
2003   if(fVerb) cout << " set name " << endl;
2004
2005
2006   // row vs time
2007   crowtime->cd();
2008   hrowtime->SetTitleSize(0.04);
2009   hrowtime->SetTitle(title);
2010   hrowtime->SetYTitle("timbin");
2011   hrowtime->SetXTitle("pad in row");
2012   hrowtime->SetZTitle("signal (ADC)");
2013
2014   hrowtime->GetXaxis()->SetTitleColor(1);
2015   hrowtime->SetMaximum(1000.0);
2016   hrowtime->SetMinimum(0.0);
2017
2018   if(setrange)
2019     {
2020       hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
2021       hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
2022       hrowtime->SetMinimum(rowtimezmin);
2023       hrowtime->SetMaximum(rowtimezmax);
2024     }
2025
2026   hrowtime->Draw("COLZ");
2027   crowtime->UseCurrentStyle();
2028   crowtime->Update();
2029
2030   // max and sum /////////////////////////
2031   crowmax->cd();
2032   if(setrange) {
2033     hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
2034     hrowmax->SetMinimum(profrowymin);
2035     hrowmax->SetMaximum(profrowymax);
2036   }
2037   hrowmax->SetTitleSize(0.04);
2038   hrowmax->SetTitle(title);
2039   hrowmax->SetYTitle("max adc");
2040   hrowmax->SetXTitle("pad in row");
2041   hrowmax->GetXaxis()->SetTitleColor(1);
2042
2043   hrowmax->SetLineColor(2);
2044   hrowmax->Draw("l");
2045   crowmax->Update();
2046
2047   return;
2048 }
2049
2050 //__________________________________________________________________
2051 void AliTPCMonitor::Write10bitChannel()
2052 {
2053
2054   // Write 10 bit words form histogram for active(last pointed)  channel
2055
2056   if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
2057
2058   Int_t  pad     = (Int_t)fMapHand->GetPad(   fPadUsedHwAddr);
2059   Int_t  row     = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
2060   Int_t  channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
2061
2062   Char_t filenameroot[256];
2063   Char_t filenamedat[256];
2064   Char_t projhist[256];
2065
2066   if(fPadUsedRoc==1) { sprintf(projhist,"ProjectionOROC"); }
2067   if(fPadUsedRoc==0) { sprintf(projhist,"ProjectionIROC"); }
2068
2069   sprintf(filenamedat, "Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat"      ,fRunId,fEventNumber,pad,row);
2070   sprintf(filenameroot,"Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root"     ,fRunId,fEventNumber,pad,row);
2071
2072   TH1D* hpr = 0;
2073   if((hpr=(TH1D*)gROOT->Get(projhist)))
2074     {
2075       // root histo
2076       TFile f(filenameroot,"recreate");
2077       hpr->Write();
2078       f.Close();
2079
2080       // raw singal
2081       ofstream datout(filenamedat,ios::out);
2082       datout <<"Timebin \t ADC value " << endl;
2083       for(Int_t i = 1; i <GetTimeBins(); i++)
2084         {
2085           datout << i << " \t \t " << fPad[channel][i] << endl;
2086         }
2087       datout.close();
2088     }
2089   else
2090     {
2091       AliWarning("No projection histo found ");
2092     }
2093 }
2094
2095 //__________________________________________________________________
2096 void AliTPCMonitor::ExecTransform()
2097 {
2098
2099   // Make Fast Fourier Transformation for active pad
2100   // fft is only performed for a data sample of size 2^n
2101   // reduce window according to largest  power of 2 which is smaller than the viewing  range
2102
2103   Char_t namecanv[256];
2104   Char_t namecanv2[256];
2105   Char_t projhist[256];
2106   Char_t namehtrimag[256];
2107   Char_t namehtrreal[256];
2108   Char_t namehtrmag[256];
2109
2110   if(fPadUsedRoc==1) {    sprintf(namecanv,"coroc_ch_trans") ; sprintf(namecanv2,"coroc_ch_trans2") ;   sprintf(projhist,"ProjectionOROC");  }
2111   if(fPadUsedRoc==0) {    sprintf(namecanv,"ciroc_ch_trans") ; sprintf(namecanv2,"ciroc_ch_trans2") ;  sprintf(projhist,"ProjectionIROC");  }
2112
2113   TH1D*  hproj = 0;
2114
2115   if((TH1D*)gROOT->Get(projhist)==0){AliWarning("Proj histo does not exist \n Move mouse over 2d histo choose channel \n and drag mouse form histo again!");  return ;}
2116   else      hproj = (TH1D*)gROOT->Get(projhist) ;
2117
2118
2119   if(fPadUsedRoc==1) {  sprintf(namehtrimag,"htransimagfreq_oroc");    sprintf(namehtrreal,"htransrealfreq_oroc"); sprintf(namehtrmag,"htransmagfreq_oroc");  }
2120   else               {  sprintf(namehtrimag,"htransimagfreq_iroc");    sprintf(namehtrreal,"htransrealfreq_iroc"); sprintf(namehtrmag,"htransmagfreq_iroc");  }
2121
2122   if( gROOT->Get(namehtrimag))  delete  gROOT->Get(namehtrimag);
2123   if( gROOT->Get(namehtrreal))  delete  gROOT->Get(namehtrreal);
2124   if( gROOT->Get(namehtrmag))  delete  gROOT->Get(namehtrmag);
2125
2126   TCanvas *ctrans = 0;
2127   if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
2128   {
2129     ctrans = CreateCanvas(namecanv);
2130     ctrans->Divide(1,2);
2131   }
2132   TCanvas *ctrans2 = 0;
2133   if(!(ctrans2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv2)))
2134   {
2135     ctrans2 = CreateCanvas(namecanv2);
2136 //      ctrans2->Divide(1,2);
2137   }
2138
2139   Int_t binfirst  =  hproj->GetXaxis()->GetFirst();
2140   Int_t binlast   =  hproj->GetXaxis()->GetLast();
2141   Int_t bins       =  binlast -binfirst +1;
2142
2143   Int_t power = 0;
2144   for(Int_t pot = 0; pot<=10 ; pot++)
2145   {
2146     Int_t comp =  (Int_t)TMath::Power(2,pot);
2147     if(bins>=comp)power = pot;
2148   }
2149
2150   bins = (Int_t)TMath::Power(2,power);
2151
2152   // sampling frequency ;
2153   Double_t  deltat = 1.0/(Float_t)GetSamplingFrequency();
2154
2155   // output histo
2156   TH1D* htransrealfreq = new TH1D(namehtrreal,namehtrreal,10000,-1/(2*deltat),1/(2*deltat));
2157   TH1D* htransimagfreq = new TH1D(namehtrimag,namehtrimag,10000,-1/(2*deltat),1/(2*deltat));
2158   TH1D* htransmag      = new TH1D(namehtrmag,namehtrmag,10000,-1/(2*deltat),1/(2*deltat));
2159
2160   Char_t titlereal[256];
2161   Char_t titleimag[256];
2162   Char_t titlemag[256];
2163   if(fPadUsedRoc==1) {    sprintf(titlereal,"OROC DFT real part");  sprintf(titleimag,"OROC DFT imag part");  sprintf(titlemag,"OROC DFT magnitude");  }
2164   else {                  sprintf(titlereal,"IROC DFT real part");  sprintf(titleimag,"IROC DFT imag part");  sprintf(titlemag,"IROC DFT magnitude");  }
2165
2166   htransrealfreq->SetTitle(titlereal);  htransrealfreq->SetXTitle("f/hz");  htransrealfreq->SetYTitle("z_{real}(f)");
2167   htransimagfreq->SetTitle(titleimag);  htransimagfreq->SetXTitle("f/hz");  htransimagfreq->SetYTitle("z_{imag}(f)");
2168   htransmag->SetTitle(titlemag);  htransmag->SetXTitle("f/hz");  htransmag->SetYTitle("mag(f)");
2169
2170   // create complex packed data array
2171   const Int_t kdatasiz = 2*bins;
2172   Double_t*  data = new Double_t[kdatasiz];
2173   for(Int_t i=0;i<2*bins;i++)  { data[i]   =  0.0;}
2174   for(Int_t i=0;i<bins;i++)    { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
2175
2176   // make fourier transformation
2177   AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
2178   four->ComplexRadix2ForwardWrap(data,1,bins);
2179
2180   // write output  and fill histos forward
2181   Double_t freq =  0.0;
2182   for(Int_t i=0;i<2*bins;i++)
2183   {
2184     if(i<bins)
2185     {
2186       if(i<(bins/2))  { freq = i/(bins*deltat)            ; }
2187       else            { freq = -1*((bins-i)/(bins*deltat)); }
2188       htransrealfreq->Fill( freq,data[2*i]  );
2189       htransimagfreq->Fill( freq,data[2*i+1]);
2190       htransmag->Fill( freq, TMath::Sqrt(data[2*i]*data[2*i]+data[2*i+1]*data[2*i+1]) );
2191     }
2192   }
2193
2194   ctrans->cd(1);
2195   htransrealfreq->Draw();
2196   ctrans->cd(2);
2197   htransimagfreq->Draw();
2198   ctrans->Update();
2199   ctrans2->cd();
2200   htransmag->Draw();
2201   ctrans2->Update();
2202   delete four;
2203   delete data;
2204 }
2205
2206 //__________________________________________________________________
2207 void AliTPCMonitor::ShowSel(Int_t* compval)
2208 {
2209
2210   // Show only selected components
2211   // First restore original histogram from clone
2212   // Than remove all not matching pads form histos
2213
2214   Int_t   connector   =  0;
2215   Int_t   fecnr       =  0;
2216   Int_t   altrochip   =  0;
2217   Int_t   feclocbran  =  0;
2218   Int_t   branch      =  0;
2219   Short_t rcuget      =  0;
2220   Int_t   emptyI      =  1;
2221   Int_t   index       = -1;
2222   Int_t   hwadd       =  0;
2223
2224   Float_t maxiroc     =  fHistIROCClone->GetMaximum();
2225   Float_t maxoroc     =  fHistOROCClone->GetMaximum();
2226
2227
2228   //  restore original histos
2229   for(Int_t row = 0; row<fkNRowsIroc;  row++)
2230     {
2231     for(Int_t pad = 0; pad<fkNPadsIroc;  pad++)
2232       {
2233       index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
2234       if(index==-1)continue;
2235       else  fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
2236       }
2237     }
2238   for(Int_t row = 0; row<fkNRowsOroc;  row++)
2239     {
2240       for(Int_t pad = 0; pad<fkNPadsOroc;  pad++)
2241         {
2242           index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
2243           if(index==-1)continue;
2244           else    fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
2245         }
2246     }
2247
2248
2249   // remove not matching entries from fHistIROC/fHistOROC
2250
2251   TH2F* fHist       =0;
2252   TH2S* fHistIndex  =0;
2253   Int_t npads       =0;
2254   Int_t subrows     =0;
2255
2256   for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc);  row++)
2257     {
2258       if(row<fkNRowsIroc) {  fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0         ;}
2259       else                {  fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
2260
2261       for(Int_t pad = 0; pad<npads;  pad++)
2262         {
2263           index    = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
2264           if(index==-1)  continue ;
2265           hwadd    = (Int_t)fHistChannelTime->GetCellContent(index,0);
2266
2267           // global fecnr
2268           fecnr     =  fMapHand->GetFECfromHw(hwadd);
2269           if(compval[0]!=-1 && fecnr!=compval[0])      {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
2270
2271           // rcu
2272           rcuget      = (hwadd & AliTPCMonitorAltro::GetHwMaskRCU())>> 12;
2273           if(compval[1]!=-1 && rcuget!=compval[1])     {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
2274
2275           // branch
2276           branch    =  fMapHand->U2fGetBranch(fecnr) ;
2277           if(compval[2]!=-1 && branch!=compval[2])     {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
2278
2279           // local fec
2280           feclocbran=   fMapHand->U2fGetFECinBranch(fecnr) ;
2281           if(compval[3]!=-1 && feclocbran!=compval[3]) {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
2282
2283           // connector
2284           connector =  fMapHand->GetFECconnector(hwadd);
2285           if(compval[4]!=-1 && connector!=compval[4])  {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
2286
2287           // Altro chip
2288           altrochip     =  fMapHand->GetAltro(hwadd);
2289           if(compval[5]!=-1 && altrochip!=compval[5])      {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
2290           emptyI =0;
2291         }
2292     }
2293
2294   TCanvas* c1 =0;
2295   TCanvas* c2 =0;
2296   if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2297     {
2298       c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
2299       c1->cd() ;
2300       fHistIROC->Draw("COLZ");
2301       fHistIROC->SetMaximum(maxiroc);
2302       fHistIROC->SetMinimum(0.0);
2303       c1->Update();
2304     }
2305   if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2306     {
2307       c2 =  (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
2308       c2->cd() ;
2309       fHistOROC->Draw("COLZ");
2310       fHistOROC->SetMaximum(maxoroc);
2311       fHistOROC->SetMinimum(0.0);
2312       c2->Update();
2313     }
2314   return ;
2315 }
2316
2317 //__________________________________________________________________
2318 void AliTPCMonitor::ResizeCanv()
2319 {
2320   // Resize canvases and delete some of them
2321
2322   Char_t carry1[100];
2323   sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
2324   Char_t carry3[100];
2325   sprintf(carry3,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2326   if(fVerb) cout <<  " canv 1 " << endl;
2327
2328   if(gROOT->GetListOfCanvases()->FindObject(        "coroc_ch")) {  delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2329   if(gROOT->GetListOfCanvases()->FindObject(        "ciroc_ch")) {  delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2330
2331   // for 2dim plots delete create and draw again
2332   if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2333     {
2334       delete  gROOT->GetListOfCanvases()->FindObject("ciroc");
2335       TCanvas* ciroc = CreateCanvas("ciroc");
2336       ciroc->cd();
2337       fHistIROC->Draw("COLZ");
2338       ciroc->AddExec("pad",carry1);
2339       ciroc->AddExec("row",carry3);
2340       fExecPlaneMax=1;
2341       ciroc->Update();
2342     }
2343   // for 2dim plots delete create and draw again
2344   if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2345     {
2346       delete gROOT->GetListOfCanvases()->FindObject("coroc");
2347       TCanvas* coroc = CreateCanvas("coroc");
2348       coroc->cd();
2349       fHistOROC->Draw("COLZ");
2350
2351       coroc->AddExec("pad",carry1);
2352       coroc->AddExec("row",carry3);
2353       coroc->Update();
2354       fExecPlaneMax=1;
2355     }
2356
2357   if(gROOT->GetListOfCanvases()->FindObject(       "cbasemean")) {    delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2358   if(gROOT->GetListOfCanvases()->FindObject(           "cbase")) {    delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2359   if(gROOT->GetListOfCanvases()->FindObject(        "cbaserms")) {    delete gROOT->GetListOfCanvases()->FindObject("cbaserms");  }
2360   if(gROOT->GetListOfCanvases()->FindObject(            "cmax")) {    delete gROOT->GetListOfCanvases()->FindObject("cmax");      }
2361   if(gROOT->GetListOfCanvases()->FindObject(            "csum")) {    delete gROOT->GetListOfCanvases()->FindObject("csum");      }
2362   if(gROOT->GetListOfCanvases()->FindObject(  "ciroc_ch_trans")) {    delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2363   if(gROOT->GetListOfCanvases()->FindObject(  "coroc_ch_trans")) {    delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
2364   if(gROOT->GetListOfCanvases()->FindObject(       "crowtime")) {    delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2365   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2366   if(gROOT->GetListOfCanvases()->FindObject(          "cxmax")) {    delete gROOT->GetListOfCanvases()->FindObject("cxmax");    }
2367   if(gROOT->GetListOfCanvases()->FindObject(        "crmsoroc")) {    delete gROOT->GetListOfCanvases()->FindObject("crmsoroc");         fExecPadOrocRms = 0;   }
2368   if(gROOT->GetListOfCanvases()->FindObject(        "crmsiroc")) {    delete gROOT->GetListOfCanvases()->FindObject("crmsiroc");         fExecPadIrocRms = 0;   }
2369   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2370   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2371
2372 }
2373
2374
2375
2376
2377 //__________________________________________________________________
2378 Int_t AliTPCMonitor::ExecProcess()
2379 {
2380   // Executable for global Histogram
2381   // Will be called from /TPC/AliTPCMonitorExec.C(3)
2382   // Call ProcessEvent for same event and sector pointed at
2383
2384   Int_t side   = 0;
2385   Int_t sector = 0;
2386
2387   Int_t event = gPad->GetEvent();
2388   if(event != 61)  return -1;
2389
2390   TObject *select = gPad->GetSelected();
2391   if(!select)  return -1;
2392   if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0);    return -1;  }
2393   if(       strcmp(select->GetName(),"hglobal" )==0 || ( strcmp(select->GetName(),"SIDE A" )==0) ) side = 0;
2394   else  if( strcmp(select->GetName(),"hglobal2")==0 || ( strcmp(select->GetName(),"SIDE C" )==0) ) side = 1;
2395
2396   // get position
2397   Int_t   px    = gPad->GetEventX();
2398   Int_t   py    = gPad->GetEventY();
2399   Float_t upy   = gPad->AbsPixeltoY(py);
2400   Float_t upx   = gPad->AbsPixeltoX(px);
2401   Float_t y     = gPad->PadtoY(upy);
2402   Float_t x     = gPad->PadtoX(upx);
2403
2404   Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2405   Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2406   if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2407
2408   Float_t alpha = 0.0;
2409   if(x>0.0 && y > 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2410   if(x>0.0 && y < 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2411   if(x<0.0 && y < 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2412   if(x<0.0 && y > 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2413
2414   if(x>0.0 && y < 0.0)    alpha += (    TMath::Pi()/2);
2415   if(x<0.0 && y < 0.0)    alpha += (    TMath::Pi());
2416   if(x<0.0 && y > 0.0)    alpha += (1.5*TMath::Pi());
2417
2418   sector =   (Int_t)(alpha/(2*TMath::Pi()/18.0));
2419   if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0))  sector+=1;
2420
2421   if(sector==18 && side ==0 ) {
2422     AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2423     sector =0;
2424   }
2425
2426   sector = (18-sector +4)%18;
2427   SetLastSector(sector+ side*18);
2428   SetProcNextEvent(0);
2429
2430   if(fVerb) cout << "AliTPCMonitor::ExecProcess()  next side          " <<   side    << " next sector        " <<    sector  << endl;
2431
2432   return (Int_t)ProcessEvent();
2433
2434 }
2435
2436 //__________________________________________________________________
2437 Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
2438 {
2439
2440   // Return RCU patch index for given equipment id eqid
2441   Int_t patch = 0;
2442   //if(runid>=704)
2443   if ( eqid<768 || eqid>983 ) return 0; //no TPC eqid
2444   if(runid>=0)
2445     {
2446       if(eqid>=1000) return 0;
2447       patch = fMapEqidsRcu[eqid] ;
2448     }
2449   else
2450     {
2451       if(eqid==408) {patch =  13*6+4 +0;  }
2452       if(eqid==409) {patch =  13*6+5 +0;  }
2453       if(eqid==509) {patch =  13*6+0 +0;  }
2454       if(eqid==512) {patch =  13*6+3 +0;  }
2455       if(eqid==513) {patch =  13*6+1 +0;  }
2456       if(eqid==517) {patch =  13*6+2 +0;  }
2457
2458       if(eqid==404) {patch =  4*6+5 +0;   }
2459       if(eqid==504) {patch =  4*6+4 +0;   }
2460       if(eqid==407) {patch =  4*6+3 +0;   }
2461       if(eqid==503) {patch =  4*6+2 +0;   }
2462       if(eqid==508) {patch =  4*6+1 +0;   }
2463       if(eqid==506) {patch =  4*6+0 +0;   }
2464     }
2465   return patch;
2466 }
2467
2468 //__________________________________________________________________
2469 void AliTPCMonitor::DumpHeader(AliRawReaderRoot * readerROOT) const
2470 {
2471   // Dump Event header for ROOT format
2472
2473   cout << "EventHeader     : fReaderROOT->GetEquipmentSize()            :" << readerROOT->GetEquipmentSize()        << endl;
2474   cout << "EventHeader     : fReaderROOT->GetType()                     :" << readerROOT->GetType()                 << endl;
2475   cout << "EventHeader     : fReaderROOT->GetRunNumber()                :" << readerROOT->GetRunNumber()            << endl;
2476   cout << "EventHeader     : fReaderROOT->GetEventId()                  :" << *(readerROOT->GetEventId())           << endl;
2477   cout << "EventHeader     : fReaderROOT->GetLDCId()                    :" << readerROOT->GetLDCId()                << endl;
2478   cout << "EventHeader     : fReaderROOT->GetGDCId()                    :" << readerROOT->GetGDCId()                << endl;
2479 }
2480
2481 //__________________________________________________________________
2482 void AliTPCMonitor::DumpHeader(AliTPCMonitorDateFormat* dateform) const
2483 {
2484   // Dump Event header for DATE format
2485
2486   cout << "EquipmentHeader : dateform->GetEquipmentSize()               :" << dateform->GetEquipmentSize()          << endl;
2487   cout << "EquipmentHeader : dateform->GetEquipmentType()               :" << dateform->GetEquipmentType()          << endl;
2488   cout << "EquipmentHeader : dateform->GetEquipmentID()                 :" << dateform->GetEquipmentID()            << endl;
2489   cout << "EquipmentHeader : dateform->GetEquipmentTypeAttribute()      :" << dateform->GetEquipmentTypeAttribute() << endl;
2490   cout << "EquipmentHeader : dateform->GetEquipmentBasicSize()          :" << dateform->GetEquipmentBasicSize()     << endl;
2491   cout << "EquipmentHeader : dateform->GetEquipmentHeaderSize()         :" << dateform->GetEquipmentHeaderSize()    << endl;
2492   cout << "EquipmentHeader : dateform->IsLastSubEventHeader()           :" << dateform->IsLastSubEventHeader()      << endl;
2493 }
2494
2495 //__________________________________________________________________
2496 Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2497
2498   // Gamma4 function used to fit signals
2499   // Defined in sections: diverging branch set to 0
2500
2501   Double_t val  = 0.0;
2502   if(x[0] > par[1])
2503     val = par[0]*exp(4.0)* pow((x[0]-par[1])/par[2],4)*exp(-4.0*(x[0]-par[1])/par[2])+ par[3];
2504   else
2505     val = 0;
2506   return val;
2507 }
2508
2509 //__________________________________________________________________
2510 TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
2511 {
2512   // Create Canvases
2513
2514   TCanvas* canv =0;
2515
2516   Int_t xoffset  = GetCanvasXOffset();
2517   Int_t xsize    = GetCanvasXSize();
2518   Int_t ysize    = GetCanvasYSize();
2519   Int_t xspace   = GetCanvasXSpace();
2520   Int_t yspace   = GetCanvasYSpace();
2521
2522   // ROC 2dim max distribution
2523   if(     strcmp(name,"coroc"         )==0) {    canv   = new TCanvas("coroc"         ,"coroc"      ,                   -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2524   else if(strcmp(name,"ciroc"         )==0) {    canv   = new TCanvas("ciroc"         ,"ciroc"      ,                   -1+xoffset,                     0    ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2525   // ROC  2dim rms distribution
2526   else if(strcmp(name,"crmsoroc"      )==0) {    canv   = new TCanvas("crmsoroc"      ,"crmsoroc"   ,                   -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2527   else if(strcmp(name,"crmsiroc"      )==0) {    canv   = new TCanvas("crmsiroc"      ,"crmsiroc"   ,                   -1+xoffset,                        0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2528   // Global ADC max Histos
2529   else if(strcmp(name,"SIDE C all"    )==0) {    canv   = new TCanvas("SIDE C all"    ,"SIDE C all" ,   (Int_t)(3*xspace+ xoffset),(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2530   else if(strcmp(name,"SIDE A all"    )==0) {    canv   = new TCanvas("SIDE A all"    ,"SIDE A all" ,   (Int_t)(3*xspace+ xoffset),                        0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2531   // 1 dim max sum basekine distribution
2532   else if(strcmp(name,"cmax"          )==0) {    canv   = new TCanvas("cmax"          ,"cmax"       ,                   -1+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2533   else if(strcmp(name,"csum"          )==0) {    canv   = new TCanvas("csum"          ,"csum"       ,               xspace+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2534   else if(strcmp(name,"cbasemean"     )==0) {    canv   = new TCanvas("cbasemean"     ,"cbasemean"  ,             2*xspace+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2535   else if(strcmp(name,"cbaserms"      )==0) {    canv   = new TCanvas("cbaserms"      ,"cbaserms"   ,             3*xspace+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2536   // Projections of single channel
2537   else if(strcmp(name,"coroc_ch"      )==0) {    canv   = new TCanvas("coroc_ch"      ,"coroc_ch"   ,   (Int_t)(1.5*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2538   else if(strcmp(name,"ciroc_ch"      )==0) {    canv   = new TCanvas("ciroc_ch"      ,"ciroc_ch"   ,   (Int_t)(1.5*xspace+xoffset),                       0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2539   // FFT for single channel
2540   else if(strcmp(name,"coroc_ch_trans")==0) {    canv   = new TCanvas("coroc_ch_trans","coroc_ch_trans",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2541   else if(strcmp(name,"ciroc_ch_trans")==0) {    canv   = new TCanvas("ciroc_ch_trans","ciroc_ch_trans",(Int_t)(3.0*xspace+xoffset),                       0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2542   else if(strcmp(name,"coroc_ch_trans2")==0) {    canv   = new TCanvas("coroc_ch_trans2","coroc_ch_trans2",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2543   else if(strcmp(name,"ciroc_ch_trans2")==0) {    canv   = new TCanvas("ciroc_ch_trans2","ciroc_ch_trans2",(Int_t)(3.0*xspace+xoffset),                       0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2544   // row profile histograms
2545   else if(strcmp(name,"crowtime"     )==0) {    canv   = new TCanvas("crowtime"     ,"crowtime"  ,              1*xspace+xoffset,         2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2546   else if(strcmp(name,"crowmax"      )==0) {    canv   = new TCanvas("crowmax"      ,"crowmax"   ,              2*xspace+xoffset,         2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2547   else if(strcmp(name,"cxmax"        )==0) {    canv   = new TCanvas("cxmax"        ,"cxmax"     ,              3*xspace+xoffset,         2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2548   else                                      {    cout   << " Warning Canvas name unknown "  << endl;                                                                                                  return 0   ;  }
2549 }
2550
2551 //__________________________________________________________________
2552 void AliTPCMonitor::WriteHistos()
2553 {
2554   // Writes all available histograms to a file in current directory
2555   // File name will be specified by : sector, side, runid and eventnumber
2556
2557   if(GetEventProcessed())
2558     {
2559       AliInfo("Write histos to file");
2560       Char_t name[256];
2561       sprintf(name,"SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2562       TFile* f = new TFile(name,"recreate");
2563       for(Int_t i =0; i<fHistList->GetEntries(); i++)
2564         {
2565           if(((TH1*)fHistList->At(i))!=0)
2566             {
2567               ((TH1*)fHistList->At(i))->Write();
2568             }
2569         }
2570       f->ls();
2571       f->Close();
2572     }
2573   else
2574     {
2575       AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2576     }
2577 }
2578
2579
2580 //__________________________________________________________________
2581 TH1* AliTPCMonitor::GetHisto(char* histname)
2582 {
2583
2584   // Returns histogram specified by histname
2585   // check available names for histos in CreateHistos()
2586
2587   TH1* hist = 0;
2588   if((TH1*)fHistList->FindObject(histname))
2589     {
2590       hist = (TH1*)fHistList->FindObject(histname);
2591     }
2592   else
2593     {
2594       cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;
2595     }
2596   return hist ;
2597 }