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