MUON/AliMUONPadStatusMaker.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 // $Id$
  17
  18 //-----------------------------------------------------------------------------
  19 /// \class AliMUONPadStatusMaker
  20 ///
  21 /// Make a 2DStore of pad statuses, using different sources of information,
  22 /// like pedestal values, gain values, and HV values.
  23 ///
  24 /// \author Laurent Aphecetche
  25 //-----------------------------------------------------------------------------
  26
  27 #include "AliMUONPadStatusMaker.h"
  28
  29 #include "AliMUON2DMap.h"
  30 #include "AliMUON2DStoreValidator.h"
  31 #include "AliMUONCalibParamNI.h"
  32 #include "AliMUONCalibrationData.h"
  33 #include "AliMUONLogger.h"
  34 #include "AliMUONRecoParam.h"
  35 #include "AliMUONStringIntMap.h"
  36 #include "AliMUONTrackerData.h"
  37 #include "AliMUONVCalibParam.h"
  38
  39 #include "AliMpArea.h"
  40 #include "AliMpArrayI.h"
  41 #include "AliMpCDB.h"
  42 #include "AliMpConstants.h"
  43 #include "AliMpDDLStore.h"
  44 #include "AliMpDEManager.h"
  45 #include "AliMpDetElement.h"
  46 #include "AliMpDCSNamer.h"
  47 #include "AliMpManuIterator.h"
  48 #include "AliMpManuUID.h"
  49
  50 #include "AliCDBEntry.h"
  51 #include "AliCDBManager.h"
  52 #include "AliCodeTimer.h"
  53 #include "AliDCSValue.h"
  54 #include "AliLog.h"
  55
  56 #include <Riostream.h>
  57 #include <TArrayI.h>
  58 #include <TExMap.h>
  59 #include <TFile.h>
  60 #include <TKey.h>
  61 #include <TMap.h>
  62 #include <TROOT.h>
  63 #include <TString.h>
  64 #include <TSystem.h>
  65
  66 /// \cond CLASSIMP
  67 ClassImp(AliMUONPadStatusMaker)
  68 /// \endcond
  69
  70 //_____________________________________________________________________________
  71 AliMUONPadStatusMaker::AliMUONPadStatusMaker(const AliMUONCalibrationData& calibData)
  72 : fkCalibrationData(calibData),
  73 fGainA1Limits(0,1E30),
  74 fGainA2Limits(-1E-30,1E30),
  75 fGainThresLimits(0,4095),
  76 fPedMeanLimits(0,4095),
  77 fPedSigmaLimits(0,4095),
  78 fManuOccupancyLimits(0,1.0),
  79 fBuspatchOccupancyLimits(0,1.0),
  80 fDEOccupancyLimits(0,1.0),
  81 fStatus(new AliMUON2DMap(true)),
  82 fHV(0x0),
  83 fPedestals(calibData.Pedestals()),
  84 fGains(calibData.Gains()),
  85 fTrackerData(0x0)
  86 {
  87   /// ctor
  88   if ( calibData.OccupancyMap() )
  89   {
  90     /// create a tracker data from the occupancy map
  91     fTrackerData = new AliMUONTrackerData("OCC","OCC",*(calibData.OccupancyMap()));
  92   }
  93   if ( calibData.HV() )
  94   {
  95     /// Only create the fHV internal store if there are some HV values available
  96     fHV = new TExMap;
  97   }
  98
  99   SetHVLimit(-1,0.0);
 100 }
 101
 102 //_____________________________________________________________________________
 103 AliMUONPadStatusMaker::~AliMUONPadStatusMaker()
 104 {
 105   /// dtor.
 106
 107   delete fStatus;
 108   delete fHV;
 109   delete fTrackerData;
 110 }
 111
 112 //_____________________________________________________________________________
 113 TString
 114 AliMUONPadStatusMaker::AsString(Int_t status)
 115 {
 116   /// return a human readable version of the integer status
 117
 118   if ( status == 0 )
 119   {
 120     return "Brave New World";
 121   }
 122
 123   Int_t pedStatus;
 124   Int_t gainStatus;
 125   Int_t hvStatus;
 126   Int_t occStatus;
 127
 128   DecodeStatus(status,pedStatus,hvStatus,gainStatus,occStatus);
 129
 130   TString s;
 131
 132   if ( pedStatus & kPedMeanZero ) s += "& Ped Mean is Zero ";
 133   if ( pedStatus & kPedMeanTooLow ) s += "& Ped Mean Too Low ";
 134   if ( pedStatus & kPedMeanTooHigh ) s += "& Ped Mean Too High ";
 135   if ( pedStatus & kPedSigmaTooLow ) s += "& Ped Sigma Too Low ";
 136   if ( pedStatus & kPedSigmaTooHigh ) s += "& Ped Sigma Too High ";
 137   if ( pedStatus & kPedMissing ) s += "& Ped is missing ";
 138
 139         if ( gainStatus & kGainA1TooLow ) s+="& Gain A1 is Too Low ";
 140         if ( gainStatus & kGainA1TooHigh ) s+="& Gain A1 is Too High ";
 141         if ( gainStatus & kGainA2TooLow ) s+="& Gain A2 is Too Low ";
 142         if ( gainStatus & kGainA2TooHigh ) s+="& Gain A2 is Too High ";
 143         if ( gainStatus & kGainThresTooLow ) s+="& Gain Thres is Too Low ";
 144         if ( gainStatus & kGainThresTooHigh ) s+="& Gain Thres is Too High ";
 145         if ( gainStatus & kGainMissing ) s+="& Gain is missing ";
 146
 147         if ( hvStatus & kHVError ) s+="& HV is on error ";
 148         if ( hvStatus & kHVTooLow ) s+="& HV is Too Low ";
 149         if ( hvStatus & kHVTooHigh ) s+="& HV is Too High ";
 150         if ( hvStatus & kHVChannelOFF ) s+="& HV has channel OFF ";
 151         if ( hvStatus & kHVSwitchOFF ) s+="& HV has switch OFF ";
 152         if ( hvStatus & kHVMissing ) s+="& HV is missing ";
 153
 154   if ( occStatus & kManuOccupancyTooHigh ) s+="& manu occupancy too high ";
 155   if ( occStatus & kManuOccupancyTooLow ) s+="& manu occupancy too low ";
 156   if ( occStatus & kBusPatchOccupancyTooHigh ) s+="& bus patch occupancy too high ";
 157   if ( occStatus & kBusPatchOccupancyTooLow ) s+="& bus patch occupancy too low ";
 158   if ( occStatus & kDEOccupancyTooHigh ) s+="& DE occupancy too high ";
 159   if ( occStatus & kDEOccupancyTooLow ) s+="& DE occupancy too low ";
 160
 161   if ( s[0] == '&' ) s[0] = ' ';
 162
 163   return s;
 164 }
 165
 166 //_____________________________________________________________________________
 167 TString
 168 AliMUONPadStatusMaker::AsCondition(Int_t mask)
 169 {
 170   /// return a human readable version of the mask's equivalent condition
 171
 172   TString s(AsString(mask));
 173
 174   s.ReplaceAll("&","|");
 175
 176   return s;
 177 }
 178
 179 //_____________________________________________________________________________
 180 Int_t
 181 AliMUONPadStatusMaker::BuildStatus(Int_t pedStatus,
 182                                    Int_t hvStatus,
 183                                    Int_t gainStatus,
 184                                    Int_t occStatus)
 185 {
 186   /// Build a complete status from specific parts (ped,hv,gain)
 187
 188   return ( hvStatus & 0xFF ) | ( ( pedStatus & 0xFF ) << 8 ) |
 189   ( ( gainStatus & 0xFF ) << 16 ) |
 190   ( ( occStatus & 0xFF ) << 24 ) ;
 191 }
 192
 193 //_____________________________________________________________________________
 194 void
 195 AliMUONPadStatusMaker::DecodeStatus(Int_t status,
 196                                     Int_t& pedStatus,
 197                                     Int_t& hvStatus,
 198                                     Int_t& gainStatus,
 199                                     Int_t& occStatus)
 200 {
 201   /// Decode complete status into specific parts (ped,hv,gain)
 202
 203   occStatus = ( status & 0xFF000000 ) >> 24;
 204   gainStatus = ( status & 0xFF0000 ) >> 16;
 205   pedStatus = ( status & 0xFF00 ) >> 8;
 206   hvStatus = (status & 0xFF);
 207 }
 208
 209 //_____________________________________________________________________________
 210 Bool_t
 211 AliMUONPadStatusMaker::HVSt12Status(Int_t detElemId, Int_t sector,
 212                                     Bool_t& hvChannelTooLow,
 213                                     Bool_t& hvChannelTooHigh,
 214                                     Bool_t& hvChannelON) const
 215 {
 216   /// Get HV status for one HV sector of St12
 217
 218   /// For a given PCB in a given DE, get the HV status (both the channel
 219   /// and the switch).
 220   /// Returns false if hv switch changed during the run.
 221
 222   AliCodeTimerAuto("",0)
 223
 224   if (!fHV) return kFALSE;
 225
 226   Bool_t error = kFALSE;
 227   hvChannelTooLow = kFALSE;
 228   hvChannelTooHigh = kFALSE;
 229   hvChannelON = kTRUE;
 230
 231   Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
 232
 233   AliMpDCSNamer hvNamer("TRACKER");
 234
 235   TString hvChannel(hvNamer.DCSChannelName(detElemId,sector));
 236
 237   TMap* hvMap = fkCalibrationData.HV();
 238   TPair* hvPair = static_cast<TPair*>(hvMap->FindObject(hvChannel.Data()));
 239   if (!hvPair)
 240   {
 241     AliError(Form("Did not find expected alias (%s) for DE %d",
 242                   hvChannel.Data(),detElemId));
 243     error = kTRUE;
 244   }
 245   else
 246   {
 247     TObjArray* values = static_cast<TObjArray*>(hvPair->Value());
 248     if (!values)
 249     {
 250       AliError(Form("Could not get values for alias %s",hvChannel.Data()));
 251       error = kTRUE;
 252     }
 253     else
 254     {
 255       // find out min value, and makes a cut
 256       Float_t hvMin(1E9);
 257       TIter next(values);
 258       AliDCSValue* val;
 259
 260       while ( ( val = static_cast<AliDCSValue*>(next()) ) )
 261       {
 262         Float_t hv = val->GetFloat();
 263         hvMin = TMath::Min(hv,hvMin);
 264       }
 265
 266       float lowThreshold = HVLimit(chamberId);
 267
 268       if ( hvMin < lowThreshold ) hvChannelTooLow = kTRUE;
 269       if ( hvMin < hvNamer.TrackerHVOFF() ) hvChannelON = kFALSE;
 270     }
 271   }
 272
 273   return error;
 274 }
 275
 276 //_____________________________________________________________________________
 277 Float_t
 278 AliMUONPadStatusMaker::SwitchValue(const TObjArray& dcsArray)
 279 {
 280   /// Loop over the dcs value for a single switch to decide whether
 281   /// we should consider it on or off
 282
 283   // we'll count the number of ON/OFF for this pad, to insure
 284   // consistency (i.e. if status changed during the run, we should
 285   // at least notify this fact ;-) and hope it's not the norm)
 286   Int_t nTrue(0);
 287   Int_t nFalse(0);
 288   TIter next(&dcsArray);
 289   AliDCSValue* val;
 290
 291   while ( ( val = static_cast<AliDCSValue*>(next()) ) )
 292   {
 293     if ( val->GetBool() )
 294     {
 295       ++nTrue;
 296     }
 297     else
 298     {
 299       ++nFalse;
 300     }
 301   }
 302
 303   if ( (nTrue>0 && nFalse>0) )
 304   {
 305     // change of state during the run, consider it off
 306     return 0.0;
 307   }
 308
 309   if ( nFalse )
 310   {
 311     /// switch = FALSE means the HV was flowding up to the PCB.
 312     /// i.e. switch = FALSE = ON
 313     return 1.0;
 314   }
 315
 316   return 0.0;
 317 }
 318
 319 //_____________________________________________________________________________
 320 Bool_t
 321 AliMUONPadStatusMaker::HVSt345Status(Int_t detElemId, Int_t pcbIndex,
 322                                      Bool_t& hvChannelTooLow,
 323                                      Bool_t& hvChannelTooHigh,
 324                                      Bool_t& hvChannelON,
 325                                      Bool_t& hvSwitchON) const
 326 {
 327   /// For a given PCB in a given DE, get the HV status (both the channel
 328   /// and the switch).
 329   /// Returns false if something goes wrong (in particular if
 330   /// hv switch changed during the run).
 331
 332   AliCodeTimerAuto("",0)
 333
 334   if (!fHV) return kFALSE;
 335
 336   Bool_t error = kFALSE;
 337   hvChannelTooLow = kFALSE;
 338   hvChannelTooHigh = kFALSE;
 339   hvSwitchON = kTRUE;
 340   hvChannelON = kTRUE;
 341
 342   AliMpDCSNamer hvNamer("TRACKER");
 343
 344   Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
 345
 346   TString hvChannel(hvNamer.DCSChannelName(detElemId));
 347
 348   TMap* hvMap = fkCalibrationData.HV();
 349
 350   TPair* hvPair = static_cast<TPair*>(hvMap->FindObject(hvChannel.Data()));
 351   if (!hvPair)
 352   {
 353     AliError(Form("Did not find expected alias (%s) for DE %d",
 354                   hvChannel.Data(),detElemId));
 355     error = kTRUE;
 356   }
 357   else
 358   {
 359     TObjArray* values = static_cast<TObjArray*>(hvPair->Value());
 360     if (!values)
 361     {
 362       AliError(Form("Could not get values for alias %s",hvChannel.Data()));
 363       error = kTRUE;
 364     }
 365     else
 366     {
 367       // find out min value, and makes a cut
 368       Float_t hvMin(1E9);
 369       TIter next(values);
 370       AliDCSValue* val;
 371
 372       while ( ( val = static_cast<AliDCSValue*>(next()) ) )
 373       {
 374         Float_t hv = val->GetFloat();
 375         hvMin = TMath::Min(hv,hvMin);
 376       }
 377
 378       float lowThreshold = HVLimit(chamberId);
 379
 380       if ( hvMin < lowThreshold ) hvChannelTooLow = kTRUE;
 381       if ( hvMin < hvNamer.TrackerHVOFF() ) hvChannelON = kFALSE;
 382     }
 383   }
 384
 385   TString hvSwitch(hvNamer.DCSSwitchName(detElemId,pcbIndex));
 386   TPair* switchPair = static_cast<TPair*>(hvMap->FindObject(hvSwitch.Data()));
 387   if (!switchPair)
 388   {
 389     AliError(Form("Did not find expected alias (%s) for DE %d PCB %d",
 390                   hvSwitch.Data(),detElemId,pcbIndex));
 391     error = kTRUE;
 392   }
 393   else
 394   {
 395     TObjArray* values = static_cast<TObjArray*>(switchPair->Value());
 396     if (!values)
 397     {
 398       AliError(Form("Could not get values for alias %s",hvSwitch.Data()));
 399       error = kTRUE;
 400     }
 401     else
 402     {
 403       Float_t sv = SwitchValue(*values);
 404       if ( sv < 0.99 ) hvSwitchON = kFALSE;
 405     }
 406   }
 407   return error;
 408 }
 409
 410 //_____________________________________________________________________________
 411 Int_t
 412 AliMUONPadStatusMaker::HVStatus(Int_t detElemId, Int_t manuId) const
 413 {
 414   /// Get HV status of one manu
 415
 416   AliCodeTimerAuto("",0)
 417
 418   if ( !fHV ) return kMissing;
 419
 420   Long_t lint = fHV->GetValue(AliMpManuUID::BuildUniqueID(detElemId,manuId));
 421
 422   if ( lint )
 423   {
 424     return (Int_t)(lint - 1);
 425   }
 426
 427   Int_t status(0);
 428
 429   AliMpDCSNamer hvNamer("TRACKER");
 430
 431   switch ( AliMpDEManager::GetStationType(detElemId) )
 432   {
 433     case AliMp::kStation12:
 434     {
 435       int sector = hvNamer.ManuId2Sector(detElemId,manuId);
 436       if ( sector >= 0 )
 437       {
 438         Bool_t hvChannelTooLow, hvChannelTooHigh, hvChannelON;
 439         Bool_t error = HVSt12Status(detElemId,sector,
 440                                     hvChannelTooLow,
 441                                     hvChannelTooHigh,
 442                                     hvChannelON);
 443         if ( error ) status |= kHVError;
 444         if ( hvChannelTooLow ) status |= kHVTooLow;
 445         if ( hvChannelTooHigh ) status |= kHVTooHigh;
 446         if ( !hvChannelON ) status |= kHVChannelOFF;
 447         // assign this status to all the other manus handled by the same HV channel
 448         SetHVStatus(detElemId,sector,status);
 449       }
 450     }
 451       break;
 452     case AliMp::kStation345:
 453     {
 454       int pcbIndex = hvNamer.ManuId2PCBIndex(detElemId,manuId);
 455       if ( pcbIndex >= 0 )
 456       {
 457         Bool_t hvChannelTooLow, hvChannelTooHigh, hvChannelON,hvSwitchON;
 458         Bool_t error = HVSt345Status(detElemId,pcbIndex,
 459                                      hvChannelTooLow,hvChannelTooHigh,
 460                                      hvChannelON,hvSwitchON);
 461         if ( error ) status |= kHVError;
 462         if ( hvChannelTooLow ) status |= kHVTooLow;
 463         if ( hvChannelTooHigh ) status |= kHVTooHigh;
 464         if ( !hvSwitchON ) status |= kHVSwitchOFF;
 465         if ( !hvChannelON) status |= kHVChannelOFF;
 466         // assign this status to all the other manus handled by the same HV channel
 467         SetHVStatus(detElemId,pcbIndex,status);
 468       }
 469     }
 470       break;
 471     default:
 472       break;
 473   }
 474
 475   return status;
 476 }
 477
 478 //_____________________________________________________________________________
 479 AliMUONVCalibParam*
 480 AliMUONPadStatusMaker::Neighbours(Int_t detElemId, Int_t manuId) const
 481 {
 482   /// Get the neighbours parameters for a given manu
 483   AliMUONVStore* neighbourStore = fkCalibrationData.Neighbours();
 484   return static_cast<AliMUONVCalibParam*>(neighbourStore->FindObject(detElemId,manuId));
 485 }
 486
 487 //_____________________________________________________________________________
 488 AliMUONVStore*
 489 AliMUONPadStatusMaker::NeighboursStore() const
 490 {
 491   /// Return the store containing all the neighbours
 492   return fkCalibrationData.Neighbours();
 493 }
 494
 495 //_____________________________________________________________________________
 496 AliMUONVCalibParam*
 497 AliMUONPadStatusMaker::ComputeStatus(Int_t detElemId, Int_t manuId) const
 498 {
 499   /// Compute the status of a given manu, using all available information,
 500   /// i.e. pedestals, gains, and HV
 501
 502   AliMUONVCalibParam* param = new AliMUONCalibParamNI(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,-1);
 503   fStatus->Add(param);
 504
 505   AliMUONVCalibParam* pedestals = static_cast<AliMUONVCalibParam*>(fPedestals->FindObject(detElemId,manuId));
 506
 507   AliMUONVCalibParam* gains = static_cast<AliMUONVCalibParam*>(fGains->FindObject(detElemId,manuId));
 508
 509   Int_t hvStatus = HVStatus(detElemId,manuId);
 510
 511   Int_t occStatus = OccupancyStatus(detElemId,manuId);
 512
 513   for ( Int_t manuChannel = 0; manuChannel < param->Size(); ++manuChannel )
 514   {
 515     Int_t pedStatus(0);
 516
 517     if (pedestals)
 518     {
 519       Float_t pedMean = pedestals->ValueAsFloatFast(manuChannel,0);
 520       Float_t pedSigma = pedestals->ValueAsFloatFast(manuChannel,1);
 521       if ( pedMean < fPedMeanLimits.X() ) pedStatus |= kPedMeanTooLow;
 522       else if ( pedMean > fPedMeanLimits.Y() ) pedStatus |= kPedMeanTooHigh;
 523       if ( pedSigma < fPedSigmaLimits.X() ) pedStatus |= kPedSigmaTooLow;
 524       else if ( pedSigma > fPedSigmaLimits.Y() ) pedStatus |= kPedSigmaTooHigh;
 525       if ( pedMean == 0 ) pedStatus |= kPedMeanZero;
 526     }
 527     else
 528     {
 529       pedStatus = kPedMissing;
 530     }
 531
 532     Int_t gainStatus(0);
 533
 534     if ( gains )
 535     {
 536       Float_t a0 = gains->ValueAsFloatFast(manuChannel,0);
 537       Float_t a1 = gains->ValueAsFloatFast(manuChannel,1);
 538       Float_t thres = gains->ValueAsFloatFast(manuChannel,2);
 539
 540       if ( a0 < fGainA1Limits.X() ) gainStatus |= kGainA1TooLow;
 541       else if ( a0 > fGainA1Limits.Y() ) gainStatus |= kGainA1TooHigh;
 542       if ( a1 < fGainA2Limits.X() ) gainStatus |= kGainA2TooLow;
 543       else if ( a1 > fGainA2Limits.Y() ) gainStatus |= kGainA2TooHigh;
 544       if ( thres < fGainThresLimits.X() ) gainStatus |= kGainThresTooLow;
 545       else if ( thres > fGainThresLimits.Y() ) gainStatus |= kGainThresTooHigh;
 546     }
 547     else
 548     {
 549       gainStatus = kGainMissing;
 550     }
 551
 552     Int_t status = BuildStatus(pedStatus,hvStatus,gainStatus,occStatus);
 553
 554     param->SetValueAsIntFast(manuChannel,0,status);
 555   }
 556
 557   return param;
 558 }
 559
 560 //_____________________________________________________________________________
 561 Int_t
 562 AliMUONPadStatusMaker::OccupancyStatus(Int_t detElemId, Int_t manuId) const
 563 {
 564   /// Get the "other" status for a given manu
 565
 566   Int_t rv(0);
 567
 568   if ( fTrackerData )
 569   {
 570     const Int_t occIndex = 2;
 571
 572     Double_t occ = fTrackerData->DetectionElement(detElemId,occIndex);
 573
 574     if ( occ <= fDEOccupancyLimits.X() )
 575     {
 576       rv |= kDEOccupancyTooLow;
 577     }
 578     else if ( occ > fDEOccupancyLimits.Y() )
 579     {
 580       rv |= kDEOccupancyTooHigh;
 581     }
 582
 583     Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
 584
 585     occ = fTrackerData->BusPatch(busPatchId,occIndex);
 586
 587     if ( occ <= fBuspatchOccupancyLimits.X() )
 588     {
 589       rv |= kBusPatchOccupancyTooLow;
 590     }
 591     else if ( occ > fBuspatchOccupancyLimits.Y() )
 592     {
 593       rv |= kBusPatchOccupancyTooHigh;
 594     }
 595
 596     occ = fTrackerData->Manu(detElemId,manuId,occIndex);
 597
 598     if ( occ <= fManuOccupancyLimits.X() )
 599     {
 600       rv |= kManuOccupancyTooLow;
 601     }
 602     else if ( occ > fManuOccupancyLimits.Y() )
 603     {
 604       rv |= kManuOccupancyTooHigh;
 605     }
 606   }
 607   return rv;
 608 }
 609
 610 //_____________________________________________________________________________
 611 AliMUONVCalibParam*
 612 AliMUONPadStatusMaker::PadStatus(Int_t detElemId, Int_t manuId) const
 613 {
 614   /// Get the status container for a given manu
 615
 616   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fStatus->FindObject(detElemId,manuId));
 617   if (!param)
 618   {
 619     // not already there, so compute it now
 620     AliCodeTimerAuto("ComputeStatus",0);
 621     param = ComputeStatus(detElemId,manuId);
 622   }
 623   return param;
 624 }
 625
 626 //_____________________________________________________________________________
 627 Int_t
 628 AliMUONPadStatusMaker::PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
 629 {
 630   /// Get the status for a given channel
 631
 632   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fStatus->FindObject(detElemId,manuId));
 633   if (!param)
 634   {
 635     // not already there, so compute it now
 636     param = ComputeStatus(detElemId,manuId);
 637   }
 638   return param->ValueAsInt(manuChannel,0);
 639 }
 640
 641 //_____________________________________________________________________________
 642 void
 643 AliMUONPadStatusMaker::SetHVStatus(Int_t detElemId, Int_t index, Int_t status) const
 644 {
 645   /// Assign status to all manus in a given HV "zone" (defined by index, meaning
 646   /// is different thing from St12 and St345)
 647
 648   AliCodeTimerAuto("",0)
 649
 650   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 651
 652   const AliMpArrayI* manus = de->ManusForHV(index);
 653
 654   for ( Int_t i = 0; i < manus->GetSize(); ++ i )
 655   {
 656     Int_t manuId = manus->GetValue(i);
 657     fHV->Add(AliMpManuUID::BuildUniqueID(detElemId,manuId),status + 1);
 658   }
 659 }
 660
 661 //_____________________________________________________________________________
 662 Double_t
 663 AliMUONPadStatusMaker::HVLimit(Int_t chamberId) const
 664 {
 665   /// Get HV limit for a given chamber
 666   if ( chamberId >=0 && chamberId < 10 )
 667   {
 668     return fHVLimit[chamberId];
 669   }
 670   return 0.0;
 671 }
 672
 673 //_____________________________________________________________________________
 674 void
 675 AliMUONPadStatusMaker::SetHVLimit(Int_t chamberId, Double_t hv)
 676 {
 677   /// Set hv limit for a given chamber (or all if chamberId==-1)
 678
 679   if ( chamberId == -1 )
 680   {
 681     for ( Int_t i = 0; i < 10; ++i )
 682     {
 683       fHVLimit[i] = hv;
 684     }
 685   }
 686   else if ( chamberId >= 0 && chamberId < 10 )
 687   {
 688     fHVLimit[chamberId]=hv;
 689   }
 690   else
 691   {
 692     AliError(Form("chamberId=%d is invalid",chamberId));
 693   }
 694 }
 695
 696 //_____________________________________________________________________________
 697 void
 698 AliMUONPadStatusMaker::SetLimits(const AliMUONRecoParam& recoParams)
 699 {
 700   /// Set the limits from the recoparam
 701
 702   for ( int i = 0; i < 10; ++i )
 703   {
 704     SetHVLimit(i,recoParams.HVLimit(i));
 705   }
 706
 707   SetPedMeanLimits(recoParams.PedMeanLowLimit(),recoParams.PedMeanHighLimit());
 708   SetPedSigmaLimits(recoParams.PedSigmaLowLimit(),recoParams.PedSigmaHighLimit());
 709
 710   SetGainA1Limits(recoParams.GainA1LowLimit(),recoParams.GainA1HighLimit());
 711   SetGainA2Limits(recoParams.GainA2LowLimit(),recoParams.GainA2HighLimit());
 712   SetGainThresLimits(recoParams.GainThresLowLimit(),recoParams.GainThresHighLimit());
 713
 714   SetManuOccupancyLimits(recoParams.ManuOccupancyLowLimit(),recoParams.ManuOccupancyHighLimit());
 715   SetBuspatchOccupancyLimits(recoParams.BuspatchOccupancyLowLimit(),recoParams.BuspatchOccupancyHighLimit());
 716   SetDEOccupancyLimits(recoParams.DEOccupancyLowLimit(),recoParams.DEOccupancyHighLimit());
 717 }
 718
 719 //_____________________________________________________________________________
 720 void
 721 AliMUONPadStatusMaker::Report(UInt_t mask)
 722 {
 723   /// Report the number of bad pads, according to the mask,
 724   /// and the various reasons why they are bad (with occurence rates)
 725
 726   AliInfo("");
 727   AliCodeTimerAuto("",0);
 728
 729   AliMUONLogger log(1064008);
 730
 731   Int_t nBadPads(0);
 732   Int_t nPads(0);
 733
 734   AliMpManuIterator it;
 735
 736   Int_t detElemId, manuId;
 737
 738   while ( it.Next(detElemId,manuId) )
 739   {
 740     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 741
 742     for ( Int_t i = 0; i < AliMpConstants::ManuNofChannels(); ++i )
 743     {
 744       if ( de->IsConnectedChannel(manuId,i) )
 745       {
 746         ++nPads;
 747
 748         Int_t status = PadStatus(detElemId,manuId,i);
 749
 750         if ( mask && ( status & mask) ) // note that if mask == 0, all pads are good...
 751         {
 752           ++nBadPads;
 753           log.Log(AsString(status));
 754         }
 755       }
 756     }
 757   }
 758
 759   TString msg;
 760   Int_t ntimes;
 761
 762   cout << Form("According to mask %x (human readable form below) %6d pads are bad (over a total of %6d, i.e. %7.2f %%)",
 763                mask,nBadPads,nPads,nPads ? nBadPads*100.0/nPads : 0.0) << endl;
 764   cout << AliMUONPadStatusMaker::AsCondition(mask) << endl;
 765   cout << "--------" << endl;
 766
 767   while ( log.Next(msg,ntimes) )
 768   {
 769     cout << Form("The message (%120s) occured %15d times (%7.4f %%)",msg.Data(),ntimes,ntimes*100.0/nPads) << endl;
 770   }
 771
 772 }
 773