[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSDDInjectors.h

#ifndef ALIITSONLINESDDINJECTORS_H
#define ALIITSONLINESDDINJECTORS_H


/* $Id$ */

///////////////////////////////////////////////////////////////////
//                                                               //
// Class used for SDD injector analysis                           //
// Origin: F.Prino, Torino, prino@to.infn.it                     //
//                                                               //
///////////////////////////////////////////////////////////////////

#include "AliITSOnlineSDD.h"


class TH1F;
class TH2F;
class TGraphErrors;
class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {

 public:
  AliITSOnlineSDDInjectors();      
  AliITSOnlineSDDInjectors(Int_t nddl, Int_t ncarlos, Int_t sid);
  virtual ~AliITSOnlineSDDInjectors();


  void SetThresholds(Int_t ilin, Float_t tl, Float_t th){
    fLowThreshold[ilin]=tl;
    fHighThreshold[ilin]=th;
  }
  void SetMaxNumberOfCellsPerAnode(Int_t maxc=40){
    fMaxCellsAboveThreshold=maxc;
  }

  void SetInjLineRange(Int_t jlin, Int_t tbmin, Int_t tbmax){
    fTbMin[jlin]=tbmin;
    fTbMax[jlin]=tbmax;
  }
  void Set20MHzConfig();
  void Set40MHzConfig();

  void SetPolDegree(Int_t n){fPolDegree=n;}
  void SetMinDriftSpeed(Float_t vmin){fMinDriftSpeed=vmin;}
  void SetMaxDriftSpeed(Float_t vmax){fMaxDriftSpeed=vmax;}
  void SetMaxDriftSpeedErr(Float_t maxval){
    fMaxDriftSpeedErr=maxval;
  }
  void SetFitLimits(Int_t firstpad,Int_t lastpad){
    fFirstPadForFit=firstpad;
    fLastPadForFit=lastpad;
  }
  void SetPadStatusCutForFit(Int_t cutval=4){
    fPadStatusCutForFit=cutval;
  }
  void SetDefaults();
  void SetTimeStep(Double_t tstep) {
    fTimeStep=tstep;
  }
  void SetUseTimeZeroSignal(Bool_t useTZ=kTRUE){
    fUseTimeZeroSignal=useTZ;
  }
  void SetUseLine(Int_t iLine, Bool_t use=kTRUE){
    if(iLine>=0 && iLine<kInjLines) fUseLine[iLine]=use;
  }
  TH1F* GetMeanDriftSpeedVsPadHisto() const;
  TGraphErrors* GetTimeVsDistGraph(Int_t jpad) const;
  TGraphErrors* GetDriftSpeedGraph() const;
  TGraphErrors* GetSelectedDriftSpeedGraph(Int_t minAcceptStatus) const;
  Double_t* GetDriftSpeedFitParam()const{ return fParam;}
  Double_t GetDriftSpeed(Int_t jpad) const{return fDriftSpeed[jpad];}
  Double_t GetDriftSpeedErr(Int_t jpad) const{return fDriftSpeedErr[jpad];}
  Double_t GetTimeBinZero() const{return fTbZero;}

  Double_t GetTimeStep() const{return fTimeStep;}
  Int_t GetAnodeNumber(Int_t iInjPad) const;
  Int_t GetInjPadNumberFromAnode(Int_t nAnode) const;
  Int_t GetInjPadStatus(Int_t jpad) const;  
  Int_t GetAnodeStatus(Int_t nAnode) const{
    Int_t jpad=GetInjPadNumberFromAnode(nAnode);
    return GetInjPadStatus(jpad);
  }  
  Double_t GetCentroid(Int_t jpad, Int_t jlin) const {
    if(jpad<kInjPads && jlin<kInjLines) return fCentroid[jpad][jlin];
    else return -9999.;
  }
  Bool_t IsInjectorGood(Int_t jpad, Int_t jlin) const {
    if(jpad<kInjPads && jlin<kInjLines) return fGoodInj[jpad][jlin];
    else return 0;
  }
  void PrintInjectorStatus();
  void PrintCentroids();
  void WriteToASCII(Int_t evNumb, UInt_t timeStamp, Int_t optAppend=0);
  void WriteInjectorStatusToASCII();
  Bool_t WriteToROOT(TFile *fil) const;

  void Reset();
  void AnalyzeEvent(TH2F* his);
  void AddEvent(TH2F* his);
  void FindGoodInjectors();
  void FindCentroids();
  void CalcDriftSpeed(Int_t jpad);
  void CalcTimeBinZero();
  void FitDriftSpeedVsAnode();
  void PolyFit(Int_t degree=3);
  Double_t GetMeanDriftSpeed(Int_t ipad) const{
    if(fNEventsInPad[ipad]==0) return 0.;
    return fSumDriftSpeed[ipad]/(Double_t)fNEventsInPad[ipad];
  }
  Double_t GetRMSDriftSpeed(Int_t ipad) const;
  Double_t GetMeanPadStatusCut(Int_t ipad) const{
    if(fNEventsInPad[ipad]==0) return 0.;
    return (Double_t)fSumPadStatusCut[ipad]/(Double_t)fNEventsInPad[ipad];
  }
  Double_t GetMeanPadStatus(Int_t ipad) const{
    if(fNEvents==0) return 0.;
    return (Double_t)fSumPadStatus[ipad]/(Double_t)fNEvents;
  }

  void FitMeanDriftSpeedVsAnode();

 protected:
  void SetPositions();
 private:

  enum {kInjPads  = 33};
  enum {kInjLines = 3};

  AliITSOnlineSDDInjectors(const AliITSOnlineSDDInjectors& source);
  AliITSOnlineSDDInjectors& operator = (const AliITSOnlineSDDInjectors& source);
  static const Float_t fgkSaturation;        // ADC saturation value (1008)
  static const Float_t fgkDefaultLThreshold;  // Default for fLowThreshold
  static const Float_t fgkDefaultLThreshold1;  // Default for fLowThreshold
  static const Float_t fgkDefaultHThreshold;  // Default for fHighThreshold
  static const Float_t fgkDefaultHThreshold1;  // Default for fHighThreshold
  static const Float_t fgkDefaultMinSpeed;   // Default for fMinDriftSpeed
  static const Float_t fgkDefaultMaxSpeed;   // Default for fMaxDriftSpeed
  static const Float_t fgkDefaultMaxErr;     // Default for fMaxDriftSpeedErr
  static const Int_t   fgkDefaultPolDegree;   // Default for fPolDegree
  static const Float_t fgkDefaultTimeStep;   // Default for fTimeStep
  static const UShort_t   fgkDefaultTbMin[kInjLines];  // Defaults for fTbMin
  static const UShort_t   fgkDefaultTbMax[kInjLines];  // Defaults for fTbMax


  TH2F* fHisto;                              // histogram of channel counts
  Double_t fTbZero;                           // Time zero for injector event
  Double_t fRMSTbZero;                        // Error on time zero 
  Double_t fPosition[kInjLines];              // Coordinates of injector lines
  UShort_t fTbMin[kInjLines];                 // Minimum time bin for each line
  UShort_t fTbMax[kInjLines];                 // Maximum time bin for each line
  Bool_t fGoodInj[kInjPads][kInjLines];       // array of good injectors
  Double_t fCentroid[kInjPads][kInjLines];    // array of time bin centroids
  Double_t fRMSCentroid[kInjPads][kInjLines]; // array of time rms of injectors
  Double_t fDriftSpeed[kInjPads];             // drift speed  
  Double_t fDriftSpeedErr[kInjPads];          // error on drift speed
  Int_t fNEvents;                             // number of events
  Int_t fNEventsInPad[kInjPads];              // number of events per pad
  Double_t fSumDriftSpeed[kInjPads];          // drift speed summed over events  
  Double_t fSumSqDriftSpeed[kInjPads];        // drift speed^2 sum
  Int_t fSumPadStatus[kInjPads];              // pad status sum
  Int_t fSumPadStatusCut[kInjPads];           // pad status (> cut) sum
  
  Double_t *fParam;                          // parameters of polinomial fit to
                                             // drift speed vs. anode number
  Int_t fPolDegree;                  // Degree of polynomial fit
  Int_t fActualPolDegree;            // Degree actually used (<=fPolDegree)
  Float_t fMinDriftSpeed;            // Minimum value for drift speed
  Float_t fMaxDriftSpeed;            // Maximum value for drift speed
  Float_t fMaxDriftSpeedErr;         // Maximum value for error on drift speed
  Float_t fLowThreshold[kInjLines];  // Low threshold for injector signal
  Float_t fHighThreshold[kInjLines]; // High threshold for injector signal

  Bool_t fUseLine[kInjLines];        // Flag to use/not use a line
  Int_t fFirstPadForFit;             // first injector pad used in fit
  Int_t fLastPadForFit;              // last injector pad used in fit
  Int_t fPadStatusCutForFit;         // minimum value of pad status for fit

  Double_t fTimeStep;                // time bin value (25 or 50 ns)
  Bool_t fUseTimeZeroSignal;         // flag for usage of time zero signal
                                     // in drift speed calculation

  Int_t fMaxCellsAboveThreshold;     // cut to remove noisy anodes

  ClassDef(AliITSOnlineSDDInjectors,9)
};
#endif
Commit	Line	Data
348f80b7	1	#ifndef ALIITSONLINESDDINJECTORS_H
	2	#define ALIITSONLINESDDINJECTORS_H
	3
	4
84df0230	5	/* $Id$ */
9f026db8	6
348f80b7	7	///////////////////////////////////////////////////////////////////
	8	// //
	9	// Class used for SDD injector analysis //
	10	// Origin: F.Prino, Torino, prino@to.infn.it //
	11	// //
	12	///////////////////////////////////////////////////////////////////
9f026db8	13
0e5e647a	14	#include "AliITSOnlineSDD.h"
348f80b7	15
9f026db8	16
e5b2f7f2	17	class TH1F;
348f80b7	18	class TH2F;
	19	class TGraphErrors;
	20	class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {
	21
	22	public:
	23	AliITSOnlineSDDInjectors();
979b5a5f	24	AliITSOnlineSDDInjectors(Int_t nddl, Int_t ncarlos, Int_t sid);
348f80b7	25	virtual ~AliITSOnlineSDDInjectors();
348f80b7	26
b255f56d	27
b9585d25	28	void SetThresholds(Int_t ilin, Float_t tl, Float_t th){
	29	fLowThreshold[ilin]=tl;
	30	fHighThreshold[ilin]=th;
9f026db8	31	}
b9585d25	32	void SetMaxNumberOfCellsPerAnode(Int_t maxc=40){
	33	fMaxCellsAboveThreshold=maxc;
	34	}
	35
9f026db8	36	void SetInjLineRange(Int_t jlin, Int_t tbmin, Int_t tbmax){
	37	fTbMin[jlin]=tbmin;
	38	fTbMax[jlin]=tbmax;
	39	}
b9585d25	40	void Set20MHzConfig();
	41	void Set40MHzConfig();
	42
915c0469	43	void SetPolDegree(Int_t n){fPolDegree=n;}
9f026db8	44	void SetMinDriftSpeed(Float_t vmin){fMinDriftSpeed=vmin;}
	45	void SetMaxDriftSpeed(Float_t vmax){fMaxDriftSpeed=vmax;}
	46	void SetMaxDriftSpeedErr(Float_t maxval){
	47	fMaxDriftSpeedErr=maxval;
348f80b7	48	}
9f026db8	49	void SetFitLimits(Int_t firstpad,Int_t lastpad){
	50	fFirstPadForFit=firstpad;
	51	fLastPadForFit=lastpad;
348f80b7	52	}
915c0469	53	void SetPadStatusCutForFit(Int_t cutval=4){
9f026db8	54	fPadStatusCutForFit=cutval;
348f80b7	55	}
9f026db8	56	void SetDefaults();
2ca27861	57	void SetTimeStep(Double_t tstep) {
f4e26d31	58	fTimeStep=tstep;
f4e26d31	59	}
784a52ed	60	void SetUseTimeZeroSignal(Bool_t useTZ=kTRUE){
	61	fUseTimeZeroSignal=useTZ;
	62	}
1397fe91	63	void SetUseLine(Int_t iLine, Bool_t use=kTRUE){
	64	if(iLine>=0 && iLine<kInjLines) fUseLine[iLine]=use;
	65	}
e5b2f7f2	66	TH1F* GetMeanDriftSpeedVsPadHisto() const;
9f026db8	67	TGraphErrors* GetTimeVsDistGraph(Int_t jpad) const;
9f026db8	68	TGraphErrors* GetDriftSpeedGraph() const;
84df0230	69	TGraphErrors* GetSelectedDriftSpeedGraph(Int_t minAcceptStatus) const;
2ca27861	70	Double_t* GetDriftSpeedFitParam()const{ return fParam;}
	71	Double_t GetDriftSpeed(Int_t jpad) const{return fDriftSpeed[jpad];}
	72	Double_t GetDriftSpeedErr(Int_t jpad) const{return fDriftSpeedErr[jpad];}
	73	Double_t GetTimeBinZero() const{return fTbZero;}
9f026db8	74
2ca27861	75	Double_t GetTimeStep() const{return fTimeStep;}
9f026db8	76	Int_t GetAnodeNumber(Int_t iInjPad) const;
	77	Int_t GetInjPadNumberFromAnode(Int_t nAnode) const;
	78	Int_t GetInjPadStatus(Int_t jpad) const;
	79	Int_t GetAnodeStatus(Int_t nAnode) const{
	80	Int_t jpad=GetInjPadNumberFromAnode(nAnode);
	81	return GetInjPadStatus(jpad);
	82	}
2ca27861	83	Double_t GetCentroid(Int_t jpad, Int_t jlin) const {
9f026db8	84	if(jpad<kInjPads && jlin<kInjLines) return fCentroid[jpad][jlin];
c668f182	85	else return -9999.;
c668f182	86	}
9f026db8	87	Bool_t IsInjectorGood(Int_t jpad, Int_t jlin) const {
9f026db8	88	if(jpad<kInjPads && jlin<kInjLines) return fGoodInj[jpad][jlin];
c668f182	89	else return 0;
c668f182	90	}
9f026db8	91	void PrintInjectorStatus();
348f80b7	92	void PrintCentroids();
4c82df4c	93	void WriteToASCII(Int_t evNumb, UInt_t timeStamp, Int_t optAppend=0);
50d25e98	94	void WriteInjectorStatusToASCII();
456ec396	95	Bool_t WriteToROOT(TFile *fil) const;
348f80b7	96
2ca27861	97	void Reset();
	98	void AnalyzeEvent(TH2F* his);
	99	void AddEvent(TH2F* his);
348f80b7	100	void FindGoodInjectors();
348f80b7	101	void FindCentroids();
9f026db8	102	void CalcDriftSpeed(Int_t jpad);
348f80b7	103	void CalcTimeBinZero();
9f026db8	104	void FitDriftSpeedVsAnode();
3bc883e9	105	void PolyFit(Int_t degree=3);
2ca27861	106	Double_t GetMeanDriftSpeed(Int_t ipad) const{
e89a0633	107	if(fNEventsInPad[ipad]==0) return 0.;
e89a0633	108	return fSumDriftSpeed[ipad]/(Double_t)fNEventsInPad[ipad];
2ca27861	109	}
2ca27861	110	Double_t GetRMSDriftSpeed(Int_t ipad) const;
e89a0633	111	Double_t GetMeanPadStatusCut(Int_t ipad) const{
	112	if(fNEventsInPad[ipad]==0) return 0.;
	113	return (Double_t)fSumPadStatusCut[ipad]/(Double_t)fNEventsInPad[ipad];
	114	}
	115	Double_t GetMeanPadStatus(Int_t ipad) const{
	116	if(fNEvents==0) return 0.;
	117	return (Double_t)fSumPadStatus[ipad]/(Double_t)fNEvents;
	118	}
	119
2ca27861	120	void FitMeanDriftSpeedVsAnode();
348f80b7	121
	122	protected:
	123	void SetPositions();
	124	private:
	125
9f026db8	126	enum {kInjPads = 33};
9f026db8	127	enum {kInjLines = 3};
348f80b7	128
	129	AliITSOnlineSDDInjectors(const AliITSOnlineSDDInjectors& source);
	130	AliITSOnlineSDDInjectors& operator = (const AliITSOnlineSDDInjectors& source);
9f026db8	131	static const Float_t fgkSaturation; // ADC saturation value (1008)
9f026db8	132	static const Float_t fgkDefaultLThreshold; // Default for fLowThreshold
b9585d25	133	static const Float_t fgkDefaultLThreshold1; // Default for fLowThreshold
9f026db8	134	static const Float_t fgkDefaultHThreshold; // Default for fHighThreshold
b9585d25	135	static const Float_t fgkDefaultHThreshold1; // Default for fHighThreshold
9f026db8	136	static const Float_t fgkDefaultMinSpeed; // Default for fMinDriftSpeed
	137	static const Float_t fgkDefaultMaxSpeed; // Default for fMaxDriftSpeed
	138	static const Float_t fgkDefaultMaxErr; // Default for fMaxDriftSpeedErr
915c0469	139	static const Int_t fgkDefaultPolDegree; // Default for fPolDegree
f4e26d31	140	static const Float_t fgkDefaultTimeStep; // Default for fTimeStep
9f026db8	141	static const UShort_t fgkDefaultTbMin[kInjLines]; // Defaults for fTbMin
	142	static const UShort_t fgkDefaultTbMax[kInjLines]; // Defaults for fTbMax
	143
	144
	145	TH2F* fHisto; // histogram of channel counts
2ca27861	146	Double_t fTbZero; // Time zero for injector event
	147	Double_t fRMSTbZero; // Error on time zero
	148	Double_t fPosition[kInjLines]; // Coordinates of injector lines
e89a0633	149	UShort_t fTbMin[kInjLines]; // Minimum time bin for each line
	150	UShort_t fTbMax[kInjLines]; // Maximum time bin for each line
	151	Bool_t fGoodInj[kInjPads][kInjLines]; // array of good injectors
2ca27861	152	Double_t fCentroid[kInjPads][kInjLines]; // array of time bin centroids
	153	Double_t fRMSCentroid[kInjPads][kInjLines]; // array of time rms of injectors
	154	Double_t fDriftSpeed[kInjPads]; // drift speed
	155	Double_t fDriftSpeedErr[kInjPads]; // error on drift speed
e89a0633	156	Int_t fNEvents; // number of events
e89a0633	157	Int_t fNEventsInPad[kInjPads]; // number of events per pad
2ca27861	158	Double_t fSumDriftSpeed[kInjPads]; // drift speed summed over events
2ca27861	159	Double_t fSumSqDriftSpeed[kInjPads]; // drift speed^2 sum
e89a0633	160	Int_t fSumPadStatus[kInjPads]; // pad status sum
e89a0633	161	Int_t fSumPadStatusCut[kInjPads]; // pad status (> cut) sum
2ca27861	162
e89a0633	163	Double_t *fParam; // parameters of polinomial fit to
9f026db8	164	// drift speed vs. anode number
e89a0633	165	Int_t fPolDegree; // Degree of polynomial fit
e89a0633	166	Int_t fActualPolDegree; // Degree actually used (<=fPolDegree)
9f026db8	167	Float_t fMinDriftSpeed; // Minimum value for drift speed
	168	Float_t fMaxDriftSpeed; // Maximum value for drift speed
	169	Float_t fMaxDriftSpeedErr; // Maximum value for error on drift speed
b9585d25	170	Float_t fLowThreshold[kInjLines]; // Low threshold for injector signal
b9585d25	171	Float_t fHighThreshold[kInjLines]; // High threshold for injector signal
9f026db8	172
1397fe91	173	Bool_t fUseLine[kInjLines]; // Flag to use/not use a line
9f026db8	174	Int_t fFirstPadForFit; // first injector pad used in fit
	175	Int_t fLastPadForFit; // last injector pad used in fit
	176	Int_t fPadStatusCutForFit; // minimum value of pad status for fit
	177
b9585d25	178	Double_t fTimeStep; // time bin value (25 or 50 ns)
784a52ed	179	Bool_t fUseTimeZeroSignal; // flag for usage of time zero signal
784a52ed	180	// in drift speed calculation
9f026db8	181
b9585d25	182	Int_t fMaxCellsAboveThreshold; // cut to remove noisy anodes
	183
	184	ClassDef(AliITSOnlineSDDInjectors,9)
348f80b7	185	};
348f80b7	186	#endif