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

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

/* $Id$ */

/////////////////////////////////////////////
//                                   	   //
//       class for ZDC reconstruction      //
//                                   	   //
/////////////////////////////////////////////

#include "AliReconstructor.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliZDCPedestals.h"
#include "AliZDCEnCalib.h"
#include "AliZDCTowerCalib.h"
#include "AliZDCMBCalib.h"
#include "AliZDCRecoParam.h"
#include "AliZDCRecoParampp.h"
#include "AliZDCRecoParamPbPb.h"
#include "AliLog.h"

class AliLoader;

class AliZDCReconstructor: public AliReconstructor {
public:
  AliZDCReconstructor();
  virtual ~AliZDCReconstructor();

  virtual void   Init();
  virtual Bool_t HasDigitConversion() const {return kFALSE;};
  
  virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; 
  virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;

  virtual void FillESD(TTree* /*digitsTree*/, TTree* clustersTree, AliESDEvent* esd) const 
  	        {FillZDCintoESD(clustersTree, esd);}
  virtual void FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, AliESDEvent* esd) const 
  	        {FillZDCintoESD(clustersTree, esd);}
  
  // parameter settings for reconstruction
  void SetRecoMode(Int_t recoMode, Float_t beamEnergy) 
  		  {fRecoMode=recoMode; fBeamEnergy=beamEnergy;}
  static void SetRecoParam(AliZDCRecoParam * param){fRecoParam = param;}
  
  Int_t   GetRecoMode() {return fRecoMode;}
  Float_t GetBeamEnergy() {return fBeamEnergy;}
  
  static const AliZDCRecoParam* GetRecoParam() {return dynamic_cast<const AliZDCRecoParam*>(AliReconstructor::GetRecoParam(9));}
    
  void  SetPedSubMode(Int_t pedsubMode) {fPedSubMode=pedsubMode;}
  Int_t GetPedSubMode() {return fPedSubMode;}
  
  void    SetSignalThreshold(Float_t val) {fSignalThreshold=val;}
  Float_t GetSignalThreshold() {return fSignalThreshold;}
  
  // OCDB objects for reconstruction
  AliCDBStorage       *SetStorage(const char* uri);
  AliZDCPedestals     *GetPedestalData() const; 
  AliZDCEnCalib       *GetEnergyCalibData() const; 
  AliZDCTowerCalib    *GetTowerCalibData() const; 
  AliZDCMBCalib       *GetMBCalibData() const; 
  AliZDCRecoParampp   *GetppRecoParamFromOCDB() const;  
  AliZDCRecoParamPbPb *GetPbPbRecoParamFromOCDB() const;  
  
private:
  AliZDCReconstructor(const AliZDCReconstructor&); //Not implemented
  AliZDCReconstructor& operator =(const AliZDCReconstructor&); //Not implemented

  void   ReconstructEventpp(TTree *clustersTree, 
  	    Float_t* ZN1ADCCorr, Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr,
	    Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2,
	    Bool_t isScalerOn, UInt_t* scaler, 
	    Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const;
  void   ReconstructEventPbPb(TTree *clustersTree, 
  	    Float_t* ZN1ADCCorr, Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr,
	    Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2,
	    Bool_t isScalerOn, UInt_t* scaler, 
	    Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const;
  
  void   FillZDCintoESD(TTree *clustersTree, AliESDEvent*esd) const;

  static AliZDCRecoParam *fRecoParam; // reconstruction parameters

  static AliZDCMBCalib   *fMBCalibData;   //! mb calibration data
  AliZDCPedestals  *fPedData; 	    	  //! pedestal calibration data
  AliZDCEnCalib    *fEnCalibData;   	  //! energy calibration data
  AliZDCTowerCalib *fTowCalibData;  	  //! equalization calibration data
  
  Int_t   fRecoMode;	    // =1->p-p, =2->A-A
  Float_t fBeamEnergy;	    // beam energy
  Int_t	  fNRun;	    // Run Number (from raw data)
  Bool_t  fIsCalibrationMB; // true if run type = "CALIBRATION_MB"
  Int_t   fPedSubMode;	    // =0->mean values, =1->from correlations
  Float_t fSignalThreshold; // Threshold value for "triggering" in p-p

  ClassDef(AliZDCReconstructor, 10)   // class for the ZDC reconstruction
};

#endif
Commit	Line	Data
8309c1ab	1	#ifndef ALIZDCRECONSTRUCTOR_H
	2	#define ALIZDCRECONSTRUCTOR_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
58671297	8	/////////////////////////////////////////////
	9	// //
	10	// class for ZDC reconstruction //
	11	// //
	12	/////////////////////////////////////////////
8309c1ab	13
8309c1ab	14	#include "AliReconstructor.h"
48642b09	15	#include "AliCDBManager.h"
48642b09	16	#include "AliCDBStorage.h"
6024ec85	17	#include "AliZDCPedestals.h"
73bc3a3f	18	#include "AliZDCEnCalib.h"
73bc3a3f	19	#include "AliZDCTowerCalib.h"
0d579f58	20	#include "AliZDCMBCalib.h"
7bff3766	21	#include "AliZDCRecoParam.h"
	22	#include "AliZDCRecoParampp.h"
	23	#include "AliZDCRecoParamPbPb.h"
70f04f6d	24	#include "AliLog.h"
8309c1ab	25
8309c1ab	26	class AliLoader;
8309c1ab	27
8309c1ab	28	class AliZDCReconstructor: public AliReconstructor {
	29	public:
	30	AliZDCReconstructor();
	31	virtual ~AliZDCReconstructor();
	32
73bc3a3f	33	virtual void Init();
a4cab348	34	virtual Bool_t HasDigitConversion() const {return kFALSE;};
73bc3a3f	35
1e319f71	36	virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
1e319f71	37	virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
70f04f6d	38
70f04f6d	39	virtual void FillESD(TTree* /digitsTree/, TTree* clustersTree, AliESDEvent* esd) const
73bc3a3f	40	{FillZDCintoESD(clustersTree, esd);}
70f04f6d	41	virtual void FillESD(AliRawReader* /rawReader/, TTree* clustersTree, AliESDEvent* esd) const
73bc3a3f	42	{FillZDCintoESD(clustersTree, esd);}
73bc3a3f	43
7bff3766	44	// parameter settings for reconstruction
03be9e4f	45	void SetRecoMode(Int_t recoMode, Float_t beamEnergy)
73bc3a3f	46	{fRecoMode=recoMode; fBeamEnergy=beamEnergy;}
7bff3766	47	static void SetRecoParam(AliZDCRecoParam * param){fRecoParam = param;}
fd9afd60	48
fd9afd60	49	Int_t GetRecoMode() {return fRecoMode;}
42d8b8d5	50	Float_t GetBeamEnergy() {return fBeamEnergy;}
42d8b8d5	51
4a72fbdb	52	static const AliZDCRecoParam* GetRecoParam() {return dynamic_cast<const AliZDCRecoParam*>(AliReconstructor::GetRecoParam(9));}
81f09162	53
42d8b8d5	54	void SetPedSubMode(Int_t pedsubMode) {fPedSubMode=pedsubMode;}
42d8b8d5	55	Int_t GetPedSubMode() {return fPedSubMode;}
7bff3766	56
58671297	57	void SetSignalThreshold(Float_t val) {fSignalThreshold=val;}
	58	Float_t GetSignalThreshold() {return fSignalThreshold;}
	59
7bff3766	60	// OCDB objects for reconstruction
1e319f71	61	AliCDBStorage SetStorage(const char uri);
	62	AliZDCPedestals *GetPedestalData() const;
	63	AliZDCEnCalib *GetEnergyCalibData() const;
	64	AliZDCTowerCalib *GetTowerCalibData() const;
0d579f58	65	AliZDCMBCalib *GetMBCalibData() const;
73bc3a3f	66	AliZDCRecoParampp *GetppRecoParamFromOCDB() const;
73bc3a3f	67	AliZDCRecoParamPbPb *GetPbPbRecoParamFromOCDB() const;
646f1679	68
8309c1ab	69	private:
3abc001d	70	AliZDCReconstructor(const AliZDCReconstructor&); //Not implemented
3abc001d	71	AliZDCReconstructor& operator =(const AliZDCReconstructor&); //Not implemented
8309c1ab	72
7bff3766	73	void ReconstructEventpp(TTree *clustersTree,
7bff3766	74	Float_t* ZN1ADCCorr, Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr,
1e319f71	75	Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2,
81f09162	76	Bool_t isScalerOn, UInt_t* scaler,
81f09162	77	Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const;
7bff3766	78	void ReconstructEventPbPb(TTree *clustersTree,
c35ed519	79	Float_t* ZN1ADCCorr, Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr,
1e319f71	80	Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2,
81f09162	81	Bool_t isScalerOn, UInt_t* scaler,
81f09162	82	Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const;
1e319f71	83
73bc3a3f	84	void FillZDCintoESD(TTree clustersTree, AliESDEventesd) const;
7bff3766	85
73bc3a3f	86	static AliZDCRecoParam *fRecoParam; // reconstruction parameters
42d8b8d5	87
91debfd4	88	static AliZDCMBCalib *fMBCalibData; //! mb calibration data
	89	AliZDCPedestals *fPedData; //! pedestal calibration data
	90	AliZDCEnCalib *fEnCalibData; //! energy calibration data
	91	AliZDCTowerCalib *fTowCalibData; //! equalization calibration data
73bc3a3f	92
	93	Int_t fRecoMode; // =1->p-p, =2->A-A
	94	Float_t fBeamEnergy; // beam energy
	95	Int_t fNRun; // Run Number (from raw data)
	96	Bool_t fIsCalibrationMB; // true if run type = "CALIBRATION_MB"
	97	Int_t fPedSubMode; // =0->mean values, =1->from correlations
58671297	98	Float_t fSignalThreshold; // Threshold value for "triggering" in p-p
73bc3a3f	99
0d579f58	100	ClassDef(AliZDCReconstructor, 10) // class for the ZDC reconstruction
8309c1ab	101	};
	102
	103	#endif