AliMUONPadStatusMaker.h

Go to the documentation of this file.

#ifndef ALIMUONPADSTATUSMAKER_H
#define ALIMUONPADSTATUSMAKER_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice                               */

// $Id$

//  Author Laurent Aphecetche

#ifndef ROOT_TObject
#  include "TObject.h"
#endif
#ifndef ROOT_TVector2
#  include "TVector2.h"
#endif

class TExMap;
class AliMUONCalibrationData;
class AliMUONRecoParam;
class AliMUONVCalibParam;
class AliMUONVTrackerData;
class AliMUONVStore;

using std::ostream;

class AliMUONPadStatusMaker : public TObject
{
public:
  AliMUONPadStatusMaker(const AliMUONCalibrationData& calibData);
  virtual ~AliMUONPadStatusMaker();

  const AliMUONCalibrationData& CalibrationData() const { return fkCalibrationData; }

  AliMUONVStore* StatusStore() const { return fStatus; }

  AliMUONVCalibParam* PadStatus(Int_t detElemId, Int_t manuId) const;

  Int_t PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const;

  AliMUONVStore* NeighboursStore() const;

  AliMUONVCalibParam* Neighbours(Int_t detElemId, Int_t manuId) const;

  static TString AsString(Int_t status);

  static TString AsCondition(Int_t status);

  Double_t HVLimit(Int_t chamberId) const;

  TVector2 PedMeanLimits() const { return fPedMeanLimits; }
  TVector2 PedSigmaLimits() const { return fPedSigmaLimits; }

  void SetHVLimit(Int_t chamberId, Double_t hv);

  void SetPedMeanLimits(float low, float high) { fPedMeanLimits.Set(low,high); }
  void SetPedSigmaLimits(float low, float high) { fPedSigmaLimits.Set(low,high); }

  void SetManuOccupancyLimits(float low, float high) { fManuOccupancyLimits.Set(low,high); }
  TVector2 ManuOccupancyLimits() const { return fManuOccupancyLimits; }

  void SetBuspatchOccupancyLimits(float low, float high) { fBuspatchOccupancyLimits.Set(low,high); }
  TVector2 BuspatchOccupancyLimits() const { return fBuspatchOccupancyLimits; }

  void SetDEOccupancyLimits(float low, float high) { fDEOccupancyLimits.Set(low,high); }
  TVector2 DEOccupancyLimits() const { return fDEOccupancyLimits; }

  void SetLimits(const AliMUONRecoParam& recoParams);

  void Report(UInt_t mask);

  static Float_t SwitchValue(const TObjArray& dcsArray);

  Int_t LVStatus(Int_t detElemId, Int_t manuId) const;

  Int_t HVStatus(Int_t detElemId, Int_t manuId) const;

  Int_t OccupancyStatus(Int_t detElemId, Int_t manuId) const;

  static void DecodeStatus(Int_t status, Int_t& pedStatus, Int_t& hvStatus,
                           Int_t&  lvStatus, Int_t& otherStatus);
  static Int_t BuildStatus(Int_t pedStatus, Int_t hvStatus,
                           Int_t lvStatus, Int_t otherStatus);
private:
  AliMUONPadStatusMaker(const AliMUONPadStatusMaker&);
  AliMUONPadStatusMaker& operator=(const AliMUONPadStatusMaker&);


  AliMUONVCalibParam* ComputeStatus(Int_t detElemId, Int_t manuId) const;

  Bool_t HVSt12Status(Int_t detElemId, Int_t sector,
                      Bool_t& hvChannelTooLow,
                      Bool_t& hvChannelTooHigh,
                      Bool_t& hvChannelON) const;


  Bool_t HVSt345Status(Int_t detElemId, Int_t pcbIndex,
                       Bool_t& hvChannelTooLow,
                       Bool_t& hvChannelTooHigh,
                       Bool_t& hvChannelON,
                       Bool_t& hvSwitchON) const;

  AliMUONVTrackerData* InternalTrackerData() const;
  TExMap* InternalHV() const;
  TExMap* InternalLV() const;
  void SetHVStatus(Int_t detElemId, Int_t index, Int_t status) const;
  Int_t CheckConfigConsistencyWithPedestalInformation(Int_t detElemId,Int_t manuId) const;

  AliMUONVStore* Pedestals() const;
  AliMUONVStore* Config() const;

public:
  enum EGeneralStatus
  {
    kMissing = (1<<7)
  };

  enum EPedestalStatus
  {
    kPedOK = 0,
    kPedMeanZero = (1<<1),
    kPedMeanTooLow = (1<<2),
    kPedMeanTooHigh = (1<<3),
    kPedSigmaTooLow = (1<<4),
    kPedSigmaTooHigh = (1<<5),

    kPedMissing = kMissing // please always use last bit for meaning "missing"
  };

  enum ELVStatus
  {
    kLVOK = 0,
    kLVTooLow = (1<<3),

    kLVMissing = kMissing // please always use last bit for meaning "missing"
  };

  enum EHVError
  {
    kHVOK = 0,
    kHVError = (1<<0),
    kHVTooLow = (1<<1),
    kHVTooHigh = (1<<2), // no longer to be used
    kHVChannelOFF = (1<<3),
    kHVSwitchOFF = (1<<4),

    kHVMissing = kMissing // please always use last bit for meaning "missing"
  };

  enum EOccupancyStatus
  {
    kManuOccupancyTooLow = (1<<1),
    kManuOccupancyTooHigh = (1<<2),
    kBusPatchOccupancyTooLow = (1<<3),
    kBusPatchOccupancyTooHigh = (1<<4),
    kDEOccupancyTooLow = (1<<5),
    kDEOccupancyTooHigh = (1<<6),
    kBusPatchRemovedByPAR = (1<<7),

  };

private:

  const AliMUONCalibrationData& fkCalibrationData; 

  Double_t fHVLimit[10]; 

  TVector2 fPedMeanLimits; 
  TVector2 fPedSigmaLimits; 

  TVector2 fManuOccupancyLimits; 
  TVector2 fBuspatchOccupancyLimits; 
  TVector2 fDEOccupancyLimits; 

  AliMUONVStore* fStatus; 

  mutable TExMap* fLV; 
  mutable TExMap* fHV; 

  mutable AliMUONVStore* fPedestals; 
  mutable AliMUONVStore* fConfig; 

  mutable AliMUONVTrackerData* fTrackerData; 

  ClassDef(AliMUONPadStatusMaker,0) // Creates pad statuses from ped,lv,hv
};

#endif