TOF/AliTOFLvHvDataPoints.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: AliTOFLvHvDataPoints.cxx,v $
  18 */
  19
  20 // AliTOFLvHvDataPoints class
  21 // main aim to introduce the aliases for the TOF LV and HV DCS
  22 // data points to be then
  23 // stored in the OCDB, and to process them.
  24 // Process() method called by TOF preprocessor
  25
  26 #include "TString.h"
  27 #include "TTimeStamp.h"
  28 #include "TMap.h"
  29 #include "TMath.h"
  30 #include "TH1C.h"
  31
  32 #include "AliDCSValue.h"
  33 #include "AliLog.h"
  34 #include "AliBitPacking.h"
  35
  36 #include "AliTOFGeometry.h"
  37 #include "AliTOFDCSmaps.h"
  38 #include "AliTOFLvHvDataPoints.h"
  39
  40 class AliCDBMetaData;
  41 class TDatime;
  42
  43 ClassImp(AliTOFLvHvDataPoints)
  44
  45 //---------------------------------------------------------------
  46 AliTOFLvHvDataPoints::AliTOFLvHvDataPoints():
  47   TObject(),
  48   fRun(0),
  49   fStartTime(0),
  50   fEndTime(0),
  51   fStartTimeDCSQuery(0),
  52   fEndTimeDCSQuery(0),
  53   fIsProcessed(kFALSE),
  54   fFDR(kFALSE),
  55   fNumberOfLVdataPoints(0),
  56   fNumberOfHVdataPoints(0),
  57   fNumberOfHVandLVmaps(0),
  58   fStartingLVmap(0x0),
  59   fStartingHVmap(0x0),
  60   fHisto(0x0),
  61   fNSecondsBeforeEOR(60)
  62 {
  63   // main constructor
  64
  65   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fLVDataPoints[ii]= 0x0;
  66   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fHVDataPoints[ii]= 0x0;
  67   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fMap[ii]= 0x0;
  68
  69 }
  70
  71 //---------------------------------------------------------------
  72 AliTOFLvHvDataPoints::AliTOFLvHvDataPoints(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
  73   TObject(),
  74   fRun(nRun),
  75   fStartTime(startTime),
  76   fEndTime(endTime),
  77   fStartTimeDCSQuery(startTimeDCSQuery),
  78   fEndTimeDCSQuery(endTimeDCSQuery),
  79   fIsProcessed(kFALSE),
  80   fFDR(kFALSE),
  81   fNumberOfLVdataPoints(0),
  82   fNumberOfHVdataPoints(0),
  83   fNumberOfHVandLVmaps(0),
  84   fStartingLVmap(new AliTOFDCSmaps()),
  85   fStartingHVmap(new AliTOFDCSmaps()),
  86   fHisto(new TH1C("histo","",kNpads,-0.5,kNpads-0.5)),
  87   fNSecondsBeforeEOR(60)
  88 {
  89
  90   // constructor with arguments
  91
  92   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fLVDataPoints[ii]= 0x0;
  93   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fHVDataPoints[ii]= 0x0;
  94   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fMap[ii]= 0x0;
  95
  96   AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
  97                TTimeStamp(startTime).AsString(),
  98                TTimeStamp(endTime).AsString(),
  99                TTimeStamp(startTimeDCSQuery).AsString(),
 100                TTimeStamp(endTimeDCSQuery).AsString()));
 101
 102   Init();
 103
 104 }
 105
 106 //---------------------------------------------------------------
 107
 108 AliTOFLvHvDataPoints::AliTOFLvHvDataPoints(const AliTOFLvHvDataPoints & data):
 109   TObject(data),
 110   fRun(data.fRun),
 111   fStartTime(data.fStartTime),
 112   fEndTime(data.fEndTime),
 113   fStartTimeDCSQuery(data.fStartTimeDCSQuery),
 114   fEndTimeDCSQuery(data.fEndTimeDCSQuery),
 115   fIsProcessed(data.fIsProcessed),
 116   fFDR(data.fFDR),
 117   fNumberOfLVdataPoints(data.fNumberOfLVdataPoints),
 118   fNumberOfHVdataPoints(data.fNumberOfHVdataPoints),
 119   fNumberOfHVandLVmaps(data.fNumberOfHVandLVmaps),
 120   fStartingLVmap(data.fStartingLVmap),
 121   fStartingHVmap(data.fStartingHVmap),
 122   fHisto(data.fHisto),
 123   fNSecondsBeforeEOR(data.fNSecondsBeforeEOR)
 124 {
 125
 126   // copy constructor
 127
 128   for(int i=0;i<kNddl;i++)
 129     fAliasNamesXLVmap[i]=data.fAliasNamesXLVmap[i];
 130
 131   for(int i=0;i<kNsectors;i++)
 132     for(int j=0;j<kNplates;j++)
 133       fAliasNamesXHVmap[i][j]=data.fAliasNamesXHVmap[i][j];
 134
 135   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fLVDataPoints[ii]= data.fLVDataPoints[ii];
 136   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fHVDataPoints[ii]= data.fLVDataPoints[ii];
 137   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fMap[ii]= data.fMap[ii];
 138
 139 }
 140 //---------------------------------------------------------------
 141
 142 AliTOFLvHvDataPoints& AliTOFLvHvDataPoints:: operator=(const AliTOFLvHvDataPoints & data) {
 143
 144   // assignment operator
 145
 146   if (this == &data)
 147     return *this;
 148
 149   TObject::operator=(data);
 150   fRun=data.GetRun();
 151   fStartTime=data.GetStartTime();
 152   fEndTime=data.GetEndTime();
 153   fStartTimeDCSQuery=data.GetStartTimeDCSQuery();
 154   fEndTimeDCSQuery=data.GetEndTimeDCSQuery();
 155
 156   fNumberOfLVdataPoints=data.fNumberOfLVdataPoints;
 157   fNumberOfHVdataPoints=data.fNumberOfHVdataPoints;
 158   fNumberOfHVandLVmaps=data.fNumberOfHVandLVmaps;
 159
 160   fStartingLVmap=data.fStartingLVmap;
 161   fStartingHVmap=data.fStartingHVmap;
 162
 163   for(int i=0;i<kNddl;i++)
 164     fAliasNamesXLVmap[i]=data.fAliasNamesXLVmap[i];
 165
 166   for(int i=0;i<kNsectors;i++)
 167     for(int j=0;j<kNplates;j++)
 168       fAliasNamesXHVmap[i][j]=data.fAliasNamesXHVmap[i][j];
 169
 170   fHisto=data.fHisto;
 171
 172   fNSecondsBeforeEOR=data.fNSecondsBeforeEOR;
 173
 174   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fLVDataPoints[ii]= data.fLVDataPoints[ii];
 175   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fHVDataPoints[ii]= data.fLVDataPoints[ii];
 176   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) fMap[ii]= data.fMap[ii];
 177
 178   return *this;
 179 }
 180 //---------------------------------------------------------------
 181 AliTOFLvHvDataPoints::~AliTOFLvHvDataPoints() {
 182
 183   // destructor
 184
 185   delete fStartingLVmap;
 186   delete fStartingHVmap;
 187
 188   for (Int_t ii=0; ii<kNmaxDataPoints; ii++)
 189     if (fLVDataPoints[ii]) fLVDataPoints[ii]->Delete();
 190   for (Int_t ii=0; ii<kNmaxDataPoints; ii++)
 191     if (fHVDataPoints[ii]) fHVDataPoints[ii]->Delete();
 192   for (Int_t ii=0; ii<kNmaxDataPoints; ii++)
 193     if (fMap[ii]) fMap[ii]->Delete();
 194
 195 }
 196
 197 //---------------------------------------------------------------
 198 Bool_t AliTOFLvHvDataPoints::ProcessData(TMap& aliasMap) {
 199   //
 200   // method to process the data
 201   //
 202
 203   if(!(fAliasNamesXHVmap[0][0]) || !(fAliasNamesXLVmap[0])) Init();
 204
 205   AliInfo(Form(" Start Time = %i",fStartTime));
 206   AliInfo(Form(" End Time = %i",fEndTime));
 207   AliInfo(Form(" Start Time DCS Query= %i",fStartTimeDCSQuery));
 208   AliInfo(Form(" End Time DCS Query= %i",fEndTimeDCSQuery));
 209
 210   if (fEndTime==fStartTime){
 211     AliError(Form(" Run with null time length: start time = %d = end time = %d",fStartTime,fEndTime));
 212     return kFALSE;
 213   }
 214
 215
 216   if (!ReadLVDataPoints(aliasMap)) return kFALSE;
 217   AliDebug(1,Form(" Number of LV dp value changes = %d",fNumberOfLVdataPoints));
 218
 219   if (!ReadHVDataPoints(aliasMap)) return kFALSE;
 220   AliDebug(1,Form(" Number of HV dp value changes = %d",fNumberOfHVdataPoints));
 221
 222   if (!MergeLVmap()) return kFALSE;
 223
 224   if (!MergeHVmap()) return kFALSE;
 225
 226   if (!MergeMaps()) return kFALSE;
 227
 228   fIsProcessed=kTRUE;
 229
 230   return kTRUE;
 231
 232 }
 233
 234 //---------------------------------------------------------------
 235 Bool_t AliTOFLvHvDataPoints::MergeMaps() {
 236   //
 237   // Merge together LV and HV maps
 238   //
 239
 240   Int_t timeMaps[kNmaxDataPoints];
 241   for (Int_t ii=0; ii<kNmaxDataPoints; ii++) timeMaps[ii]=0;
 242
 243   for (Int_t ii=0; ii<fNumberOfHVdataPoints; ii++) {
 244     AliDebug(1,Form(" fNumberOfHVandLVmaps = %d (HV=%d, LV=%d) - time=%d",fNumberOfHVandLVmaps,fNumberOfHVdataPoints,fNumberOfLVdataPoints,timeMaps[fNumberOfHVandLVmaps]));
 245     timeMaps[fNumberOfHVandLVmaps++]=fHVDataPoints[ii]->GetTime();
 246   }
 247
 248   AliDebug(1,Form(" fNumberOfHVandLVmaps = %d (HV=%d) ",fNumberOfHVandLVmaps,fNumberOfHVdataPoints));
 249
 250   Bool_t check = kTRUE;
 251   for (Int_t jj=0; jj<fNumberOfLVdataPoints; jj++) {
 252     check = kTRUE;
 253     for (Int_t ii=0; ii<fNumberOfHVdataPoints; ii++)
 254       check=check&&(fLVDataPoints[jj]->GetTime()!=timeMaps[ii]);
 255
 256     if (check) {
 257       AliDebug(1,Form(" fNumberOfHVandLVmaps = %d (HV=%d, LV=%d) - time=%d",fNumberOfHVandLVmaps,fNumberOfHVdataPoints,fNumberOfLVdataPoints,timeMaps[fNumberOfHVandLVmaps]));
 258       timeMaps[fNumberOfHVandLVmaps++]=fLVDataPoints[jj]->GetTime();
 259     }
 260   }
 261
 262   AliInfo(Form(" TOF HV dps = %d; TOF LV dps = %d; TOF HVandLV dps %d",
 263                fNumberOfHVdataPoints, fNumberOfLVdataPoints, fNumberOfHVandLVmaps));
 264
 265
 266   Int_t *controller = new Int_t[sizeof(Int_t)*fNumberOfHVandLVmaps]; // fix for coverity
 267   for (Int_t ii=0; ii<fNumberOfHVandLVmaps; ii++) controller[ii]=-1;
 268   TMath::Sort(fNumberOfHVandLVmaps,timeMaps,controller,kFALSE); // increasing order
 269
 270   for (Int_t ii=0; ii<fNumberOfHVandLVmaps; ii++)
 271     AliDebug(1, Form(" Time Order - time[controller[%d]] = %d", ii, timeMaps[controller[ii]]));
 272
 273   Short_t array[kNpads];
 274   for (Int_t iPad=0; iPad<kNpads; iPad++) array[iPad]=-1;
 275   Int_t time = 0;
 276
 277   // HVandLV status map during run
 278   for (Int_t index=0; index<fNumberOfHVandLVmaps; index++) {
 279     time = timeMaps[controller[index]];
 280
 281     AliDebug(2, Form(" Time Order - time[controller[%d]] = %d", index, timeMaps[controller[index]]));
 282
 283     for (Int_t ii=0; ii<fNumberOfHVdataPoints; ii++)
 284       for (Int_t jj=0; jj<fNumberOfLVdataPoints; jj++) {
 285
 286         AliDebug(2,Form(" time=%d --- HVdp_time[%d]=%d, LVdp_time[%d]=%d",
 287                         time,
 288                         ii,fHVDataPoints[ii]->GetTime(),
 289                         jj,fLVDataPoints[jj]->GetTime()));
 290
 291         if ( (fHVDataPoints[ii]->GetTime()==time && fLVDataPoints[jj]->GetTime()<=time) ||
 292              (fLVDataPoints[jj]->GetTime()==time && fHVDataPoints[ii]->GetTime()<=time) ) {
 293
 294           AliDebug(2,Form(" HVdp_time[%d]=%d, LVdp_time[%d]=%d",
 295                           ii,fHVDataPoints[ii]->GetTime(),
 296                           jj,fLVDataPoints[jj]->GetTime()));
 297           for (Int_t iPad=0; iPad<kNpads; iPad++)
 298             array[iPad] = fHVDataPoints[ii]->GetCellValue(iPad)*fLVDataPoints[jj]->GetCellValue(iPad);
 299           AliTOFDCSmaps *object = new AliTOFDCSmaps(time,array);
 300           fMap[index]= object;
 301           break;
 302
 303         }
 304         else if ( fHVDataPoints[ii]->GetTime()==time && fLVDataPoints[jj]->GetTime()>time ) {
 305
 306           AliDebug(2,Form(" HVdp_time[%d]=%d, (no LVdp)",ii,fHVDataPoints[ii]->GetTime()));
 307           for (Int_t iPad=0; iPad<kNpads; iPad++)
 308             array[iPad] = fHVDataPoints[ii]->GetCellValue(iPad);
 309           AliTOFDCSmaps *object = new AliTOFDCSmaps(time,array);
 310           fMap[index]= object;
 311           break;
 312
 313         } else if ( fLVDataPoints[jj]->GetTime()==time && fHVDataPoints[ii]->GetTime()>time ) {
 314
 315           AliDebug(2,Form(" LVdp_time[%d]=%d, (no HVdp)",jj,fLVDataPoints[jj]->GetTime()));
 316           for (Int_t iPad=0; iPad<kNpads; iPad++)
 317             array[iPad] = fLVDataPoints[jj]->GetCellValue(iPad);
 318           AliTOFDCSmaps *object = new AliTOFDCSmaps(time,array);
 319           fMap[index]= object;
 320           break;
 321
 322         }
 323
 324       }
 325
 326   }
 327
 328   delete [] controller;
 329
 330   for (Int_t ii=0; ii<fNumberOfHVandLVmaps; ii++)
 331     AliDebug(1,Form(" fMap[%d]->GetTime() = %d ",ii,fMap[ii]->GetTime()));
 332
 333   return kTRUE;
 334
 335 }
 336
 337 //---------------------------------------------------------------
 338 Bool_t AliTOFLvHvDataPoints::MergeHVmap() {
 339   //
 340   // Create HV maps from HV dps
 341   //
 342
 343   Bool_t check= kFALSE;
 344
 345   if (fNumberOfHVdataPoints==0)
 346     return check;
 347   else {
 348
 349     // first map construction
 350     for (Int_t iPad=0; iPad<kNpads; iPad++) {
 351       if (fHVDataPoints[0]->GetCellValue(iPad)==-1)
 352         fHVDataPoints[0]->SetCellValue(iPad,fStartingHVmap->GetCellValue(iPad));
 353       //else
 354       //fHVDataPoints[0]->SetCellValue(iPad,fHVDataPoints[0]->GetCellValue(iPad)*fStartingHVmap->GetCellValue(iPad));
 355
 356       if (iPad%(96*91)==0)
 357         AliDebug(2,Form("HVdp0: channel=%6d -> %1d",iPad,fHVDataPoints[0]->GetCellValue(iPad)));
 358     }
 359
 360     // other maps construction
 361     for (Int_t ii=1; ii<fNumberOfHVdataPoints; ii++) {
 362       for (Int_t iPad=0; iPad<kNpads; iPad++) {
 363         if (fHVDataPoints[ii]->GetCellValue(iPad)==-1)
 364           fHVDataPoints[ii]->SetCellValue(iPad,fHVDataPoints[ii-1]->GetCellValue(iPad));
 365
 366         if (iPad%(96*91)==0)
 367           AliDebug(2,Form("HVdp%d: channel=%6d -> %1d",ii,iPad,fHVDataPoints[ii]->GetCellValue(iPad)));
 368       }
 369     }
 370
 371     check=kTRUE;
 372   }
 373
 374   return kTRUE;
 375
 376 }
 377
 378 //---------------------------------------------------------------
 379 Bool_t AliTOFLvHvDataPoints::MergeLVmap() {
 380   //
 381   // Create LV maps from LV dps
 382   //
 383
 384   Bool_t check= kFALSE;
 385
 386   if (fNumberOfLVdataPoints==0)
 387     return check;
 388   else {
 389
 390     // first map construction
 391     for (Int_t iPad=0; iPad<kNpads; iPad++) {
 392       if (fLVDataPoints[0]->GetCellValue(iPad)==-1)
 393         fLVDataPoints[0]->SetCellValue(iPad,fStartingLVmap->GetCellValue(iPad));
 394       //else
 395       //fLVDataPoints[0]->SetCellValue(iPad,fLVDataPoints[0]->GetCellValue(iPad)*fStartingLVmap->GetCellValue(iPad));
 396
 397       if (iPad%(96*91)==0)
 398         AliDebug(2,Form("LVdp0: channel=%6d -> %1d",iPad,fLVDataPoints[0]->GetCellValue(iPad)));
 399     }
 400
 401     // other maps construction
 402     for (Int_t ii=1; ii<fNumberOfLVdataPoints; ii++) {
 403       for (Int_t iPad=0; iPad<kNpads; iPad++) {
 404         if (fLVDataPoints[ii]->GetCellValue(iPad)==-1)
 405           fLVDataPoints[ii]->SetCellValue(iPad,fLVDataPoints[ii-1]->GetCellValue(iPad));
 406
 407         if (iPad%(96*91)==0)
 408           AliDebug(2,Form("LVdp%d: channel=%6d -> %1d",ii,iPad,fLVDataPoints[ii]->GetCellValue(iPad)));
 409       }
 410     }
 411
 412     check=kTRUE;
 413   }
 414
 415   return check;
 416
 417 }
 418
 419 //---------------------------------------------------------------
 420 Bool_t AliTOFLvHvDataPoints::ReadHVDataPoints(TMap& aliasMap) {
 421   //
 422   // Read HV dps
 423   //
 424
 425   TObjArray *aliasArr;
 426   AliDCSValue* aValue;
 427   AliDCSValue* aValuePrev;
 428   Int_t val = 0;
 429   Int_t time = 0;
 430   Int_t nEntries = 0;
 431
 432   Short_t dummy[kNpads];
 433
 434   for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
 435   // starting loop on aliases
 436   for (int i=0; i<kNsectors; i++)
 437     for (int j=0; j<kNplates; j++) {
 438       aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNamesXHVmap[i][j].Data());
 439       if (!aliasArr) {
 440         AliError(Form("Alias %s not found!", fAliasNamesXHVmap[i][j].Data()));
 441         if (!fFDR)
 442           return kFALSE;    // returning only in case we are not in a FDR run
 443         else
 444           continue;
 445       }
 446
 447       nEntries = aliasArr->GetEntries();
 448
 449       if (nEntries<2) AliDebug(1, Form(" NB: number of values for dp %s %d (less than 2)",fAliasNamesXHVmap[i][j].Data(),nEntries));
 450
 451       if (nEntries==0) {
 452         AliError(Form("Alias %s has no entries! Nothing will be stored",
 453                       fAliasNamesXHVmap[i][j].Data()));
 454         continue;
 455       }
 456       else {
 457
 458         // read the first value
 459         for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
 460         aValue = (AliDCSValue*) aliasArr->At(0);
 461         val = aValue->GetInt();
 462         time = aValue->GetTimeStamp();
 463         AliDebug(1, Form(" at t=%d, 1st value for dp %s = %d", time, fAliasNamesXHVmap[i][j].Data(), val));
 464         FillHVarrayPerDataPoint(i,j,val,dummy);
 465         AliTOFDCSmaps *object0 = new AliTOFDCSmaps(time,dummy);
 466         if (InsertHVDataPoint(object0)!=0) return kTRUE; // to be verified
 467
 468         // read the values from the second one
 469         for (Int_t iEntry=1; iEntry<nEntries; iEntry++) {
 470           for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
 471           aValue = (AliDCSValue*) aliasArr->At(iEntry);
 472           val = aValue->GetInt();
 473           time = aValue->GetTimeStamp();
 474           AliDebug(2, Form(" at t=%d, %dth value for dp %s = %d", time, iEntry+1, fAliasNamesXHVmap[i][j].Data(), val));
 475           aValuePrev = (AliDCSValue*) aliasArr->At(iEntry-1);
 476           if (aValuePrev->GetInt()!=val) {
 477             AliDebug(1, Form(" CHANGE - at t=%d, %dth value for dp %s = %d", time, iEntry+1, fAliasNamesXHVmap[i][j].Data(), val));
 478             FillHVarrayPerDataPoint(i,j,val,dummy);
 479             AliTOFDCSmaps *object = new AliTOFDCSmaps(time,dummy);
 480             if (InsertHVDataPoint(object)!=0) return kTRUE; // to be verified
 481           }
 482
 483         }
 484       }
 485     }
 486
 487   if (fNumberOfHVdataPoints==0) {
 488     AliInfo("Valid HV dps not found. By default all HV TOF channels (except the ones in the PHOS holes) switched ON, at SOR.");
 489     if (InsertHVDataPoint(fStartingHVmap)!=0) return kTRUE; // to be verified
 490   }
 491
 492   return kTRUE;
 493
 494 }
 495
 496 //---------------------------------------------------------------
 497 Bool_t AliTOFLvHvDataPoints::ReadLVDataPoints(TMap& aliasMap) {
 498   //
 499   // Read LV dps
 500   //
 501
 502   TObjArray *aliasArr;
 503   AliDCSValue* aValue;
 504   AliDCSValue* aValuePrev;
 505   Int_t val = 0;
 506   Int_t time = 0;
 507   Int_t nEntries = 0;
 508
 509   Short_t dummy[kNpads];
 510
 511   for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
 512   // starting loop on aliases
 513   for (int i=0; i<kNddl; i++) {
 514     aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNamesXLVmap[i].Data());
 515     if (!aliasArr) {
 516       AliError(Form("Alias %s not found!", fAliasNamesXLVmap[i].Data()));
 517       if (!fFDR)
 518         return kFALSE;    // returning only in case we are not in a FDR run
 519       else
 520         continue;
 521     }
 522
 523     nEntries = aliasArr->GetEntries();
 524
 525     if (nEntries<2) AliDebug(1, Form(" NB: number of values for dp %s %d (less than 2)",fAliasNamesXLVmap[i].Data(),nEntries));
 526
 527     if (nEntries==0) {
 528       AliError(Form("Alias %s has no entries! Nothing will be stored",
 529                     fAliasNamesXLVmap[i].Data()));
 530       continue;
 531     }
 532     else {
 533
 534       // read the first value
 535       for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
 536       aValue = (AliDCSValue*) aliasArr->At(0);
 537       val = aValue->GetInt();
 538       time = aValue->GetTimeStamp();
 539       AliDebug(1, Form(" at t=%d, 1st value for dp %s = %d", time, fAliasNamesXLVmap[i].Data(), val));
 540       FillLVarrayPerDataPoint(i,val,dummy);
 541       AliTOFDCSmaps *object0 = new AliTOFDCSmaps(time,dummy);
 542       if (InsertLVDataPoint(object0)!=0) return kTRUE; // to be verified
 543
 544       // read the values from the second one
 545       for (Int_t iEntry=1; iEntry<nEntries; iEntry++) {
 546         for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
 547         aValue = (AliDCSValue*) aliasArr->At(iEntry);
 548         val = aValue->GetInt();
 549         time = aValue->GetTimeStamp();
 550         AliDebug(2, Form(" at t=%d, %dth value for dp %s = %d", time, iEntry+1, fAliasNamesXLVmap[i].Data(), val));
 551         aValuePrev = (AliDCSValue*) aliasArr->At(iEntry-1);
 552         if (aValuePrev->GetInt()!=val) {
 553           AliDebug(1, Form(" CHANGE - at t=%d, %dth value for dp %s = %d", time, iEntry+1, fAliasNamesXLVmap[i].Data(), val));
 554           FillLVarrayPerDataPoint(i,val,dummy);
 555           AliTOFDCSmaps *object = new AliTOFDCSmaps(time,dummy);
 556           if (InsertLVDataPoint(object)!=0) return kTRUE; // to be verified
 557         }
 558
 559       }
 560     }
 561   }
 562
 563   if (fNumberOfLVdataPoints==0) {
 564     AliInfo("Valid LV dps not found. By default all LV TOF channels switched ON, at SOR.");
 565     if (InsertLVDataPoint(fStartingLVmap)!=0) return kTRUE; // to be verified
 566   }
 567
 568   return kTRUE;
 569
 570 }
 571
 572 //---------------------------------------------------------------
 573 Int_t AliTOFLvHvDataPoints::InsertHVDataPoint(AliTOFDCSmaps *object)
 574 {
 575   //
 576   // Insert HV dp in the HV dps array.
 577   // The HV dps array is sorted according to increasing dp timeStamp value
 578   //
 579
 580   if (fNumberOfHVdataPoints==kNmaxDataPoints) {
 581     AliError("Too many HV data points!");
 582     return 1;
 583   }
 584
 585   if (fNumberOfHVdataPoints==0) {
 586     fHVDataPoints[fNumberOfHVdataPoints++] = object;
 587     return 0;
 588   }
 589
 590   for (Int_t index=0; index<fNumberOfHVdataPoints; index++) {
 591     if (object->GetTime()==fHVDataPoints[index]->GetTime()) {
 592       fHVDataPoints[index]->Update(object);
 593       return 0;
 594     }
 595   }
 596
 597   Int_t ii = FindHVdpIndex(object->GetTime());
 598   memmove(fHVDataPoints+ii+1 ,fHVDataPoints+ii,(fNumberOfHVdataPoints-ii)*sizeof(AliTOFDCSmaps*));
 599   fHVDataPoints[ii] = object;
 600   fNumberOfHVdataPoints++;
 601
 602   return 0;
 603
 604 }
 605
 606 //_________________________________________________________________________
 607 Int_t AliTOFLvHvDataPoints::FindHVdpIndex(Int_t z) const {
 608   //
 609   // This function returns the index of the nearest HV DP in time
 610   //
 611
 612   if (fNumberOfHVdataPoints==0) return 0;
 613   if (z <= fHVDataPoints[0]->GetTime()) return 0;
 614   if (z > fHVDataPoints[fNumberOfHVdataPoints-1]->GetTime()) return fNumberOfHVdataPoints;
 615   Int_t b = 0, e = fNumberOfHVdataPoints-1, m = (b+e)/2;
 616   for (; b<e; m=(b+e)/2) {
 617     if (z > fHVDataPoints[m]->GetTime()) b=m+1;
 618     else e=m;
 619   }
 620
 621   return m;
 622
 623 }
 624
 625 //---------------------------------------------------------------
 626 Int_t AliTOFLvHvDataPoints::InsertLVDataPoint(AliTOFDCSmaps *object)
 627 {
 628   //
 629   // Insert LV dp in the LV dps array.
 630   // The LV dps array is sorted according to increasing dp timeStamp value
 631   //
 632
 633   if (fNumberOfLVdataPoints==kNmaxDataPoints) {
 634     AliError("Too many LV data points!");
 635     return 1;
 636   }
 637
 638   if (fNumberOfLVdataPoints==0) {
 639     fLVDataPoints[fNumberOfLVdataPoints++] = object;
 640     return 0;
 641   }
 642
 643   for (Int_t index=0; index<fNumberOfLVdataPoints; index++) {
 644     if (object->GetTime()==fLVDataPoints[index]->GetTime()) {
 645       fLVDataPoints[index]->Update(object);
 646       return 0;
 647     }
 648   }
 649
 650   Int_t ii = FindLVdpIndex(object->GetTime());
 651   memmove(fLVDataPoints+ii+1 ,fLVDataPoints+ii,(fNumberOfLVdataPoints-ii)*sizeof(AliTOFDCSmaps*));
 652   fLVDataPoints[ii] = object;
 653   fNumberOfLVdataPoints++;
 654
 655   return 0;
 656
 657 }
 658
 659 //_________________________________________________________________________
 660 Int_t AliTOFLvHvDataPoints::FindLVdpIndex(Int_t z) const {
 661   //
 662   // This function returns the index of the nearest LV DP in time
 663   //
 664
 665   if (fNumberOfLVdataPoints==0) return 0;
 666   if (z <= fLVDataPoints[0]->GetTime()) return 0;
 667   if (z > fLVDataPoints[fNumberOfLVdataPoints-1]->GetTime()) return fNumberOfLVdataPoints;
 668   Int_t b = 0, e = fNumberOfLVdataPoints-1, m = (b+e)/2;
 669   for (; b<e; m=(b+e)/2) {
 670     if (z > fLVDataPoints[m]->GetTime()) b=m+1;
 671     else e=m;
 672   }
 673
 674   return m;
 675
 676 }
 677
 678 //---------------------------------------------------------------
 679 void AliTOFLvHvDataPoints::Init(){
 680   //
 681   // Initialize aliases and DCS data
 682   //
 683
 684   TString sindex;
 685   for(int i=0;i<kNsectors;i++)
 686     for(int j=0;j<kNplates;j++) {
 687       fAliasNamesXHVmap[i][j] = "TOF_HVSTATUS_";
 688       sindex.Form("SM%02dMOD%1d",i,j);
 689       fAliasNamesXHVmap[i][j] += sindex;
 690     }
 691
 692
 693   for(int i=0;i<kNddl;i++) {
 694     fAliasNamesXLVmap[i] = "TOF_FEACSTATUS_";
 695     sindex.Form("%02d",i);
 696     fAliasNamesXLVmap[i] += sindex;
 697   }
 698
 699   fStartingLVmap->SetTime(0);
 700   for (Int_t iPad=0; iPad<kNpads; iPad++)
 701     fStartingLVmap->SetCellValue(iPad,1);
 702
 703   fStartingHVmap->SetTime(0);
 704   for (Int_t iPad=0; iPad<kNpads; iPad++) {
 705     Int_t vol[5] = {-1,-1,-1,-1,-1};
 706     AliTOFGeometry::GetVolumeIndices(iPad,vol);
 707     if ( (vol[0]==13 || vol[0]==14 || vol[0]==15) &&
 708          vol[1]==2)
 709       fStartingHVmap->SetCellValue(iPad,0);
 710     else
 711       fStartingHVmap->SetCellValue(iPad,1);
 712   }
 713
 714 }
 715
 716 //---------------------------------------------------------------
 717 void AliTOFLvHvDataPoints::FillHVarrayPerDataPoint(Int_t sector, Int_t plate, UInt_t baseWord, Short_t *array) const
 718 {
 719   //
 720   // Set the status of the TOF pads connected to the HV dp
 721   // labelled by sector and plate numbers
 722   //
 723
 724   Int_t det[5] = {sector, plate, -1, -1, -1};
 725   UInt_t checkBit = 0;
 726
 727   Int_t channel = -1;
 728
 729   for (Int_t iStrip=0; iStrip<AliTOFGeometry::NStrip(plate); iStrip++) {
 730     checkBit = AliBitPacking::UnpackWord(baseWord,iStrip,iStrip);
 731     for (Int_t iPadZ=0; iPadZ<AliTOFGeometry::NpadZ(); iPadZ++)
 732       for (Int_t iPadX=0; iPadX<AliTOFGeometry::NpadX(); iPadX++) {
 733         det[2] = iStrip;
 734         det[3] = iPadZ;
 735         det[4] = iPadX;
 736         channel = AliTOFGeometry::GetIndex(det);
 737         array[channel]=checkBit;
 738     }
 739   }
 740
 741
 742 }
 743
 744 //---------------------------------------------------------------
 745 void AliTOFLvHvDataPoints::FillLVarrayPerDataPoint(Int_t nDDL, UInt_t baseWord, Short_t *array) const
 746 {
 747   //
 748   // Set the status of the TOF pads connected to the LV dp
 749   // labelled by TOF crate number
 750   //
 751
 752   Int_t det[5] = {nDDL/4, -1, -1, -1, -1};
 753   UInt_t checkBit = 0;
 754
 755   Int_t iStripXsm[6] = {-1,-1,-1,-1,-1,-1};
 756   Int_t firstPadX = -1;
 757   Int_t lastPadX = -1;
 758   Int_t plate = -1;
 759   Int_t strip = -1;
 760
 761   Int_t channel = -1;
 762
 763   for (Int_t nFEAC=0; nFEAC<8; nFEAC++) {
 764     checkBit = AliBitPacking::UnpackWord(baseWord,nFEAC,nFEAC);
 765     firstPadX = -1;
 766     lastPadX = -1;
 767     GetStripsConnectedToFEAC(nDDL, nFEAC, iStripXsm, firstPadX,lastPadX);
 768     for (Int_t index=0; index<6; index++) {
 769       if (iStripXsm[index]==-1) continue;
 770
 771       for (Int_t iPadZ=0; iPadZ<AliTOFGeometry::NpadZ(); iPadZ++)
 772         for (Int_t iPadX=firstPadX; iPadX<=lastPadX; iPadX++) {
 773           AliTOFGeometry::GetStripAndModule(iStripXsm[index],plate,strip);
 774           det[1] = plate;
 775           det[2] = strip;
 776           det[3] = iPadZ;
 777           det[4] = iPadX;
 778           channel = AliTOFGeometry::GetIndex(det);
 779           array[channel]=checkBit;
 780         }
 781     }
 782   }
 783
 784
 785 }
 786
 787 //---------------------------------------------------------------
 788 void AliTOFLvHvDataPoints::GetStripsConnectedToFEAC(Int_t nDDL, Int_t nFEAC, Int_t *iStrip, Int_t &firstPadX, Int_t &lastPadX) const
 789 {
 790   //
 791   // FEAC-strip mapping:
 792   // return the strips and first PadX numbers
 793   // connected to the FEAC number nFEAC in the crate number nDDL
 794   //
 795
 796   for (Int_t ii=0; ii<6; ii++) iStrip[ii]=-1;
 797
 798   if (nDDL<0 || nDDL>=kNddl || nFEAC<0 || nFEAC>=8) return;
 799
 800   switch (nDDL%4) {
 801   case 0:
 802     firstPadX =  0;
 803     lastPadX  = AliTOFGeometry::NpadX()/2-1;
 804
 805     if (nFEAC<=2)
 806       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC;
 807     else if (nFEAC==3)
 808       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=ii+6*nFEAC;
 809     else if (nFEAC==4)
 810       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC-1;
 811     else if (nFEAC==5)
 812       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=ii+6*nFEAC-1;
 813     else if (nFEAC==6)
 814       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC-2;
 815     else if (nFEAC==7)
 816       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=ii+6*nFEAC-2;
 817
 818     break;
 819   case 1:
 820     firstPadX = AliTOFGeometry::NpadX()/2;
 821     lastPadX  = AliTOFGeometry::NpadX()-1;
 822
 823     if (nFEAC<=2)
 824       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC;
 825     else if (nFEAC==3)
 826       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=ii+6*nFEAC;
 827     else if (nFEAC==4)
 828       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC-1;
 829     else if (nFEAC==5)
 830       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC-1;
 831     else if (nFEAC==6)
 832       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=ii+6*nFEAC-1;
 833     else if (nFEAC==7)
 834       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=ii+6*nFEAC-2;
 835
 836     break;
 837   case 2:
 838     firstPadX = AliTOFGeometry::NpadX()/2;
 839     lastPadX  = AliTOFGeometry::NpadX()-1;
 840
 841     if (nFEAC<=2)
 842       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC);
 843     else if (nFEAC==3)
 844       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=90-(ii+6*nFEAC);
 845     else if (nFEAC==4)
 846       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC-1);
 847     else if (nFEAC==5)
 848       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=90-(ii+6*nFEAC-1);
 849     else if (nFEAC==6)
 850       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC-2);
 851     else if (nFEAC==7)
 852       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=90-(ii+6*nFEAC-2);
 853
 854     break;
 855   case 3:
 856     firstPadX =  0;
 857     lastPadX  = AliTOFGeometry::NpadX()/2-1;
 858
 859     if (nFEAC<=2)
 860       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC);
 861     else if (nFEAC==3)
 862       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=90-(ii+6*nFEAC);
 863     else if (nFEAC==4)
 864       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC-1);
 865     else if (nFEAC==5)
 866       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC-1);
 867     else if (nFEAC==6)
 868       for (Int_t ii=0; ii<5; ii++) iStrip[ii]=90-(ii+6*nFEAC-1);
 869     else if (nFEAC==7)
 870       for (Int_t ii=0; ii<6; ii++) iStrip[ii]=90-(ii+6*nFEAC-2);
 871
 872     break;
 873  }
 874
 875 }
 876
 877 //---------------------------------------------------------------
 878 void AliTOFLvHvDataPoints::Draw(const Option_t* /*option*/)
 879 {
 880   //
 881   // Draw all histos and graphs
 882   //
 883
 884   if(!fIsProcessed) return;
 885   /*
 886   TCanvas *ch;
 887   TString canvasHistoName="Histos";
 888   ch = new TCanvas(canvasHistoName,canvasHistoName,20,20,600,600);
 889   ch->cd();
 890   */
 891   // to be implemented
 892
 893 }
 894
 895
 896 //---------------------------------------------------------------
 897 void AliTOFLvHvDataPoints::DrawHVandLVMap(Int_t index)
 898 {
 899   //
 900   // Draw HV+LV map labelled as index
 901   //
 902
 903   const Int_t kSize = 100;
 904
 905   if(!fIsProcessed) return;
 906
 907   if (index>=fNumberOfHVandLVmaps) return;
 908
 909   AliTOFDCSmaps *mappa=(AliTOFDCSmaps*)GetHVandLVmap(index);
 910
 911   char title[kSize];
 912   if (index==0) snprintf(title,kSize,"HVandLV map at time %d (%dst map)",mappa->GetTime(),index+1);
 913   else if (index==1) snprintf(title,kSize,"HVandLV map at time %d (%dnd map)",mappa->GetTime(),index+1);
 914   else if (index==2) snprintf(title,kSize,"HVandLV map at time %d (%drd map)",mappa->GetTime(),index+1);
 915   else if (index>=3) snprintf(title,kSize,"HVandLV map at time %d (%dth map)",mappa->GetTime(),index+1);
 916   fHisto->Delete();
 917   fHisto = new TH1C("histo","",kNpads,-0.5,kNpads-0.5);
 918   //fHisto->Clear();
 919   fHisto->SetTitle(title);
 920
 921   for (Int_t ii=0; ii<kNpads; ii++)
 922     fHisto->SetBinContent(ii+1,mappa->GetCellValue(ii));
 923
 924   fHisto->Draw();
 925
 926 }
 927
 928 //---------------------------------------------------------------
 929 void AliTOFLvHvDataPoints::DrawLVMap(Int_t index)
 930 {
 931   //
 932   // Draw LV map labelled as index
 933   //
 934
 935   const Int_t kSize = 100;
 936
 937   if(!fIsProcessed) return;
 938
 939   if (index>=fNumberOfLVdataPoints) return;
 940
 941   AliTOFDCSmaps *mappa=(AliTOFDCSmaps*)GetLVmap(index);
 942
 943   char title[kSize];
 944   if (index==0) snprintf(title,kSize,"LV map at time %d (%dst map)",mappa->GetTime(),index+1);
 945   else if (index==1) snprintf(title,kSize,"LV map at time %d (%dnd map)",mappa->GetTime(),index+1);
 946   else if (index==2) snprintf(title,kSize,"LV map at time %d (%drd map)",mappa->GetTime(),index+1);
 947   else if (index>=3) snprintf(title,kSize,"LV map at time %d (%dth map)",mappa->GetTime(),index+1);
 948   fHisto->Delete();
 949   fHisto = new TH1C("histo","",kNpads,-0.5,kNpads-0.5);
 950   //fHisto->Clear();
 951   fHisto->SetTitle(title);
 952
 953   for (Int_t ii=0; ii<kNpads; ii++)
 954     fHisto->SetBinContent(ii+1,mappa->GetCellValue(ii));
 955
 956   fHisto->Draw();
 957
 958 }
 959
 960 //---------------------------------------------------------------
 961 void AliTOFLvHvDataPoints::DrawHVMap(Int_t index)
 962 {
 963   //
 964   // Draw HV map labelled as index
 965   //
 966
 967   const Int_t kSize = 100;
 968
 969   if(!fIsProcessed) return;
 970
 971   if (index>=fNumberOfHVdataPoints) return;
 972
 973   AliTOFDCSmaps *mappa=(AliTOFDCSmaps*)GetHVmap(index);
 974
 975   char title[kSize];
 976   if (index==0) snprintf(title,kSize,"HV map at time %d (%dst map)",mappa->GetTime(),index+1);
 977   else if (index==1) snprintf(title,kSize,"HV map at time %d (%dnd map)",mappa->GetTime(),index+1);
 978   else if (index==2) snprintf(title,kSize,"HV map at time %d (%drd map)",mappa->GetTime(),index+1);
 979   else if (index>=3) snprintf(title,kSize,"HV map at time %d (%dth map)",mappa->GetTime(),index+1);
 980   fHisto->Delete();
 981   fHisto = new TH1C("histo","",kNpads,-0.5,kNpads-0.5);
 982   //fHisto->Clear();
 983   fHisto->SetTitle(title);
 984
 985   for (Int_t ii=0; ii<kNpads; ii++)
 986     fHisto->SetBinContent(ii+1,mappa->GetCellValue(ii));
 987
 988   fHisto->Draw();
 989
 990 }
 991
 992 //---------------------------------------------------------------
 993 AliTOFDCSmaps *AliTOFLvHvDataPoints::GetHVandLVmapAtEOR()
 994 {
 995   //
 996   // Returns HVandLV status map at EOR.
 997   // If the end-of-run has been caused by TOF self,
 998   // the second-last value of HVandLV status map
 999   // will be taken into account, i.e. the value immediately before
1000   // the change that caused EOR.
1001   // This last condition is true
1002   // if the time interval between the last map value and the EOR
1003   // is less than 60s.
1004   // If the run ended correctly, last map value will be take into account.
1005   // If nothing changed during the run, the SOR map will be take into account.
1006   //
1007
1008   AliTOFDCSmaps * lvANDhvMap = 0;
1009
1010   if (fNumberOfHVandLVmaps==1) { // nothing changed during the run
1011
1012     AliInfo(Form("Nothing changed in the TOF channels LV and HV status during the run number %d",fRun));
1013
1014     lvANDhvMap = fMap[fNumberOfHVandLVmaps-1];
1015
1016   }
1017   else {
1018
1019     if ( (fEndTimeDCSQuery-fMap[fNumberOfHVandLVmaps-1]->GetTime()<=fNSecondsBeforeEOR) ||
1020          (fEndTime-fMap[fNumberOfHVandLVmaps-1]->GetTime()<=fNSecondsBeforeEOR) ) {
1021       lvANDhvMap = (AliTOFDCSmaps*)fMap[fNumberOfHVandLVmaps-2];
1022       AliInfo(Form("Probably, TOF caused the EOR (EOR-t(last map))<%d).For run number %d the second-last HVandLV map will be take into account.",fNSecondsBeforeEOR,fRun));
1023     }
1024     else {
1025       lvANDhvMap = (AliTOFDCSmaps*)fMap[fNumberOfHVandLVmaps-1];
1026       AliInfo(Form("The run number %d ended correctly. The last HVandLV map will be take into account.",fRun));
1027     }
1028
1029   }
1030
1031   return lvANDhvMap;
1032
1033 }