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