next50 trigger mask in AliHLTGlobalEsdConverterComponent
[u/mrichter/AliRoot.git] / MUON / AliMUONPadStatusMaker.cxx
CommitLineData
2c780493 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$
78649106 17
3d1463c8 18//-----------------------------------------------------------------------------
2c780493 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///
78649106 24/// \author Laurent Aphecetche
3d1463c8 25//-----------------------------------------------------------------------------
2c780493 26
27#include "AliMUONPadStatusMaker.h"
28
29#include "AliMUON2DMap.h"
9044498f 30#include "AliMUON2DStoreValidator.h"
31#include "AliMUONCalibParamNI.h"
2c780493 32#include "AliMUONCalibrationData.h"
411a502a 33#include "AliMUONLogger.h"
34#include "AliMUONRecoParam.h"
49e396d9 35#include "AliMUONStringIntMap.h"
7eafe398 36#include "AliMUONTrackerData.h"
411a502a 37#include "AliMUONVCalibParam.h"
2ce1c72b 38
2c780493 39#include "AliMpArea.h"
49e396d9 40#include "AliMpArrayI.h"
411a502a 41#include "AliMpCDB.h"
8d8e920c 42#include "AliMpConstants.h"
49e396d9 43#include "AliMpDDLStore.h"
2c780493 44#include "AliMpDEManager.h"
49e396d9 45#include "AliMpDetElement.h"
49e110ec 46#include "AliMpDCSNamer.h"
411a502a 47#include "AliMpManuIterator.h"
49e396d9 48#include "AliMpManuUID.h"
2ce1c72b 49
50#include "AliCDBEntry.h"
51#include "AliCDBManager.h"
52#include "AliCodeTimer.h"
53#include "AliDCSValue.h"
54#include "AliLog.h"
55
9044498f 56#include <Riostream.h>
49e396d9 57#include <TArrayI.h>
58#include <TExMap.h>
004a9ccd 59#include <TFile.h>
60#include <TKey.h>
9044498f 61#include <TMap.h>
004a9ccd 62#include <TROOT.h>
9044498f 63#include <TString.h>
004a9ccd 64#include <TSystem.h>
2c780493 65
b80faac0 66using std::cout;
67using std::endl;
78649106 68/// \cond CLASSIMP
2c780493 69ClassImp(AliMUONPadStatusMaker)
78649106 70/// \endcond
2c780493 71
72//_____________________________________________________________________________
73AliMUONPadStatusMaker::AliMUONPadStatusMaker(const AliMUONCalibrationData& calibData)
72dae9ff 74: fkCalibrationData(calibData),
004a9ccd 75fGainA1Limits(0,1E30),
76fGainA2Limits(-1E-30,1E30),
77fGainThresLimits(0,4095),
004a9ccd 78fPedMeanLimits(0,4095),
79fPedSigmaLimits(0,4095),
7eafe398 80fManuOccupancyLimits(0,1.0),
411a502a 81fBuspatchOccupancyLimits(0,1.0),
7eafe398 82fDEOccupancyLimits(0,1.0),
004a9ccd 83fStatus(new AliMUON2DMap(true)),
00977a64 84fHV(0x0),
004a9ccd 85fPedestals(calibData.Pedestals()),
86fGains(calibData.Gains()),
7eafe398 87fTrackerData(0x0)
2c780493 88{
004a9ccd 89 /// ctor
7eafe398 90 if ( calibData.OccupancyMap() )
004a9ccd 91 {
7eafe398 92 /// create a tracker data from the occupancy map
93 fTrackerData = new AliMUONTrackerData("OCC","OCC",*(calibData.OccupancyMap()));
411a502a 94 }
00977a64 95 if ( calibData.HV() )
96 {
97 /// Only create the fHV internal store if there are some HV values available
98 fHV = new TExMap;
99 }
32f1b761 100
101 SetHVLimit(-1,0.0);
2c780493 102}
103
104//_____________________________________________________________________________
105AliMUONPadStatusMaker::~AliMUONPadStatusMaker()
106{
71a2d3aa 107 /// dtor.
411a502a 108
49e396d9 109 delete fStatus;
110 delete fHV;
7eafe398 111 delete fTrackerData;
2c780493 112}
113
114//_____________________________________________________________________________
49e396d9 115TString
116AliMUONPadStatusMaker::AsString(Int_t status)
2c780493 117{
49e396d9 118 /// return a human readable version of the integer status
004a9ccd 119
659e1281 120 if ( status == 0 )
121 {
122 return "Brave New World";
123 }
124
49e396d9 125 Int_t pedStatus;
126 Int_t gainStatus;
127 Int_t hvStatus;
7eafe398 128 Int_t occStatus;
004a9ccd 129
7eafe398 130 DecodeStatus(status,pedStatus,hvStatus,gainStatus,occStatus);
004a9ccd 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
7eafe398 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 ";
49e396d9 162
004a9ccd 163 if ( s[0] == '&' ) s[0] = ' ';
164
165 return s;
166}
49e396d9 167
004a9ccd 168//_____________________________________________________________________________
169TString
170AliMUONPadStatusMaker::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
49e396d9 178 return s;
2c780493 179}
180
181//_____________________________________________________________________________
49e396d9 182Int_t
183AliMUONPadStatusMaker::BuildStatus(Int_t pedStatus,
184 Int_t hvStatus,
004a9ccd 185 Int_t gainStatus,
7eafe398 186 Int_t occStatus)
96199305 187{
49e396d9 188 /// Build a complete status from specific parts (ped,hv,gain)
8d8e920c 189
49e396d9 190 return ( hvStatus & 0xFF ) | ( ( pedStatus & 0xFF ) << 8 ) |
004a9ccd 191 ( ( gainStatus & 0xFF ) << 16 ) |
7eafe398 192 ( ( occStatus & 0xFF ) << 24 ) ;
49e396d9 193}
194
195//_____________________________________________________________________________
196void
197AliMUONPadStatusMaker::DecodeStatus(Int_t status,
198 Int_t& pedStatus,
199 Int_t& hvStatus,
004a9ccd 200 Int_t& gainStatus,
7eafe398 201 Int_t& occStatus)
49e396d9 202{
203 /// Decode complete status into specific parts (ped,hv,gain)
96199305 204
7eafe398 205 occStatus = ( status & 0xFF000000 ) >> 24;
49e396d9 206 gainStatus = ( status & 0xFF0000 ) >> 16;
207 pedStatus = ( status & 0xFF00 ) >> 8;
208 hvStatus = (status & 0xFF);
96199305 209}
210
211//_____________________________________________________________________________
2c780493 212Bool_t
49e396d9 213AliMUONPadStatusMaker::HVSt12Status(Int_t detElemId, Int_t sector,
214 Bool_t& hvChannelTooLow,
215 Bool_t& hvChannelTooHigh,
216 Bool_t& hvChannelON) const
2c780493 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
99c136e1 224 AliCodeTimerAuto("",0)
49e396d9 225
00977a64 226 if (!fHV) return kFALSE;
227
2c780493 228 Bool_t error = kFALSE;
229 hvChannelTooLow = kFALSE;
230 hvChannelTooHigh = kFALSE;
231 hvChannelON = kTRUE;
49e396d9 232
32f1b761 233 Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
234
49e110ec 235 AliMpDCSNamer hvNamer("TRACKER");
2c780493 236
1d5cf0f2 237 TString hvChannel(hvNamer.DCSAliasName(detElemId,sector));
2c780493 238
72dae9ff 239 TMap* hvMap = fkCalibrationData.HV();
49e396d9 240 TPair* hvPair = static_cast<TPair*>(hvMap->FindObject(hvChannel.Data()));
2c780493 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 {
32f1b761 257 // find out min value, and makes a cut
2c780493 258 Float_t hvMin(1E9);
2c780493 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);
2c780493 266 }
267
527707f3 268 float lowThreshold = HVLimit(chamberId);
2c780493 269
270 if ( hvMin < lowThreshold ) hvChannelTooLow = kTRUE;
32f1b761 271 if ( hvMin < hvNamer.TrackerHVOFF() ) hvChannelON = kFALSE;
2c780493 272 }
273 }
274
275 return error;
276}
277
278//_____________________________________________________________________________
ca913045 279Float_t
280AliMUONPadStatusMaker::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//_____________________________________________________________________________
2c780493 322Bool_t
49e396d9 323AliMUONPadStatusMaker::HVSt345Status(Int_t detElemId, Int_t pcbIndex,
324 Bool_t& hvChannelTooLow,
325 Bool_t& hvChannelTooHigh,
326 Bool_t& hvChannelON,
327 Bool_t& hvSwitchON) const
2c780493 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
99c136e1 334 AliCodeTimerAuto("",0)
49e396d9 335
00977a64 336 if (!fHV) return kFALSE;
337
2c780493 338 Bool_t error = kFALSE;
339 hvChannelTooLow = kFALSE;
340 hvChannelTooHigh = kFALSE;
341 hvSwitchON = kTRUE;
342 hvChannelON = kTRUE;
343
49e110ec 344 AliMpDCSNamer hvNamer("TRACKER");
2c780493 345
32f1b761 346 Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
347
1d5cf0f2 348 TString hvChannel(hvNamer.DCSAliasName(detElemId));
2c780493 349
72dae9ff 350 TMap* hvMap = fkCalibrationData.HV();
49e396d9 351
352 TPair* hvPair = static_cast<TPair*>(hvMap->FindObject(hvChannel.Data()));
2c780493 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 {
32f1b761 369 // find out min value, and makes a cut
2c780493 370 Float_t hvMin(1E9);
2c780493 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);
2c780493 378 }
379
527707f3 380 float lowThreshold = HVLimit(chamberId);
2c780493 381
382 if ( hvMin < lowThreshold ) hvChannelTooLow = kTRUE;
32f1b761 383 if ( hvMin < hvNamer.TrackerHVOFF() ) hvChannelON = kFALSE;
2c780493 384 }
385 }
386
1d5cf0f2 387 TString hvSwitch(hvNamer.DCSSwitchAliasName(detElemId,pcbIndex));
49e396d9 388 TPair* switchPair = static_cast<TPair*>(hvMap->FindObject(hvSwitch.Data()));
2c780493 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 {
ca913045 405 Float_t sv = SwitchValue(*values);
406 if ( sv < 0.99 ) hvSwitchON = kFALSE;
2c780493 407 }
408 }
409 return error;
410}
411
412//_____________________________________________________________________________
49e396d9 413Int_t
414AliMUONPadStatusMaker::HVStatus(Int_t detElemId, Int_t manuId) const
2c780493 415{
49e396d9 416 /// Get HV status of one manu
2c780493 417
99c136e1 418 AliCodeTimerAuto("",0)
2c780493 419
00977a64 420 if ( !fHV ) return kMissing;
49e396d9 421
422 Long_t lint = fHV->GetValue(AliMpManuUID::BuildUniqueID(detElemId,manuId));
2c780493 423
49e396d9 424 if ( lint )
425 {
426 return (Int_t)(lint - 1);
427 }
428
429 Int_t status(0);
2c780493 430
49e110ec 431 AliMpDCSNamer hvNamer("TRACKER");
2c780493 432
49e396d9 433 switch ( AliMpDEManager::GetStationType(detElemId) )
2c780493 434 {
4e51cfd2 435 case AliMp::kStation12:
2c780493 436 {
49e396d9 437 int sector = hvNamer.ManuId2Sector(detElemId,manuId);
438 if ( sector >= 0 )
2c780493 439 {
49e396d9 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);
2c780493 470 }
2c780493 471 }
49e396d9 472 break;
473 default:
474 break;
2c780493 475 }
476
49e396d9 477 return status;
478}
479
480//_____________________________________________________________________________
481AliMUONVCalibParam*
482AliMUONPadStatusMaker::Neighbours(Int_t detElemId, Int_t manuId) const
483{
484 /// Get the neighbours parameters for a given manu
72dae9ff 485 AliMUONVStore* neighbourStore = fkCalibrationData.Neighbours();
49e396d9 486 return static_cast<AliMUONVCalibParam*>(neighbourStore->FindObject(detElemId,manuId));
2c780493 487}
488
489//_____________________________________________________________________________
8d8e920c 490AliMUONVStore*
49e396d9 491AliMUONPadStatusMaker::NeighboursStore() const
2c780493 492{
49e396d9 493 /// Return the store containing all the neighbours
72dae9ff 494 return fkCalibrationData.Neighbours();
49e396d9 495}
496
497//_____________________________________________________________________________
498AliMUONVCalibParam*
499AliMUONPadStatusMaker::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
2c780493 503
49e396d9 504 AliMUONVCalibParam* param = new AliMUONCalibParamNI(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,-1);
505 fStatus->Add(param);
004a9ccd 506
49e396d9 507 AliMUONVCalibParam* pedestals = static_cast<AliMUONVCalibParam*>(fPedestals->FindObject(detElemId,manuId));
508
509 AliMUONVCalibParam* gains = static_cast<AliMUONVCalibParam*>(fGains->FindObject(detElemId,manuId));
2c780493 510
49e396d9 511 Int_t hvStatus = HVStatus(detElemId,manuId);
512
7eafe398 513 Int_t occStatus = OccupancyStatus(detElemId,manuId);
2c780493 514
49e396d9 515 for ( Int_t manuChannel = 0; manuChannel < param->Size(); ++manuChannel )
2c780493 516 {
49e396d9 517 Int_t pedStatus(0);
518
519 if (pedestals)
2c780493 520 {
49e396d9 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
004a9ccd 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;
49e396d9 546 if ( thres < fGainThresLimits.X() ) gainStatus |= kGainThresTooLow;
547 else if ( thres > fGainThresLimits.Y() ) gainStatus |= kGainThresTooHigh;
2c780493 548 }
49e396d9 549 else
550 {
551 gainStatus = kGainMissing;
552 }
2b8a1212 553
7eafe398 554 Int_t status = BuildStatus(pedStatus,hvStatus,gainStatus,occStatus);
49e396d9 555
556 param->SetValueAsIntFast(manuChannel,0,status);
2c780493 557 }
558
49e396d9 559 return param;
2c780493 560}
561
562//_____________________________________________________________________________
004a9ccd 563Int_t
7eafe398 564AliMUONPadStatusMaker::OccupancyStatus(Int_t detElemId, Int_t manuId) const
004a9ccd 565{
566 /// Get the "other" status for a given manu
7eafe398 567
568 Int_t rv(0);
569
004a9ccd 570 if ( fTrackerData )
571 {
7eafe398 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() )
004a9ccd 581 {
7eafe398 582 rv |= kDEOccupancyTooHigh;
004a9ccd 583 }
7eafe398 584
585 Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
586
587 occ = fTrackerData->BusPatch(busPatchId,occIndex);
588
411a502a 589 if ( occ <= fBuspatchOccupancyLimits.X() )
7eafe398 590 {
591 rv |= kBusPatchOccupancyTooLow;
592 }
411a502a 593 else if ( occ > fBuspatchOccupancyLimits.Y() )
7eafe398 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() )
004a9ccd 605 {
7eafe398 606 rv |= kManuOccupancyTooHigh;
004a9ccd 607 }
608 }
7eafe398 609 return rv;
004a9ccd 610}
611
612//_____________________________________________________________________________
49e396d9 613AliMUONVCalibParam*
614AliMUONPadStatusMaker::PadStatus(Int_t detElemId, Int_t manuId) const
2c780493 615{
004a9ccd 616 /// Get the status container for a given manu
2c780493 617
49e396d9 618 AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fStatus->FindObject(detElemId,manuId));
619 if (!param)
96199305 620 {
49e396d9 621 // not already there, so compute it now
99c136e1 622 AliCodeTimerAuto("ComputeStatus",0);
49e396d9 623 param = ComputeStatus(detElemId,manuId);
96199305 624 }
49e396d9 625 return param;
2c780493 626}
627
628//_____________________________________________________________________________
49e396d9 629Int_t
630AliMUONPadStatusMaker::PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
2c780493 631{
49e396d9 632 /// Get the status for a given channel
2c780493 633
49e396d9 634 AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fStatus->FindObject(detElemId,manuId));
635 if (!param)
2c780493 636 {
49e396d9 637 // not already there, so compute it now
638 param = ComputeStatus(detElemId,manuId);
639 }
640 return param->ValueAsInt(manuChannel,0);
2c780493 641}
642
643//_____________________________________________________________________________
644void
49e396d9 645AliMUONPadStatusMaker::SetHVStatus(Int_t detElemId, Int_t index, Int_t status) const
2c780493 646{
49e396d9 647 /// Assign status to all manus in a given HV "zone" (defined by index, meaning
648 /// is different thing from St12 and St345)
649
99c136e1 650 AliCodeTimerAuto("",0)
49e396d9 651
652 AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
2c780493 653
49e396d9 654 const AliMpArrayI* manus = de->ManusForHV(index);
2c780493 655
49e396d9 656 for ( Int_t i = 0; i < manus->GetSize(); ++ i )
2c780493 657 {
49e396d9 658 Int_t manuId = manus->GetValue(i);
659 fHV->Add(AliMpManuUID::BuildUniqueID(detElemId,manuId),status + 1);
2c780493 660 }
661}
411a502a 662
663//_____________________________________________________________________________
527707f3 664Double_t
665AliMUONPadStatusMaker::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//_____________________________________________________________________________
411a502a 676void
32f1b761 677AliMUONPadStatusMaker::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//_____________________________________________________________________________
699void
411a502a 700AliMUONPadStatusMaker::SetLimits(const AliMUONRecoParam& recoParams)
701{
702 /// Set the limits from the recoparam
703
32f1b761 704 for ( int i = 0; i < 10; ++i )
705 {
706 SetHVLimit(i,recoParams.HVLimit(i));
707 }
411a502a 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//_____________________________________________________________________________
722void
723AliMUONPadStatusMaker::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("");
99c136e1 729 AliCodeTimerAuto("",0);
411a502a 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
659e1281 752 if ( mask && ( status & mask) ) // note that if mask == 0, all pads are good...
411a502a 753 {
754 ++nBadPads;
755 log.Log(AsString(status));
756 }
757 }
758 }
759 }
760
0d66cd7d 761 if (!nPads)
762 {
763 AliError("Got no pad from the iterator ?! That's not normal. Please check !");
764 return;
765 }
766
411a502a 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 %%)",
f64f0649 771 mask,nBadPads,nPads,nBadPads*100.0/nPads) << endl;
411a502a 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