[u/mrichter/AliRoot.git] / TPC / TPCbase / AliTPCdataQA.h

/// \class AliTPCdataQA

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

#include <TBits.h>
#include <TH1F.h>
#include <TProfile.h>
#include <TProfile2D.h>
#include "AliRecoParam.h"

#include <TArray.h>

class TH2F;
class TTreeSRedirector;
class AliTPCROC;
class AliTPCCalROC;
class AliTPCRawStreamV3;
class AliRawReader;
class AliTPCAltroMapping;
class AliTPCCalPad;
class TMap;
class TObjArray;
struct eventHeaderStruct;

class AliTPCdataQA : public TH1F {

public:
  AliTPCdataQA();
  AliTPCdataQA(const AliTPCdataQA &ped);
  AliTPCdataQA(const TMap *config);
  virtual ~AliTPCdataQA();

  AliTPCdataQA& operator = (const  AliTPCdataQA &source);
 void  DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE);
 void MakeTree(const char *fname="QApad.root") const;

  //
  Bool_t ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3);
  Bool_t ProcessEvent(AliRawReader    *const rawReader);
  Bool_t ProcessEvent(eventHeaderStruct   *const event);

  void   Analyse();
  //
  //
  void SetPedestal(AliTPCCalPad *const pedestalCal){ fPedestal = pedestalCal;}
  void SetNoise(AliTPCCalPad *const noiseCal){ fNoise = noiseCal;}

  void SetMinQMax               (Float_t minQmax  ) { fMinQMax                = minQmax; }
  void SetRequireNeighbouringPad(Bool_t  req=kTRUE) { fRequireNeighbouringPad = req;     }

  // DQM methods
  void FillOccupancyProfile();
  void ResetProfiles();


  AliTPCCalPad *GetNoThreshold() const { return fNoThreshold;}
  AliTPCCalPad *GetMaxCharge() const { return fMaxCharge;}
  AliTPCCalPad *GetMeanCharge() const { return fMeanCharge;}
  AliTPCCalPad *GetNLocalMaxima() const { return fNLocalMaxima;}
  AliTPCCalPad *GetOverThreshold10() const { return fOverThreshold10;}
  AliTPCCalPad *GetOverThreshold20() const { return fOverThreshold20;}
  AliTPCCalPad *GetOverThreshold30() const { return fOverThreshold30;}
  AliTPCCalPad *GetNTimeBins() const { return fNTimeBins;}
  AliTPCCalPad *GetNPads() const { return fNPads;}
  AliTPCCalPad *GetTimePosition() const { return fTimePosition;}
  TProfile* GetHistQVsTimeSideA()    const {return fHistQVsTimeSideA;}
  TProfile* GetHistQVsTimeSideC()    const {return fHistQVsTimeSideC;}
  TProfile* GetHistQMaxVsTimeSideA() const {return fHistQMaxVsTimeSideA;}
  TProfile* GetHistQMaxVsTimeSideC() const {return fHistQMaxVsTimeSideC;}
  TH1F*     GetHistOccupancyVsEventConst() const {return fHistOccupancyVsEvent;}
  TH1F*     GetHistNclustersVsEventConst() const {return fHistNclustersVsEvent;}
  TH1F*     GetHistOccupancyVsEvent();
  TH1F*     GetHistNclustersVsEvent();

  // DQM output
  TProfile* GetHistOccVsSector()  const { return fHistOccVsSector; }
  TProfile2D* GetHistOcc2dVsSector() const { return fHistOcc2dVsSector; }
  TProfile* GetHistQVsSector()    const { return fHistQVsSector; }
  TProfile* GetHistQmaxVsSector() const { return fHistQmaxVsSector; }

  //
  AliTPCAltroMapping **GetAltroMapping() const { return fMapping; };
  void  SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; };
  //
  //
  Int_t  GetFirstTimeBin() const { return fFirstTimeBin; }
  Int_t  GetLastTimeBin()  const { return fLastTimeBin;  }
  Int_t  GetAdcMin()       const { return fAdcMin;       }
  Int_t  GetAdcMax()       const { return fAdcMax;       }
  Int_t  GetEventCounter() const { return fEventCounter; }
  Bool_t GetIsAnalysed()   const { return fIsAnalysed;   }
  Int_t  GetMaxEvents()      const { return fMaxEvents;     }
  Int_t  GetEventsPerBin()   const { return fEventsPerBin;  }
  Int_t  GetSignalCounter()  const { return fSignalCounter; }
  Int_t  GetClusterCounter() const { return fClusterCounter;}

  Float_t GetMinQMax()                const { return fMinQMax;                }
  Bool_t  GetRequireNeighbouringPad() const { return fRequireNeighbouringPad; }

  // DQM getter
  Bool_t    GetIsDQM() const { return fIsDQM; }

  void  SetRangeTime(Int_t tMin, Int_t tMax){ fFirstTimeBin=tMin; fLastTimeBin=tMax;}  // Set time bin range that is used for the pedestal calibration
  void  SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; }  // Set adc range for the pedestal calibration
  void  SetMaxEvents   (Int_t value) { fMaxEvents = value; }
  void  SetEventsPerBin(Int_t value) { fEventsPerBin = value; }

  // DQM setter
  void  SetIsDQM(Bool_t value) { fIsDQM = value; }

  void ResetData();

  void SetChamberStatus(UInt_t roc, Bool_t status) { fActiveChambers.SetBitNumber(roc,status); }
  Bool_t GetChamberStatus(UInt_t roc) {return fActiveChambers.TestBitNumber(roc);}
private:
  Int_t Update(const Int_t iSector, const Int_t iRow, const Int_t iPad,
	       const Int_t iTimeBin, Float_t signal,
	       const Int_t iPatch=-1, const Int_t iBranch=-1);
  void  FindLocalMaxima(const Int_t iSector);

  void MakeArrays();                // Create arrays for random data acces
  void CleanArrays();               // Clean arrays for random data acces
  void SetExpandDigit(const Int_t iRow, Int_t iPad, Int_t iTimeBin,
		      const Float_t signal); // Fill arrays with signals
  void GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin); // Get pad and time bin corresponding to the 1d bin
  Float_t GetQ(const Float_t* adcArray, const Int_t time,
	       const Int_t pad, const Int_t maxTimeBins,
	       Int_t& timeMin,Int_t& timeMax,Int_t& padMin,Int_t& padMax) const;
  void UpdateEventHistograms();

  void Init();

  TObjArray *ConfigArrRocs(TObjArray *arr, const Text_t* name);

  Int_t fFirstTimeBin;              ///< First Time bin needed for analysis
  Int_t fLastTimeBin;               ///< Last Time bin needed for analysis
  Int_t fAdcMin;                    ///< min adc channel of pedestal value
  Int_t fAdcMax;                    ///< max adc channel of pedestal value
  Float_t fMinQMax;                 ///< Minimun charge for Maximum ADC in cluster
  Bool_t fRequireNeighbouringPad;   ///< If clusterer should require a neighbouring pad to accept it


  AliTPCAltroMapping **fMapping;    //!< Altro Mapping object
  //
  //
  AliTPCCalPad * fPedestal;         //!< option to set pedestal cal object
  AliTPCCalPad * fNoise;            //!< option to set noise cal object
  AliTPCCalPad * fNLocalMaxima;     ///< local maximas found
  AliTPCCalPad * fMaxCharge;        ///< max charge
  AliTPCCalPad * fMeanCharge;       ///< mean charge
  AliTPCCalPad * fNoThreshold;      ///< number of digits
  AliTPCCalPad * fNTimeBins;        ///< timebins width of cluster
  AliTPCCalPad * fNPads;            ///< pads with of cluster
  AliTPCCalPad * fTimePosition;     ///< Time position of local maximum
  AliTPCCalPad * fOverThreshold10;  //!< local maxima with qMax over threshold
  AliTPCCalPad * fOverThreshold20;  //!< local maxima with qMax over threshold
  AliTPCCalPad * fOverThreshold30;  //!< local maxima with qMax over threshold

  TProfile* fHistQVsTimeSideA;      ///< Q vs time (side A)
  TProfile* fHistQVsTimeSideC;	    ///< Q vs time (side C)
  TProfile* fHistQMaxVsTimeSideA;   ///< QMax vs time (side A)
  TProfile* fHistQMaxVsTimeSideC;   ///< QMax vs time (side C)

  TH1F* fHistOccupancyVsEvent;      ///< Occupancy vs event number (~time)
  TH1F* fHistNclustersVsEvent;      ///< Nclusters vs event number (~time)

  Int_t   fEventCounter;            ///< event Counter
  Bool_t  fIsAnalysed;              ///< Set to true after Analyse has been called

  Int_t fMaxEvents;                 ///< Max events for event histograms
  Int_t fEventsPerBin;              ///< Events per bin for event histograms
  Int_t fSignalCounter;             ///< Signal counter
  Int_t fClusterCounter;            ///< Cluster counter

  TBits fActiveChambers;           ///< configured ROCs

  //
  //  Expand buffer
  //
  Float_t** fAllBins;              //!< array for digit using random access
  Int_t**   fAllSigBins;           //!< array of pointers to the indexes over threshold
  Int_t*    fAllNSigBins;          //!<
  Int_t fRowsMax;                  //!< Maximum number of time bins
  Int_t fPadsMax;                  //!< Maximum number of time bins
  Int_t fTimeBinsMax;              //!< Maximum number of time bins

  // DQM variables
  Bool_t fIsDQM;                   //!< Is DQM -> Simple output (no 2D!)
  TProfile* fHistOccVsSector;      //!< Occ vs sector (for DQM only)
  TProfile2D* fHistOcc2dVsSector;  //!< Occ vs sector 2D (for DQM only)
  TProfile* fHistQVsSector;        //!< Q vs sector (for DQM only)
  TProfile* fHistQmaxVsSector;     //!< QMax vs sector (for DQM only)
  TArrayD* fOccVec;                //!< Occupancy help counter for DQM
  TArrayD* fOccMaxVec;             //!< Occupancy help normlization for DQM
  TArrayD* fOccVecFine;            //!< "2D" occupancy help counter for DQM
  TArrayD* fOccMaxVecFine;         //!< "2D" occupancy help normlization for DQM


  /// \cond CLASSIMP
  ClassDef(AliTPCdataQA, 6)  // Implementation of the TPC Raw QA
  /// \endcond
};


#endif
Commit	Line	Data
7d855b04	1	/// \class AliTPCdataQA
7d855b04	2
0ffacf98	3	#ifndef ALITPCDATAQA_H
	4	#define ALITPCDATAQA_H
	5	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	6	* See cxx source for full Copyright notice */
	7
909e332a	8	#include <TBits.h>
336156cc	9	#include <TH1F.h>
92ae9768	10	#include <TProfile.h>
92ae9768	11	#include <TProfile2D.h>
57acd2d2	12	#include "AliRecoParam.h"
0ffacf98	13
0ab2a4cc	14	#include <TArray.h>
0ab2a4cc	15
0ffacf98	16	class TH2F;
	17	class TTreeSRedirector;
	18	class AliTPCROC;
	19	class AliTPCCalROC;
0c25417d	20	class AliTPCRawStreamV3;
0ffacf98	21	class AliRawReader;
0ffacf98	22	class AliTPCAltroMapping;
ac940b58	23	class AliTPCCalPad;
909e332a	24	class TMap;
909e332a	25	class TObjArray;
0ffacf98	26	struct eventHeaderStruct;
0ffacf98	27
336156cc	28	class AliTPCdataQA : public TH1F {
0ffacf98	29
	30	public:
	31	AliTPCdataQA();
	32	AliTPCdataQA(const AliTPCdataQA &ped);
8ba97cc8	33	AliTPCdataQA(const TMap *config);
0ffacf98	34	virtual ~AliTPCdataQA();
	35
	36	AliTPCdataQA& operator = (const AliTPCdataQA &source);
8368e0ee	37	void DumpToFile(const Char_t filename, const Char_t dir="", Bool_t append=kFALSE);
6a50ff96	38	void MakeTree(const char *fname="QApad.root") const;
258cd111	39
0ffacf98	40	//
6a50ff96	41	Bool_t ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3);
6a50ff96	42	Bool_t ProcessEvent(AliRawReader *const rawReader);
6a50ff96	43	Bool_t ProcessEvent(eventHeaderStruct *const event);
0ffacf98	44
0ffacf98	45	void Analyse();
	46	//
	47	//
6a50ff96	48	void SetPedestal(AliTPCCalPad *const pedestalCal){ fPedestal = pedestalCal;}
6a50ff96	49	void SetNoise(AliTPCCalPad *const noiseCal){ fNoise = noiseCal;}
f11b3071	50
909e332a	51	void SetMinQMax (Float_t minQmax ) { fMinQMax = minQmax; }
909e332a	52	void SetRequireNeighbouringPad(Bool_t req=kTRUE) { fRequireNeighbouringPad = req; }
7d855b04	53
0ab2a4cc	54	// DQM methods
	55	void FillOccupancyProfile();
	56	void ResetProfiles();
	57
	58
266f8637	59	AliTPCCalPad *GetNoThreshold() const { return fNoThreshold;}
	60	AliTPCCalPad *GetMaxCharge() const { return fMaxCharge;}
	61	AliTPCCalPad *GetMeanCharge() const { return fMeanCharge;}
	62	AliTPCCalPad *GetNLocalMaxima() const { return fNLocalMaxima;}
	63	AliTPCCalPad *GetOverThreshold10() const { return fOverThreshold10;}
	64	AliTPCCalPad *GetOverThreshold20() const { return fOverThreshold20;}
	65	AliTPCCalPad *GetOverThreshold30() const { return fOverThreshold30;}
	66	AliTPCCalPad *GetNTimeBins() const { return fNTimeBins;}
	67	AliTPCCalPad *GetNPads() const { return fNPads;}
	68	AliTPCCalPad *GetTimePosition() const { return fTimePosition;}
23c9ab21	69	TProfile* GetHistQVsTimeSideA() const {return fHistQVsTimeSideA;}
	70	TProfile* GetHistQVsTimeSideC() const {return fHistQVsTimeSideC;}
	71	TProfile* GetHistQMaxVsTimeSideA() const {return fHistQMaxVsTimeSideA;}
	72	TProfile* GetHistQMaxVsTimeSideC() const {return fHistQMaxVsTimeSideC;}
ce0175fa	73	TH1F* GetHistOccupancyVsEventConst() const {return fHistOccupancyVsEvent;}
	74	TH1F* GetHistNclustersVsEventConst() const {return fHistNclustersVsEvent;}
	75	TH1F* GetHistOccupancyVsEvent();
	76	TH1F* GetHistNclustersVsEvent();
0ffacf98	77
0ab2a4cc	78	// DQM output
0ab2a4cc	79	TProfile* GetHistOccVsSector() const { return fHistOccVsSector; }
92ae9768	80	TProfile2D* GetHistOcc2dVsSector() const { return fHistOcc2dVsSector; }
0ab2a4cc	81	TProfile* GetHistQVsSector() const { return fHistQVsSector; }
	82	TProfile* GetHistQmaxVsSector() const { return fHistQmaxVsSector; }
	83
0ffacf98	84	//
6a50ff96	85	AliTPCAltroMapping **GetAltroMapping() const { return fMapping; };
0ffacf98	86	void SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; };
	87	//
	88	//
266f8637	89	Int_t GetFirstTimeBin() const { return fFirstTimeBin; }
	90	Int_t GetLastTimeBin() const { return fLastTimeBin; }
	91	Int_t GetAdcMin() const { return fAdcMin; }
	92	Int_t GetAdcMax() const { return fAdcMax; }
	93	Int_t GetEventCounter() const { return fEventCounter; }
266f8637	94	Bool_t GetIsAnalysed() const { return fIsAnalysed; }
ce0175fa	95	Int_t GetMaxEvents() const { return fMaxEvents; }
	96	Int_t GetEventsPerBin() const { return fEventsPerBin; }
	97	Int_t GetSignalCounter() const { return fSignalCounter; }
	98	Int_t GetClusterCounter() const { return fClusterCounter;}
	99
909e332a	100	Float_t GetMinQMax() const { return fMinQMax; }
909e332a	101	Bool_t GetRequireNeighbouringPad() const { return fRequireNeighbouringPad; }
7d855b04	102
0ab2a4cc	103	// DQM getter
	104	Bool_t GetIsDQM() const { return fIsDQM; }
	105
c322f08a	106	void SetRangeTime(Int_t tMin, Int_t tMax){ fFirstTimeBin=tMin; fLastTimeBin=tMax;} // Set time bin range that is used for the pedestal calibration
0ffacf98	107	void SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; } // Set adc range for the pedestal calibration
ce0175fa	108	void SetMaxEvents (Int_t value) { fMaxEvents = value; }
ce0175fa	109	void SetEventsPerBin(Int_t value) { fEventsPerBin = value; }
7d855b04	110
0ab2a4cc	111	// DQM setter
0ab2a4cc	112	void SetIsDQM(Bool_t value) { fIsDQM = value; }
c322f08a	113
909e332a	114	void ResetData();
	115
	116	void SetChamberStatus(UInt_t roc, Bool_t status) { fActiveChambers.SetBitNumber(roc,status); }
	117	Bool_t GetChamberStatus(UInt_t roc) {return fActiveChambers.TestBitNumber(roc);}
0ffacf98	118	private:
266f8637	119	Int_t Update(const Int_t iSector, const Int_t iRow, const Int_t iPad,
92ae9768	120	const Int_t iTimeBin, Float_t signal,
92ae9768	121	const Int_t iPatch=-1, const Int_t iBranch=-1);
266f8637	122	void FindLocalMaxima(const Int_t iSector);
	123
	124	void MakeArrays(); // Create arrays for random data acces
	125	void CleanArrays(); // Clean arrays for random data acces
7d855b04	126	void SetExpandDigit(const Int_t iRow, Int_t iPad, Int_t iTimeBin,
266f8637	127	const Float_t signal); // Fill arrays with signals
	128	void GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin); // Get pad and time bin corresponding to the 1d bin
	129	Float_t GetQ(const Float_t* adcArray, const Int_t time,
7d855b04	130	const Int_t pad, const Int_t maxTimeBins,
6a50ff96	131	Int_t& timeMin,Int_t& timeMax,Int_t& padMin,Int_t& padMax) const;
ce0175fa	132	void UpdateEventHistograms();
266f8637	133
909e332a	134	void Init();
	135
	136	TObjArray ConfigArrRocs(TObjArray arr, const Text_t* name);
	137
7d855b04	138	Int_t fFirstTimeBin; ///< First Time bin needed for analysis
	139	Int_t fLastTimeBin; ///< Last Time bin needed for analysis
	140	Int_t fAdcMin; ///< min adc channel of pedestal value
	141	Int_t fAdcMax; ///< max adc channel of pedestal value
	142	Float_t fMinQMax; ///< Minimun charge for Maximum ADC in cluster
	143	Bool_t fRequireNeighbouringPad; ///< If clusterer should require a neighbouring pad to accept it
	144
0ffacf98	145
7d855b04	146	AliTPCAltroMapping **fMapping; //!< Altro Mapping object
0ffacf98	147	//
0ffacf98	148	//
7d855b04	149	AliTPCCalPad * fPedestal; //!< option to set pedestal cal object
	150	AliTPCCalPad * fNoise; //!< option to set noise cal object
	151	AliTPCCalPad * fNLocalMaxima; ///< local maximas found
	152	AliTPCCalPad * fMaxCharge; ///< max charge
	153	AliTPCCalPad * fMeanCharge; ///< mean charge
	154	AliTPCCalPad * fNoThreshold; ///< number of digits
	155	AliTPCCalPad * fNTimeBins; ///< timebins width of cluster
	156	AliTPCCalPad * fNPads; ///< pads with of cluster
	157	AliTPCCalPad * fTimePosition; ///< Time position of local maximum
	158	AliTPCCalPad * fOverThreshold10; //!< local maxima with qMax over threshold
	159	AliTPCCalPad * fOverThreshold20; //!< local maxima with qMax over threshold
	160	AliTPCCalPad * fOverThreshold30; //!< local maxima with qMax over threshold
	161
	162	TProfile* fHistQVsTimeSideA; ///< Q vs time (side A)
	163	TProfile* fHistQVsTimeSideC; ///< Q vs time (side C)
	164	TProfile* fHistQMaxVsTimeSideA; ///< QMax vs time (side A)
	165	TProfile* fHistQMaxVsTimeSideC; ///< QMax vs time (side C)
	166
	167	TH1F* fHistOccupancyVsEvent; ///< Occupancy vs event number (~time)
	168	TH1F* fHistNclustersVsEvent; ///< Nclusters vs event number (~time)
	169
	170	Int_t fEventCounter; ///< event Counter
	171	Bool_t fIsAnalysed; ///< Set to true after Analyse has been called
	172
	173	Int_t fMaxEvents; ///< Max events for event histograms
	174	Int_t fEventsPerBin; ///< Events per bin for event histograms
	175	Int_t fSignalCounter; ///< Signal counter
	176	Int_t fClusterCounter; ///< Cluster counter
	177
	178	TBits fActiveChambers; ///< configured ROCs
909e332a	179
c322f08a	180	//
	181	// Expand buffer
	182	//
7d855b04	183	Float_t** fAllBins; //!< array for digit using random access
	184	Int_t** fAllSigBins; //!< array of pointers to the indexes over threshold
	185	Int_t* fAllNSigBins; //!<
	186	Int_t fRowsMax; //!< Maximum number of time bins
	187	Int_t fPadsMax; //!< Maximum number of time bins
	188	Int_t fTimeBinsMax; //!< Maximum number of time bins
c322f08a	189
0ab2a4cc	190	// DQM variables
7d855b04	191	Bool_t fIsDQM; //!< Is DQM -> Simple output (no 2D!)
	192	TProfile* fHistOccVsSector; //!< Occ vs sector (for DQM only)
	193	TProfile2D* fHistOcc2dVsSector; //!< Occ vs sector 2D (for DQM only)
	194	TProfile* fHistQVsSector; //!< Q vs sector (for DQM only)
	195	TProfile* fHistQmaxVsSector; //!< QMax vs sector (for DQM only)
	196	TArrayD* fOccVec; //!< Occupancy help counter for DQM
	197	TArrayD* fOccMaxVec; //!< Occupancy help normlization for DQM
	198	TArrayD* fOccVecFine; //!< "2D" occupancy help counter for DQM
	199	TArrayD* fOccMaxVecFine; //!< "2D" occupancy help normlization for DQM
	200
	201
	202	/// \cond CLASSIMP
909e332a	203	ClassDef(AliTPCdataQA, 6) // Implementation of the TPC Raw QA
7d855b04	204	/// \endcond
0ffacf98	205	};
	206
	207
	208
	209	#endif
	210