[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFillHisto.h

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

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  TRD calibration class for the HLT parameters                             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TObject
#  include <TObject.h>
#endif
#ifndef ROOT_TLinearFitter
#  include <TLinearFitter.h> 
#endif
#ifndef ROOT_TProfile2D
#  include <TProfile2D.h> 
#endif
#ifndef ROOT_TH2I
#  include <TH2I.h> 
#endif

class TProfile2D;
class TObjArray;
class TH1F;
class TH2I;
class TH2F;
class TH2;
class TLinearFitter;
class TTreeSRedirector;

class AliLog;
class AliRawReader;

class AliTRDCalibraMode;
class AliTRDCalibraVector;
class AliTRDCalibraVdriftLinearFit;
class AliTRDrawStreamBase;
class AliTRDcluster;
class AliTRDtrackV1;
class AliTRDtrack;
class AliTRDseedV1;
class AliTRDmcm;
class AliTRDmcmTracklet;
class AliTRDgeometry;
class AliTRDCalDet;
class AliTRDCalROC;


struct eventHeaderStruct;

class AliTRDCalibraFillHisto : public TObject {

 public: 

  // Instance
  static AliTRDCalibraFillHisto *Instance();
  static void Terminate();
  static void Destroy();
  void DestroyDebugStreamer();


  AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c);
  AliTRDCalibraFillHisto &operator=(const AliTRDCalibraFillHisto &) { return *this; }

  // Functions for initialising and filling with AliTRDtrackV1
          Bool_t  Init2Dhistos();
	  Bool_t  UpdateHistograms(AliTRDtrack *t);
	  Bool_t  UpdateHistogramsV1(AliTRDtrackV1 *t);
 
  // Process events DAQ
	  Int_t   ProcessEventDAQ(AliTRDrawStreamBase *rawStream, Bool_t nocheck = kFALSE);
	  Int_t   ProcessEventDAQ(AliRawReader *rawReader, Bool_t nocheck = kFALSE);
	  Int_t   ProcessEventDAQ(eventHeaderStruct *event, Bool_t nocheck = kFALSE);

	  Int_t   ProcessEventDAQV1(AliTRDrawStreamBase *rawStream, Bool_t nocheck = kFALSE);
	  Int_t   ProcessEventDAQV1(AliRawReader *rawReader, Bool_t nocheck = kFALSE);
	  Int_t   ProcessEventDAQV1(eventHeaderStruct *event, Bool_t nocheck = kFALSE);

  // Is Pad on
          Bool_t   IsPadOn(Int_t detector, Int_t row, Int_t col) const;

  // Functions for write
	  void     Write2d(const Char_t *filename = "TRD.calibration.root", Bool_t append = kFALSE);

  //For the statistics
	  Double_t *StatH(TH2 *ch, Int_t i);
	  Double_t *GetMeanMedianRMSNumberCH();
	  Double_t *GetMeanMedianRMSNumberLinearFitter() const;
       
     	 
  //
  // Set of Get the variables
  //

  // Choice to fill or not the 2D
          void     SetMcmCorrectAngle(Bool_t mcmcorrectangle = kTRUE)        { fMcmCorrectAngle = mcmcorrectangle;   }
          void     SetPH2dOn(Bool_t ph2don = kTRUE)                          { fPH2dOn          = ph2don;            }
          void     SetCH2dOn(Bool_t ch2don = kTRUE)                          { fCH2dOn          = ch2don;            }
          void     SetPRF2dOn(Bool_t prf2don = kTRUE)                        { fPRF2dOn         = prf2don;           }
          void     SetHisto2d(Bool_t histo2d = kTRUE)                        { fHisto2d         = histo2d;           }
          void     SetVector2d(Bool_t vector2d = kTRUE)                      { fVector2d        = vector2d;          }
	  void     SetLinearFitterOn(Bool_t linearfitteron = kTRUE)          { fLinearFitterOn      = linearfitteron;}
	  void     SetLinearFitterDebugOn(Bool_t debug = kTRUE)              { fLinearFitterDebugOn = debug;         }
	 	  
  
          Bool_t   GetMcmCorrectAngle() const                                { return fMcmCorrectAngle;        }
          Bool_t   GetPH2dOn() const                                         { return fPH2dOn;                 }
          Bool_t   GetCH2dOn() const                                         { return fCH2dOn;                 }
          Bool_t   GetPRF2dOn() const                                        { return fPRF2dOn;                }
          Bool_t   GetHisto2d() const                                        { return fHisto2d;                }
          Bool_t   GetVector2d() const                                       { return fVector2d;               }
          Bool_t   GetLinearFitterOn() const                                 { return fLinearFitterOn;         }
	  Bool_t   GetLinearFitterDebugOn() const                            { return fLinearFitterDebugOn; }


  // Get stuff that are filled
  TH2I            *GetCH2d();
  TProfile2D      *GetPH2d(Int_t nbtimebin=24, Float_t samplefrequency= 10.0);
  TProfile2D      *GetPRF2d() const                                          { return fPRF2d;                  } 
  TObjArray        GetLinearFitterArray() const                              { return fLinearFitterArray;      }
  TLinearFitter   *GetLinearFitter(Int_t detector, Bool_t force=kFALSE);
  AliTRDCalibraVdriftLinearFit *GetVdriftLinearFit() const                   { return fLinearVdriftFit;        }
  
 
  // How to fill the 2D
          void     SetRelativeScale(Float_t relativeScale);                      
          void     SetThresholdClusterPRF2(Float_t thresholdClusterPRF2)     { fThresholdClusterPRF2 = thresholdClusterPRF2; }
	  void     SetLimitChargeIntegration(Bool_t limitChargeIntegration)  { fLimitChargeIntegration = limitChargeIntegration; }
	  void     SetNz(Int_t i, Short_t nz);
          void     SetNrphi(Int_t i, Short_t nrphi);
          void     SetProcent(Float_t procent)                               { fProcent              = procent;              }
          void     SetDifference(Short_t difference)                         { fDifference           = difference;           }
          void     SetNumberClusters(Short_t numberClusters)                 { fNumberClusters       = numberClusters;       }
	  void     SetNumberClustersf(Short_t numberClustersf)               { fNumberClustersf      = numberClustersf;      }
          void     SetNumberBinCharge(Short_t numberBinCharge)               { fNumberBinCharge      = numberBinCharge;      }
          void     SetNumberBinPRF(Short_t numberBinPRF)                     { fNumberBinPRF         = numberBinPRF;         }
	  void     SetNumberGroupsPRF(Short_t numberGroupsPRF);
  
          Float_t  GetRelativeScale() const                                  { return fRelativeScale;          }
          Float_t  GetThresholdClusterPRF2() const                           { return fThresholdClusterPRF2;   }
	  Bool_t   GetLimitChargeIntegration() const                         { return fLimitChargeIntegration; }
	  Float_t  GetProcent() const                                        { return fProcent;                }
          Short_t  GetDifference() const                                     { return fDifference;             }
          Short_t  GetNumberClusters() const                                 { return fNumberClusters;         }
	  Short_t  GetNumberClustersf() const                                { return fNumberClustersf;        }
          Short_t  GetNumberBinCharge() const                                { return fNumberBinCharge;        }
          Short_t  GetNumberBinPRF() const                                   { return fNumberBinPRF;           }
	  Short_t  GetNumberGroupsPRF() const                                { return fNgroupprf;              }
	  Int_t    *GetEntriesLinearFitter() const                           { return fEntriesLinearFitter;    }

 // Debug
          void     SetDebugLevel(Short_t level)                              { fDebugLevel = level;           }

  // Vector method
AliTRDCalibraVector *GetCalibraVector() const                                { return fCalibraVector;          }   
  
 protected:

  // Geometry
  AliTRDgeometry  *fGeo;                    //! The TRD geometry

  // Choice to fill or not the 2D
          Bool_t   fMcmCorrectAngle;        // Apply correction due to the mcmtrackletangle in the z direction (only) assuming  from vertex
          Bool_t   fCH2dOn;                 // Chose to fill the 2D histos or vectors for the relative gain calibration 
          Bool_t   fPH2dOn;                 // Chose to fill the 2D histos or vectors for the drift velocity and T0
          Bool_t   fPRF2dOn;                // Chose to fill the 2D histos or vectors for the pad response function calibration
          Bool_t   fHisto2d;                // Chose to fill the 2D histos
          Bool_t   fVector2d;               // Chose to fill vectors
	  Bool_t   fLinearFitterOn;         // Method with linear fit for drift velocity
	  Bool_t   fLinearFitterDebugOn;    // Method with linear fit for drift velocity

  // How to fill the 2D
          Float_t  fRelativeScale;          // Scale of the deposited charge
          Float_t  fThresholdClusterPRF2;   // Threshold on cluster pad signals
          Bool_t   fLimitChargeIntegration; // Integration range for the gain calibration
  // Calibration mode
	  AliTRDCalibraMode *fCalibraMode;  // Calibration mode

  //For debugging
	  TTreeSRedirector          *fDebugStreamer;                 //!Debug streamer
          Short_t     fDebugLevel;                                   // Flag for debugging
  //
  // Internal variables
  //

  // Fill the 2D histos in the offline tracking
	  Int_t    fDetectorPreviousTrack;  // Change of detector
	  Int_t    fMCMPrevious;            // Change of MCM
	  Int_t    fROBPrevious;            // Change of ROB
	  Short_t  fNumberClusters;         // Minimum number of clusters in the tracklets
	  Short_t  fNumberClustersf;        // Maximum number of clusters in the tracklets
          Float_t  fProcent;                // Limit to take the info of the most important calibration group if the track goes through 2 groups (CH)
          Short_t  fDifference;             // Limit to take the info of the most important calibration group if the track goes through 2 groups (CH)
          Int_t    fNumberTrack;            // How many tracks could be used (Debug for the moment)
          Int_t    fNumberUsedCh[2];        // How many tracks have been really used for the gain (0, strict; 1 with fProcent)
          Int_t    fNumberUsedPh[2];        // How many tracks have been really used for the drift velocity (0, strict; 1 with fDifference)
	  Int_t    fTimeMax;                // Number of time bins
          Float_t  fSf;                     // Sampling frequence
	  Short_t  fNumberBinCharge;        // Number of bins for the gain factor
	  Short_t  fNumberBinPRF;           // Number of bin for the PRF
	  Short_t  fNgroupprf;              // Number of groups in tnp bins for PRF /2.0

  // Variables per tracklet
	  Float_t       *fAmpTotal;                  // Energy deposited in the calibration group by the track
          Short_t       *fPHPlace;                   // Calibration group of PH
          Float_t       *fPHValue;                   // PH
	  Bool_t         fGoodTracklet;              // Good tracklet
  //Statistics
	  Int_t         *fEntriesCH;                 // Number of entries CH
	  Int_t         *fEntriesLinearFitter;       // Number of entries LinearFitter


  //
  // Vector method
  //
  	  
	  AliTRDCalibraVector *fCalibraVector; // The vector object
 
 
  // Histograms to store the info from the digits, from the tracklets or from the tracks
	  TProfile2D      *fPH2d;                         // 2D average pulse height
	  TProfile2D      *fPRF2d;                        // 2D PRF
	  TH2I            *fCH2d;                         // 2D deposited charge
	  TObjArray       fLinearFitterArray;             // TObjArray of Linear Fitters for the detectors 
	  AliTRDCalibraVdriftLinearFit *fLinearVdriftFit; // Info Linear Fit
	  
 // Current calib object: to correct for the database used
	  AliTRDCalDet *fCalDetGain;                      // Current calib object gain
	  AliTRDCalROC *fCalROCGain;                      // Current calib object gain
	   
  //
  // A lot of internal functions......
  //
  // Create the 2D histo to be filled Online
          void     CreateCH2d(Int_t nn);
          void     CreatePH2d(Int_t nn);
          void     CreatePRF2d(Int_t nn);
  
  // Calibration with AliTRDtrackV1
          void     FillTheInfoOfTheTrackPH();
          void     FillTheInfoOfTheTrackCH(Int_t nbclusters);
	  Bool_t   FindP1TrackPHtracklet(AliTRDtrack *t, Int_t index0, Int_t index1);
	  Bool_t   FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
	  Bool_t   HandlePRFtracklet(AliTRDtrack *t, Int_t index0, Int_t index1);
	  Bool_t   HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
	  void     ResetfVariablestracklet();
	  void     StoreInfoCHPHtrack(AliTRDcluster *cl, Double_t dqdl, Int_t *group, Int_t row, Int_t col);
	  void     FillCH2d(Int_t x, Float_t y);

  // Calibration on DAQ

	  Int_t    FillDAQ(Double_t phvalue[16][144][36]);
	  Int_t    FillDAQ(AliTRDmcm *mcm);
	  Int_t    TestTracklet( Int_t idet, Int_t row, Int_t iSeed, AliTRDmcm *mcm);
	  Bool_t   UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Float_t signal, Int_t nbtimebins);
	  Int_t    UpdateHistogramcm(AliTRDmcmTracklet *trk);

  // row col calibration groups stuff
          Bool_t   LocalisationDetectorXbins(Int_t detector);
	  Int_t    CalculateTotalNumberOfBins(Int_t i);
	  void     CheckGoodTrackletV0(Int_t detector, Int_t row, Int_t col);
	  void     CheckGoodTrackletV1(AliTRDcluster *cl);
	  Int_t    CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const;
 
  // LinearFitter
	  void     AnalyseLinearFitter();
	  
  // Clear
          void     ClearHistos();
      
  // Some basic geometry function
  virtual Int_t    GetPlane(Int_t d) const;
  virtual Int_t    GetChamber(Int_t d) const;
  virtual Int_t    GetSector(Int_t d) const;
	  
          
  // Instance of this class and so on
  static  AliTRDCalibraFillHisto *fgInstance;                // Instance
  static  Bool_t   fgTerminated;                             // If terminated

 private:
  
  // This is a singleton, contructor is private!
  AliTRDCalibraFillHisto();
  virtual ~AliTRDCalibraFillHisto(); 
    
  ClassDef(AliTRDCalibraFillHisto,4)                         // TRD Calibration class

};
  
#endif
Commit	Line	Data
55a288e5	1	#ifndef ALITRDCALIBRAFILLHISTO_H
bcb6fb78	2	#define ALITRDCALIBRAFILLHISTOs_H
55a288e5	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	///////////////////////////////////////////////////////////////////////////////
	9	// //
	10	// TRD calibration class for the HLT parameters //
	11	// //
	12	///////////////////////////////////////////////////////////////////////////////
	13
	14	#ifndef ROOT_TObject
	15	# include <TObject.h>
	16	#endif
170c35f1	17	#ifndef ROOT_TLinearFitter
	18	# include <TLinearFitter.h>
	19	#endif
	20	#ifndef ROOT_TProfile2D
	21	# include <TProfile2D.h>
	22	#endif
	23	#ifndef ROOT_TH2I
	24	# include <TH2I.h>
	25	#endif
55a288e5	26
55a288e5	27	class TProfile2D;
55a288e5	28	class TObjArray;
	29	class TH1F;
	30	class TH2I;
170c35f1	31	class TH2F;
55a288e5	32	class TH2;
170c35f1	33	class TLinearFitter;
3a0f6479	34	class TTreeSRedirector;
55a288e5	35
55a288e5	36	class AliLog;
f162af62	37	class AliRawReader;
f162af62	38
55a288e5	39	class AliTRDCalibraMode;
55a288e5	40	class AliTRDCalibraVector;
3a0f6479	41	class AliTRDCalibraVdriftLinearFit;
b70c68da	42	class AliTRDrawStreamBase;
55a288e5	43	class AliTRDcluster;
bcb6fb78	44	class AliTRDtrackV1;
55a288e5	45	class AliTRDtrack;
bcb6fb78	46	class AliTRDseedV1;
bcb6fb78	47	class AliTRDmcm;
55a288e5	48	class AliTRDmcmTracklet;
f162af62	49	class AliTRDgeometry;
d0569428	50	class AliTRDCalDet;
	51	class AliTRDCalROC;
	52
170c35f1	53
170c35f1	54	struct eventHeaderStruct;
55a288e5	55
	56	class AliTRDCalibraFillHisto : public TObject {
	57
	58	public:
	59
	60	// Instance
	61	static AliTRDCalibraFillHisto *Instance();
	62	static void Terminate();
	63	static void Destroy();
bcb6fb78	64	void DestroyDebugStreamer();
bcb6fb78	65
55a288e5	66
	67	AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c);
	68	AliTRDCalibraFillHisto &operator=(const AliTRDCalibraFillHisto &) { return *this; }
	69
bcb6fb78	70	// Functions for initialising and filling with AliTRDtrackV1
	71	Bool_t Init2Dhistos();
	72	Bool_t UpdateHistograms(AliTRDtrack *t);
	73	Bool_t UpdateHistogramsV1(AliTRDtrackV1 *t);
55a288e5	74
3a0f6479	75	// Process events DAQ
b70c68da	76	Int_t ProcessEventDAQ(AliTRDrawStreamBase *rawStream, Bool_t nocheck = kFALSE);
3a0f6479	77	Int_t ProcessEventDAQ(AliRawReader *rawReader, Bool_t nocheck = kFALSE);
3a0f6479	78	Int_t ProcessEventDAQ(eventHeaderStruct *event, Bool_t nocheck = kFALSE);
170c35f1	79
b70c68da	80	Int_t ProcessEventDAQV1(AliTRDrawStreamBase *rawStream, Bool_t nocheck = kFALSE);
bcb6fb78	81	Int_t ProcessEventDAQV1(AliRawReader *rawReader, Bool_t nocheck = kFALSE);
bcb6fb78	82	Int_t ProcessEventDAQV1(eventHeaderStruct *event, Bool_t nocheck = kFALSE);
170c35f1	83
55a288e5	84	// Is Pad on
bcb6fb78	85	Bool_t IsPadOn(Int_t detector, Int_t row, Int_t col) const;
55a288e5	86
170c35f1	87	// Functions for write
	88	void Write2d(const Char_t *filename = "TRD.calibration.root", Bool_t append = kFALSE);
	89
55a288e5	90	//For the statistics
55a288e5	91	Double_t StatH(TH2 ch, Int_t i);
170c35f1	92	Double_t *GetMeanMedianRMSNumberCH();
	93	Double_t *GetMeanMedianRMSNumberLinearFitter() const;
	94
55a288e5	95
	96	//
	97	// Set of Get the variables
	98	//
	99
	100	// Choice to fill or not the 2D
3a0f6479	101	void SetMcmCorrectAngle(Bool_t mcmcorrectangle = kTRUE) { fMcmCorrectAngle = mcmcorrectangle; }
	102	void SetPH2dOn(Bool_t ph2don = kTRUE) { fPH2dOn = ph2don; }
	103	void SetCH2dOn(Bool_t ch2don = kTRUE) { fCH2dOn = ch2don; }
	104	void SetPRF2dOn(Bool_t prf2don = kTRUE) { fPRF2dOn = prf2don; }
	105	void SetHisto2d(Bool_t histo2d = kTRUE) { fHisto2d = histo2d; }
	106	void SetVector2d(Bool_t vector2d = kTRUE) { fVector2d = vector2d; }
	107	void SetLinearFitterOn(Bool_t linearfitteron = kTRUE) { fLinearFitterOn = linearfitteron;}
	108	void SetLinearFitterDebugOn(Bool_t debug = kTRUE) { fLinearFitterDebugOn = debug; }
	109
55a288e5	110
55a288e5	111	Bool_t GetMcmCorrectAngle() const { return fMcmCorrectAngle; }
	112	Bool_t GetPH2dOn() const { return fPH2dOn; }
	113	Bool_t GetCH2dOn() const { return fCH2dOn; }
	114	Bool_t GetPRF2dOn() const { return fPRF2dOn; }
	115	Bool_t GetHisto2d() const { return fHisto2d; }
	116	Bool_t GetVector2d() const { return fVector2d; }
3a0f6479	117	Bool_t GetLinearFitterOn() const { return fLinearFitterOn; }
bcb6fb78	118	Bool_t GetLinearFitterDebugOn() const { return fLinearFitterDebugOn; }
	119
	120
	121	// Get stuff that are filled
	122	TH2I *GetCH2d();
3a0f6479	123	TProfile2D *GetPH2d(Int_t nbtimebin=24, Float_t samplefrequency= 10.0);
170c35f1	124	TProfile2D *GetPRF2d() const { return fPRF2d; }
	125	TObjArray GetLinearFitterArray() const { return fLinearFitterArray; }
	126	TLinearFitter *GetLinearFitter(Int_t detector, Bool_t force=kFALSE);
d0569428	127	AliTRDCalibraVdriftLinearFit *GetVdriftLinearFit() const { return fLinearVdriftFit; }
3a0f6479	128
170c35f1	129
55a288e5	130	// How to fill the 2D
55a288e5	131	void SetRelativeScale(Float_t relativeScale);
55a288e5	132	void SetThresholdClusterPRF2(Float_t thresholdClusterPRF2) { fThresholdClusterPRF2 = thresholdClusterPRF2; }
b70c68da	133	void SetLimitChargeIntegration(Bool_t limitChargeIntegration) { fLimitChargeIntegration = limitChargeIntegration; }
170c35f1	134	void SetNz(Int_t i, Short_t nz);
55a288e5	135	void SetNrphi(Int_t i, Short_t nrphi);
	136	void SetProcent(Float_t procent) { fProcent = procent; }
	137	void SetDifference(Short_t difference) { fDifference = difference; }
	138	void SetNumberClusters(Short_t numberClusters) { fNumberClusters = numberClusters; }
bcb6fb78	139	void SetNumberClustersf(Short_t numberClustersf) { fNumberClustersf = numberClustersf; }
55a288e5	140	void SetNumberBinCharge(Short_t numberBinCharge) { fNumberBinCharge = numberBinCharge; }
55a288e5	141	void SetNumberBinPRF(Short_t numberBinPRF) { fNumberBinPRF = numberBinPRF; }
170c35f1	142	void SetNumberGroupsPRF(Short_t numberGroupsPRF);
55a288e5	143
55a288e5	144	Float_t GetRelativeScale() const { return fRelativeScale; }
55a288e5	145	Float_t GetThresholdClusterPRF2() const { return fThresholdClusterPRF2; }
b70c68da	146	Bool_t GetLimitChargeIntegration() const { return fLimitChargeIntegration; }
55a288e5	147	Float_t GetProcent() const { return fProcent; }
	148	Short_t GetDifference() const { return fDifference; }
	149	Short_t GetNumberClusters() const { return fNumberClusters; }
bcb6fb78	150	Short_t GetNumberClustersf() const { return fNumberClustersf; }
55a288e5	151	Short_t GetNumberBinCharge() const { return fNumberBinCharge; }
55a288e5	152	Short_t GetNumberBinPRF() const { return fNumberBinPRF; }
170c35f1	153	Short_t GetNumberGroupsPRF() const { return fNgroupprf; }
170c35f1	154	Int_t *GetEntriesLinearFitter() const { return fEntriesLinearFitter; }
55a288e5	155
170c35f1	156	// Debug
	157	void SetDebugLevel(Short_t level) { fDebugLevel = level; }
	158
	159	// Vector method
55a288e5	160	AliTRDCalibraVector *GetCalibraVector() const { return fCalibraVector; }
e4db522f	161
55a288e5	162	protected:
55a288e5	163
f162af62	164	// Geometry
	165	AliTRDgeometry *fGeo; //! The TRD geometry
	166
55a288e5	167	// Choice to fill or not the 2D
55a288e5	168	Bool_t fMcmCorrectAngle; // Apply correction due to the mcmtrackletangle in the z direction (only) assuming from vertex
	169	Bool_t fCH2dOn; // Chose to fill the 2D histos or vectors for the relative gain calibration
	170	Bool_t fPH2dOn; // Chose to fill the 2D histos or vectors for the drift velocity and T0
	171	Bool_t fPRF2dOn; // Chose to fill the 2D histos or vectors for the pad response function calibration
	172	Bool_t fHisto2d; // Chose to fill the 2D histos
	173	Bool_t fVector2d; // Chose to fill vectors
170c35f1	174	Bool_t fLinearFitterOn; // Method with linear fit for drift velocity
170c35f1	175	Bool_t fLinearFitterDebugOn; // Method with linear fit for drift velocity
55a288e5	176
	177	// How to fill the 2D
	178	Float_t fRelativeScale; // Scale of the deposited charge
170c35f1	179	Float_t fThresholdClusterPRF2; // Threshold on cluster pad signals
b70c68da	180	Bool_t fLimitChargeIntegration; // Integration range for the gain calibration
170c35f1	181	// Calibration mode
55a288e5	182	AliTRDCalibraMode *fCalibraMode; // Calibration mode
55a288e5	183
170c35f1	184	//For debugging
	185	TTreeSRedirector *fDebugStreamer; //!Debug streamer
	186	Short_t fDebugLevel; // Flag for debugging
55a288e5	187	//
	188	// Internal variables
	189	//
	190
	191	// Fill the 2D histos in the offline tracking
170c35f1	192	Int_t fDetectorPreviousTrack; // Change of detector
e4db522f	193	Int_t fMCMPrevious; // Change of MCM
e4db522f	194	Int_t fROBPrevious; // Change of ROB
170c35f1	195	Short_t fNumberClusters; // Minimum number of clusters in the tracklets
bcb6fb78	196	Short_t fNumberClustersf; // Maximum number of clusters in the tracklets
55a288e5	197	Float_t fProcent; // Limit to take the info of the most important calibration group if the track goes through 2 groups (CH)
	198	Short_t fDifference; // Limit to take the info of the most important calibration group if the track goes through 2 groups (CH)
	199	Int_t fNumberTrack; // How many tracks could be used (Debug for the moment)
	200	Int_t fNumberUsedCh[2]; // How many tracks have been really used for the gain (0, strict; 1 with fProcent)
	201	Int_t fNumberUsedPh[2]; // How many tracks have been really used for the drift velocity (0, strict; 1 with fDifference)
	202	Int_t fTimeMax; // Number of time bins
	203	Float_t fSf; // Sampling frequence
	204	Short_t fNumberBinCharge; // Number of bins for the gain factor
	205	Short_t fNumberBinPRF; // Number of bin for the PRF
170c35f1	206	Short_t fNgroupprf; // Number of groups in tnp bins for PRF /2.0
	207
	208	// Variables per tracklet
170c35f1	209	Float_t *fAmpTotal; // Energy deposited in the calibration group by the track
	210	Short_t *fPHPlace; // Calibration group of PH
	211	Float_t *fPHValue; // PH
	212	Bool_t fGoodTracklet; // Good tracklet
bcb6fb78	213	//Statistics
170c35f1	214	Int_t *fEntriesCH; // Number of entries CH
	215	Int_t *fEntriesLinearFitter; // Number of entries LinearFitter
	216
55a288e5	217
	218	//
	219	// Vector method
	220	//
d0569428	221
d0569428	222	AliTRDCalibraVector *fCalibraVector; // The vector object
55a288e5	223
	224
	225	// Histograms to store the info from the digits, from the tracklets or from the tracks
d0569428	226	TProfile2D *fPH2d; // 2D average pulse height
	227	TProfile2D *fPRF2d; // 2D PRF
	228	TH2I *fCH2d; // 2D deposited charge
	229	TObjArray fLinearFitterArray; // TObjArray of Linear Fitters for the detectors
	230	AliTRDCalibraVdriftLinearFit *fLinearVdriftFit; // Info Linear Fit
	231
	232	// Current calib object: to correct for the database used
	233	AliTRDCalDet *fCalDetGain; // Current calib object gain
	234	AliTRDCalROC *fCalROCGain; // Current calib object gain
bcb6fb78	235
55a288e5	236	//
	237	// A lot of internal functions......
	238	//
55a288e5	239	// Create the 2D histo to be filled Online
	240	void CreateCH2d(Int_t nn);
	241	void CreatePH2d(Int_t nn);
3a0f6479	242	void CreatePRF2d(Int_t nn);
55a288e5	243
bcb6fb78	244	// Calibration with AliTRDtrackV1
55a288e5	245	void FillTheInfoOfTheTrackPH();
bcb6fb78	246	void FillTheInfoOfTheTrackCH(Int_t nbclusters);
	247	Bool_t FindP1TrackPHtracklet(AliTRDtrack *t, Int_t index0, Int_t index1);
	248	Bool_t FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
	249	Bool_t HandlePRFtracklet(AliTRDtrack *t, Int_t index0, Int_t index1);
	250	Bool_t HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
	251	void ResetfVariablestracklet();
	252	void StoreInfoCHPHtrack(AliTRDcluster cl, Double_t dqdl, Int_t group, Int_t row, Int_t col);
170c35f1	253	void FillCH2d(Int_t x, Float_t y);
bcb6fb78	254
	255	// Calibration on DAQ
	256
	257	Int_t FillDAQ(Double_t phvalue[16][144][36]);
	258	Int_t FillDAQ(AliTRDmcm *mcm);
	259	Int_t TestTracklet( Int_t idet, Int_t row, Int_t iSeed, AliTRDmcm *mcm);
	260	Bool_t UpdateDAQ(Int_t det, Int_t /row/, Int_t /col/, Int_t timebin, Float_t signal, Int_t nbtimebins);
	261	Int_t UpdateHistogramcm(AliTRDmcmTracklet *trk);
	262
	263	// row col calibration groups stuff
55a288e5	264	Bool_t LocalisationDetectorXbins(Int_t detector);
170c35f1	265	Int_t CalculateTotalNumberOfBins(Int_t i);
d95484e4	266	void CheckGoodTrackletV0(Int_t detector, Int_t row, Int_t col);
d95484e4	267	void CheckGoodTrackletV1(AliTRDcluster *cl);
bcb6fb78	268	Int_t CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const;
3a0f6479	269
	270	// LinearFitter
	271	void AnalyseLinearFitter();
170c35f1	272
55a288e5	273	// Clear
	274	void ClearHistos();
	275
	276	// Some basic geometry function
	277	virtual Int_t GetPlane(Int_t d) const;
	278	virtual Int_t GetChamber(Int_t d) const;
	279	virtual Int_t GetSector(Int_t d) const;
d0569428	280
bcb6fb78	281
55a288e5	282	// Instance of this class and so on
170c35f1	283	static AliTRDCalibraFillHisto *fgInstance; // Instance
170c35f1	284	static Bool_t fgTerminated; // If terminated
0c349049	285
0c349049	286	private:
	287
	288	// This is a singleton, contructor is private!
	289	AliTRDCalibraFillHisto();
e4db522f	290	virtual ~AliTRDCalibraFillHisto();
55a288e5	291
e4db522f	292	ClassDef(AliTRDCalibraFillHisto,4) // TRD Calibration class
55a288e5	293
	294	};
	295
	296	#endif
	297
	298