[u/mrichter/AliRoot.git] / MUON / AliMUONPadStatusMaker.h

#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$

/// \ingroup rec
/// \class AliMUONPadStatusMaker
/// \brief Make a 2DStore of pad statuses, using different sources of information
/// 
//  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;

class AliMUONPadStatusMaker : public TObject
{
public:
  AliMUONPadStatusMaker(const AliMUONCalibrationData& calibData);
  virtual ~AliMUONPadStatusMaker();
  
  /// Get the reference to the calibrationdata object we use.
  const AliMUONCalibrationData& CalibrationData() const { return fkCalibrationData; }
  
  /** Get access to internal status store (for debug only, as it may not be complete,
    depending on whether you've already called PadStatus for all possible de,manu
    combinations or not...
    */
  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);

  /// Return Low and High limits for a0 parameter of gain (linear slope)
  TVector2 GainA1Limits() const { return fGainA1Limits; }
  /// Return Low and High limits for a1 parameter of gain (parabolic term)
  TVector2 GainA2Limits() const { return fGainA2Limits; }
  /// Return Low and High limits for thres parameter of gain
  TVector2 GainThresLimits() const { return fGainThresLimits; }
  
  /// Return Low and High threshold for St12 HV
  TVector2 HVSt12Limits() const { return fHVSt12Limits; }
  /// Return Low and High threshold for St345 HV
  TVector2 HVSt345Limits() const { return fHVSt345Limits; }
  
  /// Return Low and High threshold for pedestal mean
  TVector2 PedMeanLimits() const { return fPedMeanLimits; }
  /// Return Low and High threshold for pedestal sigma
  TVector2 PedSigmaLimits() const { return fPedSigmaLimits; }
  
  /// Set Low and High limits for a0 parameter of gain (linear slope)
  void GainA1Limits(float low, float high) { fGainA1Limits.Set(low,high); }
  /// Set Low and High limits for a1 parameter of gain (parabolic term)
  void GainA2Limits(float low, float high) { fGainA2Limits.Set(low,high); }
  /// Set Low and High limits for thres parameter of gain
  void GainThresLimits(float low, float high) { fGainThresLimits.Set(low,high); }
  
  /// Set Low and High threshold for St12 HV
  void SetHVSt12Limits(float low, float high) { fHVSt12Limits.Set(low,high); }
  /// Set Low and High threshold for St345 HV
  void SetHVSt345Limits(float low, float high) { fHVSt345Limits.Set(low,high); }

  /// Set Low and High threshold for pedestal mean
  void SetPedMeanLimits(float low, float high) { fPedMeanLimits.Set(low,high); }
  /// Set Low and High threshold for pedestal sigma 
  void SetPedSigmaLimits(float low, float high) { fPedSigmaLimits.Set(low,high); }
  
	/// Set Low and High threshold for gain a0 term
	void SetGainA1Limits(float low, float high) { fGainA1Limits.Set(low,high); }
	/// Set Low and High threshold for gain a1 term
	void SetGainA2Limits(float low, float high) { fGainA2Limits.Set(low,high); }
	/// Set Low and High threshold for gain threshold term
	void SetGainThresLimits(float low, float high) { fGainThresLimits.Set(low,high); }
	
  /// Set Low and High manu occupancy limits
  void SetManuOccupancyLimits(float low, float high) { fManuOccupancyLimits.Set(low,high); }
  /// Get manu occupancy limits
  TVector2 ManuOccupancyLimits() const { return fManuOccupancyLimits; }

  /// Set Low and High bus patch occupancy limits
  void SetBuspatchOccupancyLimits(float low, float high) { fBuspatchOccupancyLimits.Set(low,high); }
  /// Get bus patch occupancy limits
  TVector2 BuspatchOccupancyLimits() const { return fBuspatchOccupancyLimits; }

  /// Set Low and High DE occupancy limits
  void SetDEOccupancyLimits(float low, float high) { fDEOccupancyLimits.Set(low,high); }
  /// Get DE occupancy limits
  TVector2 DEOccupancyLimits() const { return fDEOccupancyLimits; }
  
  void SetLimits(const AliMUONRecoParam& recoParams);

  void Report(UInt_t mask);
  
private:
  /// Not implemented
  AliMUONPadStatusMaker(const AliMUONPadStatusMaker&);
  /// Not implemented
  AliMUONPadStatusMaker& operator=(const AliMUONPadStatusMaker&);

  static void DecodeStatus(Int_t status, Int_t& pedStatus, Int_t& hvStatus, 
                           Int_t&  gainStatus, Int_t& otherStatus);
  static Int_t BuildStatus(Int_t pedStatus, Int_t hvStatus, 
                           Int_t gainStatus, Int_t otherStatus);
  
  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;

  Int_t HVStatus(Int_t detElemId, Int_t manuId) const;

  Int_t OccupancyStatus(Int_t detElemId, Int_t manuId) const;
  
  void SetHVStatus(Int_t detElemId, Int_t index, Int_t status) const;

private:
  /// General status
  enum EGeneralStatus
  {
    kMissing = (1<<7)
  };

  /// Gain status
  enum EGainStatus
  {
    kGainOK = 0,
    kGainA1TooLow = (1<<1),
    kGainA1TooHigh = (1<<2),
    kGainA2TooLow = (1<<3),
    kGainA2TooHigh = (1<<4),
    kGainThresTooLow = (1<<5),
    kGainThresTooHigh = (1<<6),
    
    kGainMissing = kMissing // please always use last bit for meaning "missing"
  };
  
  /// Pedestal status
  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"
  };
  
  /// HV Error
  enum EHVError 
  {
    kHVOK = 0,
    kHVError = (1<<0),
    kHVTooLow = (1<<1),
    kHVTooHigh = (1<<2),
    kHVChannelOFF = (1<<3),
    kHVSwitchOFF = (1<<4),

    kHVMissing = kMissing // please always use last bit for meaning "missing"
  };
  
  /// Other
  enum EOccupancyStatus
  {
    kManuOccupancyTooLow = (1<<1),
    kManuOccupancyTooHigh = (1<<2),
    kBusPatchOccupancyTooLow = (1<<3),
    kBusPatchOccupancyTooHigh = (1<<4),
    kDEOccupancyTooLow = (1<<5),
    kDEOccupancyTooHigh = (1<<6)
  };
  
  const AliMUONCalibrationData& fkCalibrationData; //!< helper class to get data access (not owner)
  
  TVector2 fGainA1Limits; //!< Low and High threshold for gain a0 parameter
  TVector2 fGainA2Limits; //!< Low and High threshold for gain a1 parameter
  TVector2 fGainThresLimits; //!< Low and High threshold for gain threshold parameter

  TVector2 fHVSt12Limits; //!< Low and High threshold for St12 HV
  TVector2 fHVSt345Limits; //!< Low and High threshold for St345 HV

  TVector2 fPedMeanLimits; //!< Low and High threshold for pedestal mean
  TVector2 fPedSigmaLimits; //!< Low and High threshold for pedestal sigma
  
  TVector2 fManuOccupancyLimits; //!< Low and High manu occupancy limits
  TVector2 fBuspatchOccupancyLimits; //!< Low and High buspatch occupancy limits
  TVector2 fDEOccupancyLimits; //!< Low and High DE occupancy limits
  
  AliMUONVStore* fStatus; //!< statuses of the pads
  
  mutable TExMap* fHV; //!< cache of hv statuses

  AliMUONVStore* fPedestals; //!< pedestal values
  AliMUONVStore* fGains; //!< gain values
  
  AliMUONVTrackerData* fTrackerData; //!< to get occupancies...
  
  ClassDef(AliMUONPadStatusMaker,0) // Creates pad statuses from ped,gain,hv
};

#endif
Commit	Line	Data
	1	#ifndef ALIMUONPADSTATUSMAKER_H
	2	#define ALIMUONPADSTATUSMAKER_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	// $Id$
	8
	9	/// \ingroup rec
	10	/// \class AliMUONPadStatusMaker
	11	/// \brief Make a 2DStore of pad statuses, using different sources of information
	12	///
	13	// Author Laurent Aphecetche
	14
	15	#ifndef ROOT_TObject
	16	# include "TObject.h"
	17	#endif
	18	#ifndef ROOT_TVector2
	19	# include "TVector2.h"
	20	#endif
	21
	22	class TExMap;
	23	class AliMUONCalibrationData;
	24	class AliMUONRecoParam;
	25	class AliMUONVCalibParam;
	26	class AliMUONVTrackerData;
	27	class AliMUONVStore;
	28
	29	class AliMUONPadStatusMaker : public TObject
	30	{
	31	public:
	32	AliMUONPadStatusMaker(const AliMUONCalibrationData& calibData);
	33	virtual ~AliMUONPadStatusMaker();
	34
	35	/// Get the reference to the calibrationdata object we use.
	36	const AliMUONCalibrationData& CalibrationData() const { return fkCalibrationData; }
	37
	38	/** Get access to internal status store (for debug only, as it may not be complete,
	39	depending on whether you've already called PadStatus for all possible de,manu
	40	combinations or not...
	41	*/
	42	AliMUONVStore* StatusStore() const { return fStatus; }
	43
	44	AliMUONVCalibParam* PadStatus(Int_t detElemId, Int_t manuId) const;
	45
	46	Int_t PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const;
	47
	48	AliMUONVStore* NeighboursStore() const;
	49
	50	AliMUONVCalibParam* Neighbours(Int_t detElemId, Int_t manuId) const;
	51
	52	static TString AsString(Int_t status);
	53
	54	static TString AsCondition(Int_t status);
	55
	56	/// Return Low and High limits for a0 parameter of gain (linear slope)
	57	TVector2 GainA1Limits() const { return fGainA1Limits; }
	58	/// Return Low and High limits for a1 parameter of gain (parabolic term)
	59	TVector2 GainA2Limits() const { return fGainA2Limits; }
	60	/// Return Low and High limits for thres parameter of gain
	61	TVector2 GainThresLimits() const { return fGainThresLimits; }
	62
	63	/// Return Low and High threshold for St12 HV
	64	TVector2 HVSt12Limits() const { return fHVSt12Limits; }
	65	/// Return Low and High threshold for St345 HV
	66	TVector2 HVSt345Limits() const { return fHVSt345Limits; }
	67
	68	/// Return Low and High threshold for pedestal mean
	69	TVector2 PedMeanLimits() const { return fPedMeanLimits; }
	70	/// Return Low and High threshold for pedestal sigma
	71	TVector2 PedSigmaLimits() const { return fPedSigmaLimits; }
	72
	73	/// Set Low and High limits for a0 parameter of gain (linear slope)
	74	void GainA1Limits(float low, float high) { fGainA1Limits.Set(low,high); }
	75	/// Set Low and High limits for a1 parameter of gain (parabolic term)
	76	void GainA2Limits(float low, float high) { fGainA2Limits.Set(low,high); }
	77	/// Set Low and High limits for thres parameter of gain
	78	void GainThresLimits(float low, float high) { fGainThresLimits.Set(low,high); }
	79
	80	/// Set Low and High threshold for St12 HV
	81	void SetHVSt12Limits(float low, float high) { fHVSt12Limits.Set(low,high); }
	82	/// Set Low and High threshold for St345 HV
	83	void SetHVSt345Limits(float low, float high) { fHVSt345Limits.Set(low,high); }
	84
	85	/// Set Low and High threshold for pedestal mean
	86	void SetPedMeanLimits(float low, float high) { fPedMeanLimits.Set(low,high); }
	87	/// Set Low and High threshold for pedestal sigma
	88	void SetPedSigmaLimits(float low, float high) { fPedSigmaLimits.Set(low,high); }
	89
	90	/// Set Low and High threshold for gain a0 term
	91	void SetGainA1Limits(float low, float high) { fGainA1Limits.Set(low,high); }
	92	/// Set Low and High threshold for gain a1 term
	93	void SetGainA2Limits(float low, float high) { fGainA2Limits.Set(low,high); }
	94	/// Set Low and High threshold for gain threshold term
	95	void SetGainThresLimits(float low, float high) { fGainThresLimits.Set(low,high); }
	96
	97	/// Set Low and High manu occupancy limits
	98	void SetManuOccupancyLimits(float low, float high) { fManuOccupancyLimits.Set(low,high); }
	99	/// Get manu occupancy limits
	100	TVector2 ManuOccupancyLimits() const { return fManuOccupancyLimits; }
	101
	102	/// Set Low and High bus patch occupancy limits
	103	void SetBuspatchOccupancyLimits(float low, float high) { fBuspatchOccupancyLimits.Set(low,high); }
	104	/// Get bus patch occupancy limits
	105	TVector2 BuspatchOccupancyLimits() const { return fBuspatchOccupancyLimits; }
	106
	107	/// Set Low and High DE occupancy limits
	108	void SetDEOccupancyLimits(float low, float high) { fDEOccupancyLimits.Set(low,high); }
	109	/// Get DE occupancy limits
	110	TVector2 DEOccupancyLimits() const { return fDEOccupancyLimits; }
	111
	112	void SetLimits(const AliMUONRecoParam& recoParams);
	113
	114	void Report(UInt_t mask);
	115
	116	private:
	117	/// Not implemented
	118	AliMUONPadStatusMaker(const AliMUONPadStatusMaker&);
	119	/// Not implemented
	120	AliMUONPadStatusMaker& operator=(const AliMUONPadStatusMaker&);
	121
	122	static void DecodeStatus(Int_t status, Int_t& pedStatus, Int_t& hvStatus,
	123	Int_t& gainStatus, Int_t& otherStatus);
	124	static Int_t BuildStatus(Int_t pedStatus, Int_t hvStatus,
	125	Int_t gainStatus, Int_t otherStatus);
	126
	127	AliMUONVCalibParam* ComputeStatus(Int_t detElemId, Int_t manuId) const;
	128
	129	Bool_t HVSt12Status(Int_t detElemId, Int_t sector,
	130	Bool_t& hvChannelTooLow,
	131	Bool_t& hvChannelTooHigh,
	132	Bool_t& hvChannelON) const;
	133
	134
	135	Bool_t HVSt345Status(Int_t detElemId, Int_t pcbIndex,
	136	Bool_t& hvChannelTooLow,
	137	Bool_t& hvChannelTooHigh,
	138	Bool_t& hvChannelON,
	139	Bool_t& hvSwitchON) const;
	140
	141	Int_t HVStatus(Int_t detElemId, Int_t manuId) const;
	142
	143	Int_t OccupancyStatus(Int_t detElemId, Int_t manuId) const;
	144
	145	void SetHVStatus(Int_t detElemId, Int_t index, Int_t status) const;
	146
	147	private:
	148	/// General status
	149	enum EGeneralStatus
	150	{
	151	kMissing = (1<<7)
	152	};
	153
	154	/// Gain status
	155	enum EGainStatus
	156	{
	157	kGainOK = 0,
	158	kGainA1TooLow = (1<<1),
	159	kGainA1TooHigh = (1<<2),
	160	kGainA2TooLow = (1<<3),
	161	kGainA2TooHigh = (1<<4),
	162	kGainThresTooLow = (1<<5),
	163	kGainThresTooHigh = (1<<6),
	164
	165	kGainMissing = kMissing // please always use last bit for meaning "missing"
	166	};
	167
	168	/// Pedestal status
	169	enum EPedestalStatus
	170	{
	171	kPedOK = 0,
	172	kPedMeanZero = (1<<1),
	173	kPedMeanTooLow = (1<<2),
	174	kPedMeanTooHigh = (1<<3),
	175	kPedSigmaTooLow = (1<<4),
	176	kPedSigmaTooHigh = (1<<5),
	177
	178	kPedMissing = kMissing // please always use last bit for meaning "missing"
	179	};
	180
	181	/// HV Error
	182	enum EHVError
	183	{
	184	kHVOK = 0,
	185	kHVError = (1<<0),
	186	kHVTooLow = (1<<1),
	187	kHVTooHigh = (1<<2),
	188	kHVChannelOFF = (1<<3),
	189	kHVSwitchOFF = (1<<4),
	190
	191	kHVMissing = kMissing // please always use last bit for meaning "missing"
	192	};
	193
	194	/// Other
	195	enum EOccupancyStatus
	196	{
	197	kManuOccupancyTooLow = (1<<1),
	198	kManuOccupancyTooHigh = (1<<2),
	199	kBusPatchOccupancyTooLow = (1<<3),
	200	kBusPatchOccupancyTooHigh = (1<<4),
	201	kDEOccupancyTooLow = (1<<5),
	202	kDEOccupancyTooHigh = (1<<6)
	203	};
	204
	205	const AliMUONCalibrationData& fkCalibrationData; //!< helper class to get data access (not owner)
	206
	207	TVector2 fGainA1Limits; //!< Low and High threshold for gain a0 parameter
	208	TVector2 fGainA2Limits; //!< Low and High threshold for gain a1 parameter
	209	TVector2 fGainThresLimits; //!< Low and High threshold for gain threshold parameter
	210
	211	TVector2 fHVSt12Limits; //!< Low and High threshold for St12 HV
	212	TVector2 fHVSt345Limits; //!< Low and High threshold for St345 HV
	213
	214	TVector2 fPedMeanLimits; //!< Low and High threshold for pedestal mean
	215	TVector2 fPedSigmaLimits; //!< Low and High threshold for pedestal sigma
	216
	217	TVector2 fManuOccupancyLimits; //!< Low and High manu occupancy limits
	218	TVector2 fBuspatchOccupancyLimits; //!< Low and High buspatch occupancy limits
	219	TVector2 fDEOccupancyLimits; //!< Low and High DE occupancy limits
	220
	221	AliMUONVStore* fStatus; //!< statuses of the pads
	222
	223	mutable TExMap* fHV; //!< cache of hv statuses
	224
	225	AliMUONVStore* fPedestals; //!< pedestal values
	226	AliMUONVStore* fGains; //!< gain values
	227
	228	AliMUONVTrackerData* fTrackerData; //!< to get occupancies...
	229
	230	ClassDef(AliMUONPadStatusMaker,0) // Creates pad statuses from ped,gain,hv
	231	};
	232
	233	#endif