[u/mrichter/AliRoot.git] / EMCAL / AliEMCALCalibTimeDep.h

#ifndef ALIEMCALCALIBTIMEDEP_H
#define ALIEMCALCALIBTIMEDEP_H

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

/* $Id: AliEMCALCalibTimeDep.h $ */

/////////////////////////////////////////////////
// class for EMCAL time-dependence calibration //
/////////////////////////////////////////////////

#include "TObject.h"

class AliEMCALSensorTempArray;
class AliCaloCalibSignal;
class AliEMCALCalibTempCoeff;
class AliEMCALCalibReference; 
class AliEMCALCalibTimeDepCorrection; 

class AliEMCALCalibTimeDep : public TObject {

 public:
  AliEMCALCalibTimeDep(); //! ctor
  AliEMCALCalibTimeDep(const AliEMCALCalibTimeDep &calibt); //! copy ctor
  AliEMCALCalibTimeDep& operator= (const AliEMCALCalibTimeDep &calibt); //! 
  virtual ~AliEMCALCalibTimeDep(); //! dtor
  virtual void PrintInfo() const; 

  void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);//!

  // simple getters
  Int_t GetRunNumber() const { return fRun; } // 
  UInt_t GetStartTime() const { return fStartTime; } // 
  UInt_t GetEndTime() const { return fEndTime; } //  
  Double_t GetLengthOfRunInHours() const; // 
  Double_t GetLengthOfRunInBins() const; // 

  // Temperature Section
  // access pointer to the basic temperature object: AliEMCALSensorTempArray 
  AliEMCALSensorTempArray  * GetTempArray() const { return fTempArray; } // temperature array

  // range of temperature readings/values during the run 
  Int_t ScanTemperatureInfo(); // go through the temperature info
  Double_t GetMinTemp() const { return fMinTemp; } //  
  Double_t GetMaxTemp() const { return fMaxTemp; } // 
  Double_t GetMinTempVariation() const { return fMinTempVariation; } //  
  Double_t GetMaxTempVariation() const { return fMaxTempVariation; } // 
  Double_t GetMinTempValid() const { return fMinTempValid; } //  
  Double_t GetMaxTempValid() const { return fMaxTempValid; } // 
  UInt_t GetMinTime() const { return fMinTime; } // 
  UInt_t GetMaxTime() const { return fMaxTime; } // 
  Double_t GetRangeOfTempMeasureInHours() const; //! 
  Double_t GetRangeOfTempMeasureInDegrees() const; //! 

  // basic calibration info
  Double_t GetTemperatureSM(int imod, UInt_t timeStamp) const; // for all sensors, in a SuperModule
  // End of Temperature Section

  // control parameters
  void SetTemperatureResolution(Double_t d) { fTemperatureResolution = d; } // value for checking at which level we care about temperature differences
  void SetMaxTemperatureDiff(Double_t d) { fMaxTemperatureDiff = d; } 
  void SetTimeBinsPerHour(Int_t i) { fTimeBinsPerHour = i; } // size of the time-bins we use for corrections
  Double_t GetTemperatureResolution() const { return fTemperatureResolution; } // value for checking at which level we care about temperature differences
  Double_t GetMaxTemperatureDiff() const { return fMaxTemperatureDiff; }
  Int_t GetTimeBinsPerHour() const { return fTimeBinsPerHour; } // size of the time-bins we use foc corrections

  void SetHighLowGainFactor(Double_t value) {fHighLowGainFactor = value;}
  Double_t GetHighLowGainFactor() const {return fHighLowGainFactor;}

  // access to other pointers
  AliCaloCalibSignal  * GetCalibSignal() const { return fCalibSignal; } //
  AliEMCALCalibTempCoeff  * GetCalibTempCoeff() const { return fCalibTempCoeff; } //
  AliEMCALCalibReference  * GetCalibReference() const { return fCalibReference; } //

  // storage and access of the correction info
  Int_t CalcCorrection(); //
  AliEMCALCalibTimeDepCorrection  * GetCalibTimeDepCorrection() 
    const { return fCalibTimeDepCorrection; } //

  Double_t GetTempCoeff(Double_t IDark, Double_t M) const; //

  // for local debugging: setters of the main input pointers that are normally from OCDB
  void SetTempArray(AliEMCALSensorTempArray  *arr) { fTempArray = arr; } // 
  void SetCalibSignal(AliCaloCalibSignal  *obj) { fCalibSignal = obj; } // 
  void SetCalibTempCoeff(AliEMCALCalibTempCoeff  *obj) { fCalibTempCoeff = obj; } //
  void SetCalibReference(AliEMCALCalibReference  *obj) { fCalibReference = obj; } //
  // basic setters, also for local debugging
  void SetRunNumber(Int_t i) { fRun= i; } // 
  void SetStartTime(UInt_t ui) { fStartTime = ui; } // 
  void SetEndTime(UInt_t ui) { fEndTime = ui; } //  

  void SetMinTempValid(Double_t d) { fMinTempValid = d; } //  
  void SetMaxTempValid(Double_t d) { fMaxTempValid = d; } // 

  Int_t GetVerbosity() const { return fVerbosity; } // debug flag 
  void SetVerbosity(Int_t i) { fVerbosity= i; } // debug flag 

 private:

  void Reset(); //

  void GetTemperatureInfo(); // pick up Preprocessor output
  void GetCalibSignalInfo(); // pick up Preprocessor output
  void GetCalibTempCoeffInfo(); // pick up OCDB info
  void GetCalibReferenceInfo(); // pick up OCDB info

  Int_t CalcLEDCorrection(Int_t nSM, Int_t nBins); // based on LED signals, and reference photodiodes
  Int_t CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins); // based on LED signals, and reference photodiodes
  Int_t CalcTemperatureCorrection(Int_t nSM, Int_t nBins, Int_t binSize); // based on temperature info

  //
  Int_t fRun; // run number
  UInt_t fStartTime; // start timestamp
  UInt_t fEndTime; // end timestamp
  // temperature stuff
  Double_t fMinTemp; // min temp
  Double_t fMaxTemp; // max temp
  Double_t fMinTempVariation; // min temp variation, within a sensor
  Double_t fMaxTempVariation; // max temp variation, within a sensor
  Double_t fMinTempValid; // min limit for when temp. readings appear valid
  Double_t fMaxTempValid; // max limit for when temp. readings appear valid
  UInt_t fMinTime; // min time
  UInt_t fMaxTime; // max time
  //
  Double_t fTemperatureResolution; // value for checking at which level we care about temperature differences
  Double_t fMaxTemperatureDiff; // value for checking that temperature sensor info seems reasonable 
  Int_t fTimeBinsPerHour; // size of the time-bins we use for corrections

  Double_t fHighLowGainFactor;     //gain factor to convert between high and low gain
  
  // pointers to the different used classes
  AliEMCALSensorTempArray  *fTempArray;     // CDB class for temperature sensors
  AliCaloCalibSignal *fCalibSignal; // LED signal info
  AliEMCALCalibTempCoeff *fCalibTempCoeff; // Temperature Coefficient info
  AliEMCALCalibReference *fCalibReference; // reference info
  AliEMCALCalibTimeDepCorrection *fCalibTimeDepCorrection; // correction values

  Int_t fVerbosity; // debug flag

  //
  ClassDef(AliEMCALCalibTimeDep,5)    // EMCAL time-dep Calibration data
};

#endif
Commit	Line	Data
	1	#ifndef ALIEMCALCALIBTIMEDEP_H
	2	#define ALIEMCALCALIBTIMEDEP_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: AliEMCALCalibTimeDep.h $ */
	8
	9	/////////////////////////////////////////////////
	10	// class for EMCAL time-dependence calibration //
	11	/////////////////////////////////////////////////
	12
	13	#include "TObject.h"
	14
	15	class AliEMCALSensorTempArray;
	16	class AliCaloCalibSignal;
	17	class AliEMCALCalibTempCoeff;
	18	class AliEMCALCalibReference;
	19	class AliEMCALCalibTimeDepCorrection;
	20
	21	class AliEMCALCalibTimeDep : public TObject {
	22
	23	public:
	24	AliEMCALCalibTimeDep(); //! ctor
	25	AliEMCALCalibTimeDep(const AliEMCALCalibTimeDep &calibt); //! copy ctor
	26	AliEMCALCalibTimeDep& operator= (const AliEMCALCalibTimeDep &calibt); //!
	27	virtual ~AliEMCALCalibTimeDep(); //! dtor
	28	virtual void PrintInfo() const;
	29
	30	void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);//!
	31
	32	// simple getters
	33	Int_t GetRunNumber() const { return fRun; } //
	34	UInt_t GetStartTime() const { return fStartTime; } //
	35	UInt_t GetEndTime() const { return fEndTime; } //
	36	Double_t GetLengthOfRunInHours() const; //
	37	Double_t GetLengthOfRunInBins() const; //
	38
	39	// Temperature Section
	40	// access pointer to the basic temperature object: AliEMCALSensorTempArray
	41	AliEMCALSensorTempArray * GetTempArray() const { return fTempArray; } // temperature array
	42
	43	// range of temperature readings/values during the run
	44	Int_t ScanTemperatureInfo(); // go through the temperature info
	45	Double_t GetMinTemp() const { return fMinTemp; } //
	46	Double_t GetMaxTemp() const { return fMaxTemp; } //
	47	Double_t GetMinTempVariation() const { return fMinTempVariation; } //
	48	Double_t GetMaxTempVariation() const { return fMaxTempVariation; } //
	49	Double_t GetMinTempValid() const { return fMinTempValid; } //
	50	Double_t GetMaxTempValid() const { return fMaxTempValid; } //
	51	UInt_t GetMinTime() const { return fMinTime; } //
	52	UInt_t GetMaxTime() const { return fMaxTime; } //
	53	Double_t GetRangeOfTempMeasureInHours() const; //!
	54	Double_t GetRangeOfTempMeasureInDegrees() const; //!
	55
	56	// basic calibration info
	57	Double_t GetTemperatureSM(int imod, UInt_t timeStamp) const; // for all sensors, in a SuperModule
	58	// End of Temperature Section
	59
	60	// control parameters
	61	void SetTemperatureResolution(Double_t d) { fTemperatureResolution = d; } // value for checking at which level we care about temperature differences
	62	void SetMaxTemperatureDiff(Double_t d) { fMaxTemperatureDiff = d; }
	63	void SetTimeBinsPerHour(Int_t i) { fTimeBinsPerHour = i; } // size of the time-bins we use for corrections
	64	Double_t GetTemperatureResolution() const { return fTemperatureResolution; } // value for checking at which level we care about temperature differences
	65	Double_t GetMaxTemperatureDiff() const { return fMaxTemperatureDiff; }
	66	Int_t GetTimeBinsPerHour() const { return fTimeBinsPerHour; } // size of the time-bins we use foc corrections
	67
	68	void SetHighLowGainFactor(Double_t value) {fHighLowGainFactor = value;}
	69	Double_t GetHighLowGainFactor() const {return fHighLowGainFactor;}
	70
	71	// access to other pointers
	72	AliCaloCalibSignal * GetCalibSignal() const { return fCalibSignal; } //
	73	AliEMCALCalibTempCoeff * GetCalibTempCoeff() const { return fCalibTempCoeff; } //
	74	AliEMCALCalibReference * GetCalibReference() const { return fCalibReference; } //
	75
	76	// storage and access of the correction info
	77	Int_t CalcCorrection(); //
	78	AliEMCALCalibTimeDepCorrection * GetCalibTimeDepCorrection()
	79	const { return fCalibTimeDepCorrection; } //
	80
	81	Double_t GetTempCoeff(Double_t IDark, Double_t M) const; //
	82
	83	// for local debugging: setters of the main input pointers that are normally from OCDB
	84	void SetTempArray(AliEMCALSensorTempArray *arr) { fTempArray = arr; } //
	85	void SetCalibSignal(AliCaloCalibSignal *obj) { fCalibSignal = obj; } //
	86	void SetCalibTempCoeff(AliEMCALCalibTempCoeff *obj) { fCalibTempCoeff = obj; } //
	87	void SetCalibReference(AliEMCALCalibReference *obj) { fCalibReference = obj; } //
	88	// basic setters, also for local debugging
	89	void SetRunNumber(Int_t i) { fRun= i; } //
	90	void SetStartTime(UInt_t ui) { fStartTime = ui; } //
	91	void SetEndTime(UInt_t ui) { fEndTime = ui; } //
	92
	93	void SetMinTempValid(Double_t d) { fMinTempValid = d; } //
	94	void SetMaxTempValid(Double_t d) { fMaxTempValid = d; } //
	95
	96	Int_t GetVerbosity() const { return fVerbosity; } // debug flag
	97	void SetVerbosity(Int_t i) { fVerbosity= i; } // debug flag
	98
	99	private:
	100
	101	void Reset(); //
	102
	103	void GetTemperatureInfo(); // pick up Preprocessor output
	104	void GetCalibSignalInfo(); // pick up Preprocessor output
	105	void GetCalibTempCoeffInfo(); // pick up OCDB info
	106	void GetCalibReferenceInfo(); // pick up OCDB info
	107
	108	Int_t CalcLEDCorrection(Int_t nSM, Int_t nBins); // based on LED signals, and reference photodiodes
	109	Int_t CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins); // based on LED signals, and reference photodiodes
	110	Int_t CalcTemperatureCorrection(Int_t nSM, Int_t nBins, Int_t binSize); // based on temperature info
	111
	112	//
	113	Int_t fRun; // run number
	114	UInt_t fStartTime; // start timestamp
	115	UInt_t fEndTime; // end timestamp
	116	// temperature stuff
	117	Double_t fMinTemp; // min temp
	118	Double_t fMaxTemp; // max temp
	119	Double_t fMinTempVariation; // min temp variation, within a sensor
	120	Double_t fMaxTempVariation; // max temp variation, within a sensor
	121	Double_t fMinTempValid; // min limit for when temp. readings appear valid
	122	Double_t fMaxTempValid; // max limit for when temp. readings appear valid
	123	UInt_t fMinTime; // min time
	124	UInt_t fMaxTime; // max time
	125	//
	126	Double_t fTemperatureResolution; // value for checking at which level we care about temperature differences
	127	Double_t fMaxTemperatureDiff; // value for checking that temperature sensor info seems reasonable
	128	Int_t fTimeBinsPerHour; // size of the time-bins we use for corrections
	129
	130	Double_t fHighLowGainFactor; //gain factor to convert between high and low gain
	131
	132	// pointers to the different used classes
	133	AliEMCALSensorTempArray *fTempArray; // CDB class for temperature sensors
	134	AliCaloCalibSignal *fCalibSignal; // LED signal info
	135	AliEMCALCalibTempCoeff *fCalibTempCoeff; // Temperature Coefficient info
	136	AliEMCALCalibReference *fCalibReference; // reference info
	137	AliEMCALCalibTimeDepCorrection *fCalibTimeDepCorrection; // correction values
	138
	139	Int_t fVerbosity; // debug flag
	140
	141	//
	142	ClassDef(AliEMCALCalibTimeDep,5) // EMCAL time-dep Calibration data
	143	};
	144
	145	#endif