[u/mrichter/AliRoot.git] / ZDC / AliZDCRecParam.h

#ifndef ALIZDCRECPARAM_H
#define ALIZDCRECPARAM_H

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

////////////////////////////////////////////////
//  class for ZDC calibration                 //
////////////////////////////////////////////////

#include "TNamed.h"
#include "TH1.h"
#include "AliCDBEntry.h"

class AliZDC;

class AliZDCRecParam: public TNamed {

 public:
  AliZDCRecParam();
  AliZDCRecParam(const char* name);
  AliZDCRecParam(const AliZDCRecParam &calibda);
  AliZDCRecParam& operator= (const AliZDCRecParam &calibda);
  virtual ~AliZDCRecParam();
  void Reset();
  virtual void  Print(Option_t *) const; 
  //
  Float_t  GetMeanPed(Int_t channel)   	   const {return fMeanPedestal[channel];}
  Float_t* GetMeanPed()   		   const {return (float*)fMeanPedestal;}
  Float_t  GetMeanPedWidth(Int_t channel)  const {return fMeanPedWidth[channel];}
  Float_t* GetMeanPedWidth()   		   const {return (float*)fMeanPedWidth;}
  Float_t  GetOOTPed(Int_t channel)   	   const {return fOOTPedestal[channel];}
  Float_t* GetOOTPed()   		   const {return (float*)fOOTPedestal;}
  Float_t  GetOOTPedWidth(Int_t channel)   const {return fOOTPedWidth[channel];}
  Float_t* GetOOTPedWidth()   	           const {return (float*)fOOTPedWidth;}
  Float_t  GetPedCorrCoeff0(Int_t channel) const {return fPedCorrCoeff[0][channel];}
  Float_t  GetPedCorrCoeff1(Int_t channel) const {return fPedCorrCoeff[1][channel];}
  Float_t* GetPedCorrCoeff()		   const {return (float*)fPedCorrCoeff;}
  //
  Float_t  GetEnCalib(Int_t channel)	const {return fEnCalibration[channel];}
  Float_t* GetEnCalib()   		const {return (float*)fEnCalibration;}
  //
  Float_t  GetZN1EqualCoeff(Int_t channel) const {return fZN1EqualCoeff[channel];}
  Float_t* GetZN1EqualCoeffs()		   const {return (float*)fZN1EqualCoeff;}
  Float_t  GetZP1EqualCoeff(Int_t channel) const {return fZP1EqualCoeff[channel];}
  Float_t* GetZP1EqualCoeffs()		   const {return (float*)fZP1EqualCoeff;}
  Float_t  GetZN2EqualCoeff(Int_t channel) const {return fZN2EqualCoeff[channel];}
  Float_t* GetZN2EqualCoeffs()		   const {return (float*)fZN2EqualCoeff;}
  Float_t  GetZP2EqualCoeff(Int_t channel) const {return fZP2EqualCoeff[channel];}
  Float_t* GetZP2EqualCoeffs()		   const {return (float*)fZP2EqualCoeff;}
  //
  Float_t GetZEMEndValue()     const {return fZEMEndValue;}
  Float_t GetZEMCutFraction()  const {return fZEMCutFraction;}
  Float_t GetDZEMSup()	       const {return fDZEMSup;}
  Float_t GetDZEMInf()	       const {return fDZEMInf;}
  //
  Float_t GetEZN1MaxValue()  const {return fEZN1MaxValue;}
  Float_t GetEZP1MaxValue()  const {return fEZP1MaxValue;}
  Float_t GetEZDC1MaxValue() const {return fEZDC1MaxValue;}
  Float_t GetEZN2MaxValue()  const {return fEZN2MaxValue;}
  Float_t GetEZP2MaxValue()  const {return fEZP2MaxValue;}
  Float_t GetEZDC2MaxValue() const {return fEZDC2MaxValue;}

  void  SetMeanPed(Int_t channel, Float_t val) {fMeanPedestal[channel]=val;}
  void  SetMeanPed(Float_t* MeanPed);
  void  SetMeanPedWidth(Int_t channel, Float_t val) {fMeanPedWidth[channel]=val;}
  void  SetMeanPedWidth(Float_t* MeanPedWidth);
  void  SetOOTPed(Int_t channel, Float_t val) {fOOTPedestal[channel]=val;}
  void  SetOOTPed(Float_t* OOTPed);
  void  SetOOTPedWidth(Int_t channel, Float_t val) {fOOTPedWidth[channel]=val;}
  void  SetOOTPedWidth(Float_t* OOTPedWidth);
  void  SetPedCorrCoeff(Int_t channel, Float_t valCoeff0, Float_t valCoeff1)
  	{fPedCorrCoeff[0][channel]=valCoeff0; fPedCorrCoeff[1][channel]=valCoeff1;}
  void  SetPedCorrCoeff(Float_t* PedCorrCoeff);
  void  SetPedCorrCoeff(Float_t* PedCorrCoeff0, Float_t* PedCorrCoeff1);
  //
  void 	SetEnCalib(Int_t channel, Float_t val) {fEnCalibration[channel]=val;}
  void 	SetEnCalib(Float_t* EnCalib);
  //
  void 	SetZN1EqualCoeff(Int_t channel, Float_t val) {fZN1EqualCoeff[channel]=val;}
  void 	SetZN1EqualCoeff(Float_t* EqualCoeff);
  void 	SetZP1EqualCoeff(Int_t channel, Float_t val) {fZP1EqualCoeff[channel]=val;}
  void 	SetZP1EqualCoeff(Float_t* EqualCoeff);
  void 	SetZN2EqualCoeff(Int_t channel, Float_t val) {fZN2EqualCoeff[channel]=val;}
  void 	SetZN2EqualCoeff(Float_t* EqualCoeff);
  void 	SetZP2EqualCoeff(Int_t channel, Float_t val) {fZP2EqualCoeff[channel]=val;}
  void 	SetZP2EqualCoeff(Float_t* EqualCoeff);
  //  
  void  SetZEMEndValue(Float_t ZEMEndValue) {fZEMEndValue = ZEMEndValue;}
  void  SetZEMCutFraction(Float_t ZEMCutFraction) {fZEMCutFraction = ZEMCutFraction;}
  void  SetDZEMSup(Float_t DZEMSup) {fDZEMSup = DZEMSup;}
  void  SetDZEMInf(Float_t DZEMInf) {fDZEMInf = DZEMInf;}
  //
  void	SetEZN1MaxValue(Float_t value)  {fEZN1MaxValue = value;}
  void	SetEZP1MaxValue(Float_t value)  {fEZP1MaxValue = value;}
  void	SetEZDC1MaxValue(Float_t value) {fEZDC1MaxValue = value;}
  void	SetEZN2MaxValue(Float_t value)  {fEZN2MaxValue = value;}
  void	SetEZP2MaxValue(Float_t value)  {fEZP2MaxValue = value;}
  void	SetEZDC2MaxValue(Float_t value) {fEZDC2MaxValue = value;}
  
 protected:
  // --- Pedestals
  Float_t  fMeanPedestal[48];	 // Mean pedestal values 
  Float_t  fMeanPedWidth[48];	 // Mean pedestal widths 
  Float_t  fOOTPedestal[48];	 // "Out of Time" pedestal values
  Float_t  fOOTPedWidth[48];	 // "Out of Time" pedestal widths
  Float_t  fPedCorrCoeff[2][48]; // Fit of correlation in-time vs. out-of-time
  // --- E calibration
  Float_t  fEnCalibration[6];	 // Coeff. for energy calibration
  // --- Coefficients for tower calibration
  Float_t  fZN1EqualCoeff[5];	 // Equalization coefficients for ZN1 PTMs
  Float_t  fZP1EqualCoeff[5];	 // Equalization coefficients for ZN1 PTMs
  Float_t  fZN2EqualCoeff[5];	 // Equalization coefficients for ZN1 PTMs
  Float_t  fZP2EqualCoeff[5];	 // Equalization coefficients for ZN1 PTMs
  // --- Coefficients for centrality selection from ZEM signal
  Float_t  fZEMEndValue;    	 // End point value of ZEM energy spectrum
  Float_t  fZEMCutFraction; 	 // Fraction of ZEM energy spectrum used to cut
  Float_t  fDZEMSup;// Upper value of EZDCvs.ZEM correlation where ZEM signal is used
  Float_t  fDZEMInf;// Lower value of EZDCvs.ZEM correlation where ZEM signal is used
  // --- Parameters from EZDC vs. Nspec correlation
  Float_t  fEZN1MaxValue;	 // Max value of ZN1 vs. Nspec n correlation
  Float_t  fEZP1MaxValue;	 // Max value of ZP1 vs. Nspec p correlation
  Float_t  fEZDC1MaxValue;	 // Max value of ZDC1 vs. Nspec n+p correlation
  Float_t  fEZN2MaxValue;	 // Max value of ZN2 vs. Nspec n correlation
  Float_t  fEZP2MaxValue;	 // Max value of ZP2 vs. Nspec p correlation
  Float_t  fEZDC2MaxValue;	 // Max value of ZDC2 vs. Nspec n+p correlation
  //
  ClassDef(AliZDCRecParam,11)    // ZDC  Calibration data
};

#endif
Commit	Line	Data
6024ec85	1	#ifndef ALIZDCRECPARAM_H
	2	#define ALIZDCRECPARAM_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	// class for ZDC calibration //
	9	////////////////////////////////////////////////
	10
	11	#include "TNamed.h"
	12	#include "TH1.h"
	13	#include "AliCDBEntry.h"
	14
	15	class AliZDC;
	16
	17	class AliZDCRecParam: public TNamed {
	18
	19	public:
	20	AliZDCRecParam();
	21	AliZDCRecParam(const char* name);
	22	AliZDCRecParam(const AliZDCRecParam &calibda);
	23	AliZDCRecParam& operator= (const AliZDCRecParam &calibda);
	24	virtual ~AliZDCRecParam();
	25	void Reset();
	26	virtual void Print(Option_t *) const;
	27	//
	28	Float_t GetMeanPed(Int_t channel) const {return fMeanPedestal[channel];}
	29	Float_t* GetMeanPed() const {return (float*)fMeanPedestal;}
	30	Float_t GetMeanPedWidth(Int_t channel) const {return fMeanPedWidth[channel];}
	31	Float_t* GetMeanPedWidth() const {return (float*)fMeanPedWidth;}
	32	Float_t GetOOTPed(Int_t channel) const {return fOOTPedestal[channel];}
	33	Float_t* GetOOTPed() const {return (float*)fOOTPedestal;}
	34	Float_t GetOOTPedWidth(Int_t channel) const {return fOOTPedWidth[channel];}
	35	Float_t* GetOOTPedWidth() const {return (float*)fOOTPedWidth;}
	36	Float_t GetPedCorrCoeff0(Int_t channel) const {return fPedCorrCoeff[0][channel];}
	37	Float_t GetPedCorrCoeff1(Int_t channel) const {return fPedCorrCoeff[1][channel];}
	38	Float_t* GetPedCorrCoeff() const {return (float*)fPedCorrCoeff;}
	39	//
	40	Float_t GetEnCalib(Int_t channel) const {return fEnCalibration[channel];}
	41	Float_t* GetEnCalib() const {return (float*)fEnCalibration;}
	42	//
	43	Float_t GetZN1EqualCoeff(Int_t channel) const {return fZN1EqualCoeff[channel];}
	44	Float_t* GetZN1EqualCoeffs() const {return (float*)fZN1EqualCoeff;}
	45	Float_t GetZP1EqualCoeff(Int_t channel) const {return fZP1EqualCoeff[channel];}
	46	Float_t* GetZP1EqualCoeffs() const {return (float*)fZP1EqualCoeff;}
	47	Float_t GetZN2EqualCoeff(Int_t channel) const {return fZN2EqualCoeff[channel];}
	48	Float_t* GetZN2EqualCoeffs() const {return (float*)fZN2EqualCoeff;}
	49	Float_t GetZP2EqualCoeff(Int_t channel) const {return fZP2EqualCoeff[channel];}
	50	Float_t* GetZP2EqualCoeffs() const {return (float*)fZP2EqualCoeff;}
	51	//
	52	Float_t GetZEMEndValue() const {return fZEMEndValue;}
	53	Float_t GetZEMCutFraction() const {return fZEMCutFraction;}
	54	Float_t GetDZEMSup() const {return fDZEMSup;}
	55	Float_t GetDZEMInf() const {return fDZEMInf;}
	56	//
	57	Float_t GetEZN1MaxValue() const {return fEZN1MaxValue;}
	58	Float_t GetEZP1MaxValue() const {return fEZP1MaxValue;}
	59	Float_t GetEZDC1MaxValue() const {return fEZDC1MaxValue;}
	60	Float_t GetEZN2MaxValue() const {return fEZN2MaxValue;}
	61	Float_t GetEZP2MaxValue() const {return fEZP2MaxValue;}
	62	Float_t GetEZDC2MaxValue() const {return fEZDC2MaxValue;}
	63
	64	void SetMeanPed(Int_t channel, Float_t val) {fMeanPedestal[channel]=val;}
65	void SetMeanPed(Float_t* MeanPed);
66	void SetMeanPedWidth(Int_t channel, Float_t val) {fMeanPedWidth[channel]=val;}
67	void SetMeanPedWidth(Float_t* MeanPedWidth);
68	void SetOOTPed(Int_t channel, Float_t val) {fOOTPedestal[channel]=val;}
69	void SetOOTPed(Float_t* OOTPed);
70	void SetOOTPedWidth(Int_t channel, Float_t val) {fOOTPedWidth[channel]=val;}
71	void SetOOTPedWidth(Float_t* OOTPedWidth);
72	void SetPedCorrCoeff(Int_t channel, Float_t valCoeff0, Float_t valCoeff1)
73	{fPedCorrCoeff[0][channel]=valCoeff0; fPedCorrCoeff[1][channel]=valCoeff1;}
74	void SetPedCorrCoeff(Float_t* PedCorrCoeff);
75	void SetPedCorrCoeff(Float_t* PedCorrCoeff0, Float_t* PedCorrCoeff1);
76	//
77	void SetEnCalib(Int_t channel, Float_t val) {fEnCalibration[channel]=val;}
78	void SetEnCalib(Float_t* EnCalib);
79	//
80	void SetZN1EqualCoeff(Int_t channel, Float_t val) {fZN1EqualCoeff[channel]=val;}
81	void SetZN1EqualCoeff(Float_t* EqualCoeff);
82	void SetZP1EqualCoeff(Int_t channel, Float_t val) {fZP1EqualCoeff[channel]=val;}
83	void SetZP1EqualCoeff(Float_t* EqualCoeff);
84	void SetZN2EqualCoeff(Int_t channel, Float_t val) {fZN2EqualCoeff[channel]=val;}
85	void SetZN2EqualCoeff(Float_t* EqualCoeff);
86	void SetZP2EqualCoeff(Int_t channel, Float_t val) {fZP2EqualCoeff[channel]=val;}
87	void SetZP2EqualCoeff(Float_t* EqualCoeff);
88	//
89	void SetZEMEndValue(Float_t ZEMEndValue) {fZEMEndValue = ZEMEndValue;}
90	void SetZEMCutFraction(Float_t ZEMCutFraction) {fZEMCutFraction = ZEMCutFraction;}
91	void SetDZEMSup(Float_t DZEMSup) {fDZEMSup = DZEMSup;}
92	void SetDZEMInf(Float_t DZEMInf) {fDZEMInf = DZEMInf;}
93	//
94	void SetEZN1MaxValue(Float_t value) {fEZN1MaxValue = value;}
95	void SetEZP1MaxValue(Float_t value) {fEZP1MaxValue = value;}
96	void SetEZDC1MaxValue(Float_t value) {fEZDC1MaxValue = value;}
97	void SetEZN2MaxValue(Float_t value) {fEZN2MaxValue = value;}
98	void SetEZP2MaxValue(Float_t value) {fEZP2MaxValue = value;}
99	void SetEZDC2MaxValue(Float_t value) {fEZDC2MaxValue = value;}
100
101	protected:
102	// --- Pedestals
103	Float_t fMeanPedestal[48]; // Mean pedestal values
104	Float_t fMeanPedWidth[48]; // Mean pedestal widths
105	Float_t fOOTPedestal[48]; // "Out of Time" pedestal values
106	Float_t fOOTPedWidth[48]; // "Out of Time" pedestal widths
107	Float_t fPedCorrCoeff[2][48]; // Fit of correlation in-time vs. out-of-time
108	// --- E calibration
109	Float_t fEnCalibration[6]; // Coeff. for energy calibration
110	// --- Coefficients for tower calibration
111	Float_t fZN1EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs
112	Float_t fZP1EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs
113	Float_t fZN2EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs
114	Float_t fZP2EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs
115	// --- Coefficients for centrality selection from ZEM signal
116	Float_t fZEMEndValue; // End point value of ZEM energy spectrum
117	Float_t fZEMCutFraction; // Fraction of ZEM energy spectrum used to cut
118	Float_t fDZEMSup;// Upper value of EZDCvs.ZEM correlation where ZEM signal is used
119	Float_t fDZEMInf;// Lower value of EZDCvs.ZEM correlation where ZEM signal is used
120	// --- Parameters from EZDC vs. Nspec correlation
121	Float_t fEZN1MaxValue; // Max value of ZN1 vs. Nspec n correlation
122	Float_t fEZP1MaxValue; // Max value of ZP1 vs. Nspec p correlation
123	Float_t fEZDC1MaxValue; // Max value of ZDC1 vs. Nspec n+p correlation
124	Float_t fEZN2MaxValue; // Max value of ZN2 vs. Nspec n correlation
125	Float_t fEZP2MaxValue; // Max value of ZP2 vs. Nspec p correlation
126	Float_t fEZDC2MaxValue; // Max value of ZDC2 vs. Nspec n+p correlation
127	//
128	ClassDef(AliZDCRecParam,11) // ZDC Calibration data
129	};
130
131	#endif