[u/mrichter/AliRoot.git] / VZERO / AliVZEROCalibData.h

#ifndef ALIVZEROCALIBDATA_H
#define ALIVZEROCALIBDATA_H

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

////////////////////////////////////////////////
//                                            // 
//  class for VZERO calibration               //
//                                            //
////////////////////////////////////////////////

#include "TNamed.h"

class AliVZERODataDCS;

class AliVZEROCalibData: public TNamed {

 public:
  enum { kNCIUBoards = 8 };
  
  AliVZEROCalibData();
  AliVZEROCalibData(const char* name);
  AliVZEROCalibData(const AliVZEROCalibData &calibda);
  AliVZEROCalibData& operator= (const AliVZEROCalibData &calibda);
  virtual ~AliVZEROCalibData();
  void Reset();
  void FillDCSData(AliVZERODataDCS * data);

  Float_t  GetPedestal(Int_t channel)   const {return fPedestal[channel];}
  Float_t* GetPedestal()   const {return (float*)fPedestal;}
  Float_t  GetSigma(Int_t channel)   const {return fSigma[channel];}
  Float_t* GetSigma()   const {return (float*)fSigma;}
  Float_t  GetADCmean(Int_t channel)	const {return fADCmean[channel];}
  Float_t* GetADCmean()   const {return (float*)fADCmean;}
  Float_t  GetADCsigma(Int_t channel)	const {return fADCsigma[channel];}
  Float_t* GetADCsigma()   const {return (float*)fADCsigma;}
  Float_t  GetMeanHV(Int_t channel)	const {return fMeanHV[channel];}
  Float_t* GetMeanHV()   const {return (float*)fMeanHV;} 
  Float_t  GetWidthHV(Int_t channel)	const {return fWidthHV[channel];}
  Float_t* GetWidthHV()   const {return (float*)fWidthHV;}
  Bool_t   IsChannelDead(Int_t channel)	const {return fDeadChannel[channel];}
  Bool_t*  GetDeadMap()   const {return (bool*)fDeadChannel;} 
   
  Float_t  GetGain(Int_t channel);
  Float_t  GetTimeOffset(Int_t channel)	const {return fTimeOffset[channel];}
  Float_t* GetTimeOffset()   const {return (float*)fTimeOffset;}
  Float_t  GetTimeGain(Int_t channel)	const {return fTimeGain[channel];}
  Float_t* GetTimeGain()   const {return (float*)fTimeGain;}

  Float_t* GetTimeResolution() const {return (Float_t*) fTimeResolution;};
  Float_t  GetTimeResolution(Int_t board ) const  {return ((board>=0 && board<kNCIUBoards)?fTimeResolution[board]:0);};

  Float_t* GetWidthResolution() const {return (Float_t*) fWidthResolution;};
  Float_t  GetWidthResolution(Int_t board ) const  {return ((board>=0 && board<kNCIUBoards)?fWidthResolution[board]:0);};

  const UInt_t*  GetMatchWindow() const { return fMatchWindow; }
  UInt_t   GetMatchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fMatchWindow[board]:0); }
  const UInt_t*  GetSearchWindow() const { return fSearchWindow; }
  UInt_t   GetSearchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fSearchWindow[board]:0); }
  const UInt_t*  GetTriggerCountOffset() const { return fTriggerCountOffset; }
  UInt_t   GetTriggerCountOffset(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fTriggerCountOffset[board]:0); }
  const UInt_t*  GetRollOver() const { return fRollOver; }
  UInt_t   GetRollOver(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fRollOver[board]:0); }

  Float_t  GetDiscriThr(Int_t channel)	const {return fDiscriThr[channel];}
  Float_t* GetDiscriThr()   const {return (Float_t*)fDiscriThr;}
    
  void     SetPedestal(Float_t val, Int_t channel) {fPedestal[channel]=val;}
  void     SetPedestal(const Float_t* Pedestal);
  void     SetSigma(Float_t val, Int_t channel) {fSigma[channel]=val;}
  void     SetSigma(const Float_t* Sigma);
  void 	   SetADCmean(Float_t val, Int_t channel) {fADCmean[channel]=val;}
  void 	   SetADCmean(const Float_t* ADCmean);  
  void 	   SetADCsigma(Float_t val, Int_t channel) {fADCsigma[channel]=val;}
  void 	   SetADCsigma(const Float_t* ADCsigma);
  void     SetMeanHV(Float_t val, Int_t channel) {fMeanHV[channel]=val;}
  void     SetMeanHV(const Float_t* MeanHV);  
  void     SetWidthHV(Float_t val, Int_t channel) {fWidthHV[channel]=val;}
  void     SetWidthHV(const Float_t* WidthHV); 
  void     SetDeadChannel(Bool_t val, Int_t channel) {fDeadChannel[channel]=val;}
  void     SetDeadMap(const Bool_t* deadMap);  
   
  void     SetTimeOffset(Float_t val, Int_t board, Int_t channel);
  void     SetTimeOffset(const Float_t* TimeOffset);
  void     SetTimeGain(Float_t val, Int_t channel) {fTimeGain[channel]=val;}
  void     SetTimeGain(const Float_t* TimeGain);
  
  void 	   SetParameter(TString name, Int_t val);
  void     SetTimeResolution(UShort_t *resols);
  void     SetTimeResolution(UShort_t resol, Int_t board);
  void     SetWidthResolution(UShort_t *resols);
  void     SetWidthResolution(UShort_t resol, Int_t board);

  void     SetMatchWindow(UInt_t *windows);
  void     SetMatchWindow(UInt_t window, Int_t board);
  void     SetSearchWindow(UInt_t *windows);
  void     SetSearchWindow(UInt_t window, Int_t board);
  void     SetTriggerCountOffset(UInt_t *offsets);
  void     SetTriggerCountOffset(UInt_t offset, Int_t board);
  void     SetRollOver(UInt_t *offsets);
  void     SetRollOver(UInt_t offset, Int_t board);

  void     SetDiscriThr(Float_t thr, Int_t board, Int_t channel);
  void     SetDiscriThr(const Float_t* thresholds);

  Float_t  GetMIPperADC(Int_t channel);

  static Int_t GetOfflineChannelNumber(Int_t board, Int_t channel);
  static Int_t GetBoardNumber(Int_t channel);
  static Int_t GetFEEChannelNumber(Int_t channel);

  Float_t  GetLightYields(Int_t channel);

  Float_t *GetPMGainsA() const { return fPMGainsA; }
  Float_t *GetPMGainsB() const { return fPMGainsB; }

  Float_t  GetCalibDiscriThr(Int_t channel, Bool_t scaled);

 protected:
  void     InitLightYields();
  void     InitPMGains();

  Float_t  fPedestal[128];     // Mean pedestal values
  Float_t  fSigma[128];        // Sigmas of pedestal peaks
  Float_t  fADCmean[128];      // ADC mean values
  Float_t  fADCsigma[128];     // ADC sigma values
  Float_t  fMeanHV[64];        // Mean PMT HV needed to compute MIP value
  Float_t  fWidthHV[64];       // Width of the PMT HV
  
  Float_t  fTimeOffset[64];    // Time offsets of the TDC
  Float_t  fTimeGain[64];      // Gain factors of the TDC
  Bool_t   fDeadChannel[64];   // List of dead channels
  Float_t  fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel)
  Float_t  fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel)

  UInt_t   fMatchWindow[kNCIUBoards]; // HPTDC matching window (25ns units)
  UInt_t   fSearchWindow[kNCIUBoards];// HPTDC search window (25ns units)
  UInt_t   fTriggerCountOffset[kNCIUBoards]; // HPTDC trigger count offset (25ns units)
  UInt_t   fRollOver[kNCIUBoards]; // HPTDC roll-over (25ns units)

  Float_t  fDiscriThr[64];     // Discriminator thresholds

  Float_t *fLightYields;       //! Light Yields channel by channel (read from separate OCDB entry)
  Float_t *fPMGainsA;          //! PM gain factors channel by channel (read from separate OCDB entry)
  Float_t *fPMGainsB;          //! PM gain factors channel by channel (read from separate OCDB entry)

  ClassDef(AliVZEROCalibData,8)    // VZERO Calibration data
};

#endif
Commit	Line	Data
ee700a83	1	#ifndef ALIVZEROCALIBDATA_H
	2	#define ALIVZEROCALIBDATA_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	////////////////////////////////////////////////
	8	// //
	9	// class for VZERO calibration //
	10	// //
	11	////////////////////////////////////////////////
	12
	13	#include "TNamed.h"
32c24147	14
32c24147	15	class AliVZERODataDCS;
ee700a83	16
	17	class AliVZEROCalibData: public TNamed {
	18
	19	public:
d5deaaa5	20	enum { kNCIUBoards = 8 };
d5deaaa5	21
ee700a83	22	AliVZEROCalibData();
	23	AliVZEROCalibData(const char* name);
	24	AliVZEROCalibData(const AliVZEROCalibData &calibda);
	25	AliVZEROCalibData& operator= (const AliVZEROCalibData &calibda);
	26	virtual ~AliVZEROCalibData();
fae0e0c0	27	void Reset();
d5deaaa5	28	void FillDCSData(AliVZERODataDCS * data);
ee700a83	29
	30	Float_t GetPedestal(Int_t channel) const {return fPedestal[channel];}
	31	Float_t* GetPedestal() const {return (float*)fPedestal;}
fae0e0c0	32	Float_t GetSigma(Int_t channel) const {return fSigma[channel];}
fae0e0c0	33	Float_t* GetSigma() const {return (float*)fSigma;}
60a8e5df	34	Float_t GetADCmean(Int_t channel) const {return fADCmean[channel];}
60a8e5df	35	Float_t* GetADCmean() const {return (float*)fADCmean;}
3bdfb56f	36	Float_t GetADCsigma(Int_t channel) const {return fADCsigma[channel];}
3bdfb56f	37	Float_t* GetADCsigma() const {return (float*)fADCsigma;}
60a8e5df	38	Float_t GetMeanHV(Int_t channel) const {return fMeanHV[channel];}
	39	Float_t* GetMeanHV() const {return (float*)fMeanHV;}
	40	Float_t GetWidthHV(Int_t channel) const {return fWidthHV[channel];}
	41	Float_t* GetWidthHV() const {return (float*)fWidthHV;}
7495d2be	42	Bool_t IsChannelDead(Int_t channel) const {return fDeadChannel[channel];}
7495d2be	43	Bool_t* GetDeadMap() const {return (bool*)fDeadChannel;}
60a8e5df	44
3772afd5	45	Float_t GetGain(Int_t channel);
fae0e0c0	46	Float_t GetTimeOffset(Int_t channel) const {return fTimeOffset[channel];}
	47	Float_t* GetTimeOffset() const {return (float*)fTimeOffset;}
	48	Float_t GetTimeGain(Int_t channel) const {return fTimeGain[channel];}
	49	Float_t* GetTimeGain() const {return (float*)fTimeGain;}
d5deaaa5	50
d5deaaa5	51	Float_t* GetTimeResolution() const {return (Float_t*) fTimeResolution;};
4bc15c46	52	Float_t GetTimeResolution(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fTimeResolution[board]:0);};
d5deaaa5	53
d5deaaa5	54	Float_t* GetWidthResolution() const {return (Float_t*) fWidthResolution;};
4bc15c46	55	Float_t GetWidthResolution(Int_t board ) const {return ((board>=0 && board<kNCIUBoards)?fWidthResolution[board]:0);};
32cd3fdc	56
	57	const UInt_t* GetMatchWindow() const { return fMatchWindow; }
	58	UInt_t GetMatchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fMatchWindow[board]:0); }
	59	const UInt_t* GetSearchWindow() const { return fSearchWindow; }
	60	UInt_t GetSearchWindow(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fSearchWindow[board]:0); }
	61	const UInt_t* GetTriggerCountOffset() const { return fTriggerCountOffset; }
	62	UInt_t GetTriggerCountOffset(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fTriggerCountOffset[board]:0); }
	63	const UInt_t* GetRollOver() const { return fRollOver; }
	64	UInt_t GetRollOver(Int_t board) const { return ((board>=0 && board<kNCIUBoards)?fRollOver[board]:0); }
6e2c3e87	65
	66	Float_t GetDiscriThr(Int_t channel) const {return fDiscriThr[channel];}
	67	Float_t* GetDiscriThr() const {return (Float_t*)fDiscriThr;}
60a8e5df	68
ee700a83	69	void SetPedestal(Float_t val, Int_t channel) {fPedestal[channel]=val;}
32c24147	70	void SetPedestal(const Float_t* Pedestal);
fae0e0c0	71	void SetSigma(Float_t val, Int_t channel) {fSigma[channel]=val;}
32c24147	72	void SetSigma(const Float_t* Sigma);
60a8e5df	73	void SetADCmean(Float_t val, Int_t channel) {fADCmean[channel]=val;}
32c24147	74	void SetADCmean(const Float_t* ADCmean);
3bdfb56f	75	void SetADCsigma(Float_t val, Int_t channel) {fADCsigma[channel]=val;}
32c24147	76	void SetADCsigma(const Float_t* ADCsigma);
60a8e5df	77	void SetMeanHV(Float_t val, Int_t channel) {fMeanHV[channel]=val;}
32c24147	78	void SetMeanHV(const Float_t* MeanHV);
60a8e5df	79	void SetWidthHV(Float_t val, Int_t channel) {fWidthHV[channel]=val;}
32c24147	80	void SetWidthHV(const Float_t* WidthHV);
7495d2be	81	void SetDeadChannel(Bool_t val, Int_t channel) {fDeadChannel[channel]=val;}
32c24147	82	void SetDeadMap(const Bool_t* deadMap);
60a8e5df	83
51980118	84	void SetTimeOffset(Float_t val, Int_t board, Int_t channel);
32c24147	85	void SetTimeOffset(const Float_t* TimeOffset);
fae0e0c0	86	void SetTimeGain(Float_t val, Int_t channel) {fTimeGain[channel]=val;}
32c24147	87	void SetTimeGain(const Float_t* TimeGain);
d5deaaa5	88
5978520a	89	void SetParameter(TString name, Int_t val);
d5deaaa5	90	void SetTimeResolution(UShort_t *resols);
	91	void SetTimeResolution(UShort_t resol, Int_t board);
	92	void SetWidthResolution(UShort_t *resols);
	93	void SetWidthResolution(UShort_t resol, Int_t board);
706506da	94
32cd3fdc	95	void SetMatchWindow(UInt_t *windows);
	96	void SetMatchWindow(UInt_t window, Int_t board);
	97	void SetSearchWindow(UInt_t *windows);
	98	void SetSearchWindow(UInt_t window, Int_t board);
	99	void SetTriggerCountOffset(UInt_t *offsets);
	100	void SetTriggerCountOffset(UInt_t offset, Int_t board);
	101	void SetRollOver(UInt_t *offsets);
	102	void SetRollOver(UInt_t offset, Int_t board);
	103
51980118	104	void SetDiscriThr(Float_t thr, Int_t board, Int_t channel);
6e2c3e87	105	void SetDiscriThr(const Float_t* thresholds);
6e2c3e87	106
3772afd5	107	Float_t GetMIPperADC(Int_t channel);
706506da	108
51980118	109	static Int_t GetOfflineChannelNumber(Int_t board, Int_t channel);
51980118	110	static Int_t GetBoardNumber(Int_t channel);
d0ff6548	111	static Int_t GetFEEChannelNumber(Int_t channel);
51980118	112
3772afd5	113	Float_t GetLightYields(Int_t channel);
3772afd5	114
81da540f	115	Float_t *GetPMGainsA() const { return fPMGainsA; }
	116	Float_t *GetPMGainsB() const { return fPMGainsB; }
	117
ed1ea59f	118	Float_t GetCalibDiscriThr(Int_t channel, Bool_t scaled);
ed1ea59f	119
ee700a83	120	protected:
3772afd5	121	void InitLightYields();
	122	void InitPMGains();
	123
fae0e0c0	124	Float_t fPedestal[128]; // Mean pedestal values
fae0e0c0	125	Float_t fSigma[128]; // Sigmas of pedestal peaks
60a8e5df	126	Float_t fADCmean[128]; // ADC mean values
3bdfb56f	127	Float_t fADCsigma[128]; // ADC sigma values
60a8e5df	128	Float_t fMeanHV[64]; // Mean PMT HV needed to compute MIP value
60a8e5df	129	Float_t fWidthHV[64]; // Width of the PMT HV
fae0e0c0	130
32c24147	131	Float_t fTimeOffset[64]; // Time offsets of the TDC
	132	Float_t fTimeGain[64]; // Gain factors of the TDC
	133	Bool_t fDeadChannel[64]; // List of dead channels
d5deaaa5	134	Float_t fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel)
d5deaaa5	135	Float_t fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel)
ee700a83	136
32cd3fdc	137	UInt_t fMatchWindow[kNCIUBoards]; // HPTDC matching window (25ns units)
	138	UInt_t fSearchWindow[kNCIUBoards];// HPTDC search window (25ns units)
	139	UInt_t fTriggerCountOffset[kNCIUBoards]; // HPTDC trigger count offset (25ns units)
	140	UInt_t fRollOver[kNCIUBoards]; // HPTDC roll-over (25ns units)
	141
6e2c3e87	142	Float_t fDiscriThr[64]; // Discriminator thresholds
6e2c3e87	143
3772afd5	144	Float_t *fLightYields; //! Light Yields channel by channel (read from separate OCDB entry)
	145	Float_t *fPMGainsA; //! PM gain factors channel by channel (read from separate OCDB entry)
	146	Float_t *fPMGainsB; //! PM gain factors channel by channel (read from separate OCDB entry)
	147
	148	ClassDef(AliVZEROCalibData,8) // VZERO Calibration data
ee700a83	149	};
	150
	151	#endif