[u/mrichter/AliRoot.git] / PWG1 / TRD / AliTRDresolution.h

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

/* $Id: AliTRDresolution.h 27496 2008-07-22 08:35:45Z cblume $ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  TRD Resolution performance                                            //
//                                                                        //
//  Authors:                                                              //
//    Alexandru Bercuci <A.Bercuci@gsi.de>                                //
//    Markus Fasel <M.Fasel@gsi.de>                                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#ifndef ALITRDRECOTASK_H
#include "AliTRDrecoTask.h"
#endif

class TH1;
class TH2;
class TF1;
class TGraphErrors;
class TObjArray;
class TDatabasePDG;
class AliTRDrecoParam;
class AliTRDseedV1;
class AliTRDtrackInfo;
class AliTrackPoint;
class AliTRDresolution : public AliTRDrecoTask
{
public:
  enum ETRDresolutionSteer {
     kVerbose    = BIT(18) // switch verbosity
    ,kVisual     = BIT(19) // show partial results during processing
    ,kTrackRefit = BIT(20) // steer track refit
    ,kTrackSelect= BIT(21) // steer track selection
//    ,kLoadCorr   = BIT(23) // steer load corrections
  };
  enum ETRDresolutionSlots {
     kClToTrk    = 2
    ,kClToMC
    ,kTrkltToTrk
    ,kTrkltToMC
    ,kNSlots     = 4
  };
  enum ETRDresolutionClass {
    kCluster=0        // cluster - track
    ,kTracklet        // tracklet - track residuals/pulls
    ,kTrackIn         // tracklet - track residuals/pulls at lower TRD entrance
    ,kTrackOut        // tracklet - track residuals/pulls at lower TRD entrance during refit
    ,kMCcluster       // cluster-mc resolution/pulls
    ,kMCtracklet      // tracklet-mc resolution/pulls
    ,kMCtrackIn       // TPC track monitor
    ,kMCtrackOut      // TOF/HMPID track monitor
    ,kMCtrack         // TRD track monitor
    ,kNclasses        // total number of resolution classes
  };
  enum ETRDresolutionProjs {
    kBC    = 0 // bunch cross
    ,kPhi
    ,kEta
    ,kSpeciesChgRC
    ,kYrez
    ,kZrez
    ,kPrez
//    ,kPt
    ,kNdim  // no of dimensions in the THnSparse
  };
  enum ETRDresolutionSegmentation {
     kSector    = 0
    ,kStack
    ,kDetector
    ,kNbunchCross = 3  // no of classes for bunch crossing
    ,kNpt         = 24 // no of log bins in pt spectrum
    ,kNcharge     = 2
  };

  AliTRDresolution();
  AliTRDresolution(char* name);
  virtual ~AliTRDresolution();
  
  static Bool_t  FitTrack(const Int_t np, AliTrackPoint *points, Float_t params[10]);
  static Bool_t  FitTracklet(const Int_t ly, const Int_t np, const AliTrackPoint *points, const Float_t trackPars[10], Float_t trackletPars[3]);
  void    UserCreateOutputObjects();
//  Float_t GetCorrectionX(Int_t det, Int_t tb) const {return fXcorr[det][tb];}
  Float_t GetDyRange() const {return fDyRange;}
  Float_t GetMeanWithBoundary(TH1 *h, Float_t zm, Float_t zM, Float_t dz) const;
  Float_t GetPtThreshold() const {return fPtThreshold;}
  static Int_t GetPtBin(Float_t pt);
  Bool_t  GetRefFigure(Int_t ifig);

  TObjArray*  Histos(); 
//  Bool_t  Load(const Char_t *file = "AnalysisResults.root", const Char_t *dir="TRD_Performance");
//  Bool_t  LoadCorrection(const Char_t *file=NULL);
  void    MakeSummary();
  static void MakePtSegmentation(Float_t pt0=0.2, Float_t dpt=0.002);

  TObjArray*  Results(ETRDresolutionClass c) const {if(!fProj) return NULL; return (TObjArray*)fProj->At(c);}
  void    UserExec(Option_t * opt);
  void    InitExchangeContainers();
//  Bool_t  HasLoadCorrection() const {return TestBit(kLoadCorr);}
  Bool_t  HasTrackRefit() const {return TestBit(kTrackRefit);}
  Bool_t  HasTrackSelection() const {return TestBit(kTrackSelect);}
  Bool_t  IsVerbose() const {return TestBit(kVerbose);}
  Bool_t  IsVisual() const {return TestBit(kVisual);}
  Bool_t  PostProcess();

  TH1*    PlotCluster(const AliTRDtrackV1 *t=NULL);
  TH1*    PlotTracklet(const AliTRDtrackV1 *t=NULL);
  TH1*    PlotTrackIn(const AliTRDtrackV1 *t=NULL);
  TH1*    PlotTrackOut(const AliTRDtrackV1 *t=NULL);
  TH1*    PlotMC(const AliTRDtrackV1 *t=NULL);

  static Bool_t  Process(TH2* const h2, TGraphErrors **g, Int_t stat=100);
  void    SetDyRange(Float_t dy) {fDyRange = dy;}
//  void    SetSegmentationLevel(Int_t l=0);
  void    SetPtThreshold(Float_t pt) {fPtThreshold = pt;}
//  void    SetLoadCorrection(Bool_t v = kTRUE) {SetBit(kLoadCorr, v);}
  void    SetVerbose(Bool_t v = kTRUE) {SetBit(kVerbose, v);}
  void    SetVisual(Bool_t v = kTRUE) {SetBit(kVisual, v);}
  void    SetTrackRefit(Bool_t v = kTRUE) {SetBit(kTrackRefit, v);}
  void    SetTrackSelection(Bool_t v = kTRUE) {SetBit(kTrackSelect, v);}

  void    Terminate(Option_t * opt);
  static Bool_t  UseTrack(const Int_t np, const AliTrackPoint *points, Float_t params[10]);

private:
  AliTRDresolution(const AliTRDresolution&);
  AliTRDresolution& operator=(const AliTRDresolution&);

  void    AdjustF1(TH1 *h, TF1 *f);
  TObjArray*  BuildMonitorContainerCluster(const char* name, Bool_t expand=kFALSE, Float_t range=-1.);
  TObjArray*  BuildMonitorContainerTracklet(const char* name, Bool_t expand=kFALSE);
  TObjArray*  BuildMonitorContainerTrack(const char* name);
  void    GetLandauMpvFwhm(TF1 * const f, Float_t &mpv, Float_t &xm, Float_t &xM);
  void    GetRange(TH2 *h2, Char_t mod, Float_t *range);
  Bool_t  MakeProjectionCluster();
  Bool_t  MakeProjectionTracklet();
  Bool_t  MakeProjectionTrackIn();
  Bool_t  Process(TH2* const h2, TF1 *f, Float_t k, TGraphErrors **g);
  Bool_t  Pulls(Double_t dyz[2], Double_t cc[3], Double_t tilt) const;

  UShort_t              fIdxPlot;         // plot counter (internal)
  UShort_t              fIdxFrame;        // frame counter (internal)
  Float_t               fPtThreshold;     // pt threshold for some performance plots
  Float_t               fDyRange;         // min/max dy
  static Char_t const  *fgPerformanceName[kNclasses]; //! name of performance plot
  static UChar_t const  fgNproj[kNclasses];//! number of projections per task
  static Int_t const    fgkNbins[kNdim];  //! no of bins/projection
  static Double_t const fgkMin[kNdim];    //! low limits for projections
  static Double_t const fgkMax[kNdim];    //! high limits for projections
  static Char_t const  *fgkTitle[kNdim];  //! title of projection 
  static Float_t        fgPtBin[kNpt+1];  //! pt segmentation
  TObjArray            *fProj;            //! result holder - sigma values
  TDatabasePDG         *fDBPDG;           //! PDG database

  // calibration containers
  TObjArray           *fCl;               //! cluster2track calib
  TObjArray           *fMCcl;             //! cluster2mc calib
  
  ClassDef(AliTRDresolution, 10) // TRD tracking resolution task
};
#endif
Commit	Line	Data
1ee39b3a	1	#ifndef ALITRDRESOLUTION_H
	2	#define ALITRDRESOLUTION_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id: AliTRDresolution.h 27496 2008-07-22 08:35:45Z cblume $ */
	7
	8	////////////////////////////////////////////////////////////////////////////
	9	// //
	10	// TRD Resolution performance //
	11	// //
	12	// Authors: //
	13	// Alexandru Bercuci <A.Bercuci@gsi.de> //
	14	// Markus Fasel <M.Fasel@gsi.de> //
	15	// //
	16	////////////////////////////////////////////////////////////////////////////
	17
	18	#ifndef ALITRDRECOTASK_H
	19	#include "AliTRDrecoTask.h"
	20	#endif
	21
	22	class TH1;
	23	class TH2;
	24	class TF1;
	25	class TGraphErrors;
	26	class TObjArray;
92c40e64	27	class TDatabasePDG;
1ee39b3a	28	class AliTRDrecoParam;
	29	class AliTRDseedV1;
	30	class AliTRDtrackInfo;
08bdd9d1	31	class AliTrackPoint;
1ee39b3a	32	class AliTRDresolution : public AliTRDrecoTask
	33	{
	34	public:
1ee39b3a	35	enum ETRDresolutionSteer {
08bdd9d1	36	kVerbose = BIT(18) // switch verbosity
	37	,kVisual = BIT(19) // show partial results during processing
	38	,kTrackRefit = BIT(20) // steer track refit
00a56108	39	,kTrackSelect= BIT(21) // steer track selection
3ceb45ae	40	// ,kLoadCorr = BIT(23) // steer load corrections
1ee39b3a	41	};
3ceb45ae	42	enum ETRDresolutionSlots {
705f8b0a	43	kClToTrk = 2
3ceb45ae	44	,kClToMC
	45	,kTrkltToTrk
	46	,kTrkltToMC
	47	,kNSlots = 4
	48	};
	49	enum ETRDresolutionClass {
	50	kCluster=0 // cluster - track
	51	,kTracklet // tracklet - track residuals/pulls
	52	,kTrackIn // tracklet - track residuals/pulls at lower TRD entrance
	53	,kTrackOut // tracklet - track residuals/pulls at lower TRD entrance during refit
	54	,kMCcluster // cluster-mc resolution/pulls
	55	,kMCtracklet // tracklet-mc resolution/pulls
	56	,kMCtrackIn // TPC track monitor
	57	,kMCtrackOut // TOF/HMPID track monitor
	58	,kMCtrack // TRD track monitor
	59	,kNclasses // total number of resolution classes
	60	};
	61	enum ETRDresolutionProjs {
	62	kBC = 0 // bunch cross
	63	,kPhi
	64	,kEta
	65	,kSpeciesChgRC
3ceb45ae	66	,kYrez
	67	,kZrez
	68	,kPrez
0d69a485	69	// ,kPt
3ceb45ae	70	,kNdim // no of dimensions in the THnSparse
705f8b0a	71	};
9dcc64cc	72	enum ETRDresolutionSegmentation {
	73	kSector = 0
	74	,kStack
	75	,kDetector
3ceb45ae	76	,kNbunchCross = 3 // no of classes for bunch crossing
	77	,kNpt = 24 // no of log bins in pt spectrum
	78	,kNcharge = 2
9dcc64cc	79	};
1ee39b3a	80
1ee39b3a	81	AliTRDresolution();
f8f46e4d	82	AliTRDresolution(char* name);
1ee39b3a	83	virtual ~AliTRDresolution();
1ee39b3a	84
08bdd9d1	85	static Bool_t FitTrack(const Int_t np, AliTrackPoint *points, Float_t params[10]);
b37d601d	86	static Bool_t FitTracklet(const Int_t ly, const Int_t np, const AliTrackPoint *points, const Float_t trackPars[10], Float_t trackletPars[3]);
f8f46e4d	87	void UserCreateOutputObjects();
3ceb45ae	88	// Float_t GetCorrectionX(Int_t det, Int_t tb) const {return fXcorr[det][tb];}
6859821f	89	Float_t GetDyRange() const {return fDyRange;}
3ceb45ae	90	Float_t GetMeanWithBoundary(TH1 *h, Float_t zm, Float_t zM, Float_t dz) const;
3ba3e0a4	91	Float_t GetPtThreshold() const {return fPtThreshold;}
3ceb45ae	92	static Int_t GetPtBin(Float_t pt);
1ee39b3a	93	Bool_t GetRefFigure(Int_t ifig);
3ceb45ae	94
1ee39b3a	95	TObjArray* Histos();
3ceb45ae	96	// Bool_t Load(const Char_t file = "AnalysisResults.root", const Char_t dir="TRD_Performance");
3ceb45ae	97	// Bool_t LoadCorrection(const Char_t *file=NULL);
00a3f7a4	98	void MakeSummary();
3ceb45ae	99	static void MakePtSegmentation(Float_t pt0=0.2, Float_t dpt=0.002);
2589cf64	100
3ceb45ae	101	TObjArray* Results(ETRDresolutionClass c) const {if(!fProj) return NULL; return (TObjArray*)fProj->At(c);}
f8f46e4d	102	void UserExec(Option_t * opt);
83b44483	103	void InitExchangeContainers();
3ceb45ae	104	// Bool_t HasLoadCorrection() const {return TestBit(kLoadCorr);}
08bdd9d1	105	Bool_t HasTrackRefit() const {return TestBit(kTrackRefit);}
00a56108	106	Bool_t HasTrackSelection() const {return TestBit(kTrackSelect);}
801d4d50	107	Bool_t IsVerbose() const {return TestBit(kVerbose);}
801d4d50	108	Bool_t IsVisual() const {return TestBit(kVisual);}
1ee39b3a	109	Bool_t PostProcess();
1ee39b3a	110
a310e49b	111	TH1* PlotCluster(const AliTRDtrackV1 *t=NULL);
	112	TH1* PlotTracklet(const AliTRDtrackV1 *t=NULL);
	113	TH1* PlotTrackIn(const AliTRDtrackV1 *t=NULL);
	114	TH1* PlotTrackOut(const AliTRDtrackV1 *t=NULL);
	115	TH1* PlotMC(const AliTRDtrackV1 *t=NULL);
1ee39b3a	116
5468a262	117	static Bool_t Process(TH2* const h2, TGraphErrors **g, Int_t stat=100);
6859821f	118	void SetDyRange(Float_t dy) {fDyRange = dy;}
3ceb45ae	119	// void SetSegmentationLevel(Int_t l=0);
3ba3e0a4	120	void SetPtThreshold(Float_t pt) {fPtThreshold = pt;}
3ceb45ae	121	// void SetLoadCorrection(Bool_t v = kTRUE) {SetBit(kLoadCorr, v);}
801d4d50	122	void SetVerbose(Bool_t v = kTRUE) {SetBit(kVerbose, v);}
801d4d50	123	void SetVisual(Bool_t v = kTRUE) {SetBit(kVisual, v);}
08bdd9d1	124	void SetTrackRefit(Bool_t v = kTRUE) {SetBit(kTrackRefit, v);}
00a56108	125	void SetTrackSelection(Bool_t v = kTRUE) {SetBit(kTrackSelect, v);}
1ee39b3a	126
1ee39b3a	127	void Terminate(Option_t * opt);
b37d601d	128	static Bool_t UseTrack(const Int_t np, const AliTrackPoint *points, Float_t params[10]);
3ceb45ae	129
1ee39b3a	130	private:
	131	AliTRDresolution(const AliTRDresolution&);
	132	AliTRDresolution& operator=(const AliTRDresolution&);
afca20ef	133
1ee39b3a	134	void AdjustF1(TH1 h, TF1 f);
9dcc64cc	135	TObjArray* BuildMonitorContainerCluster(const char* name, Bool_t expand=kFALSE, Float_t range=-1.);
2589cf64	136	TObjArray* BuildMonitorContainerTracklet(const char* name, Bool_t expand=kFALSE);
3d2a3dff	137	TObjArray* BuildMonitorContainerTrack(const char* name);
1ee39b3a	138	void GetLandauMpvFwhm(TF1 * const f, Float_t &mpv, Float_t &xm, Float_t &xM);
068e2c00	139	void GetRange(TH2 h2, Char_t mod, Float_t range);
3ceb45ae	140	Bool_t MakeProjectionCluster();
	141	Bool_t MakeProjectionTracklet();
	142	Bool_t MakeProjectionTrackIn();
1ee39b3a	143	Bool_t Process(TH2* const h2, TF1 f, Float_t k, TGraphErrors *g);
61f6b45e	144	Bool_t Pulls(Double_t dyz[2], Double_t cc[3], Double_t tilt) const;
1ee39b3a	145
3ceb45ae	146	UShort_t fIdxPlot; // plot counter (internal)
	147	UShort_t fIdxFrame; // frame counter (internal)
	148	Float_t fPtThreshold; // pt threshold for some performance plots
	149	Float_t fDyRange; // min/max dy
	150	static Char_t const *fgPerformanceName[kNclasses]; //! name of performance plot
	151	static UChar_t const fgNproj[kNclasses];//! number of projections per task
	152	static Int_t const fgkNbins[kNdim]; //! no of bins/projection
	153	static Double_t const fgkMin[kNdim]; //! low limits for projections
	154	static Double_t const fgkMax[kNdim]; //! high limits for projections
	155	static Char_t const *fgkTitle[kNdim]; //! title of projection
	156	static Float_t fgPtBin[kNpt+1]; //! pt segmentation
	157	TObjArray *fProj; //! result holder - sigma values
	158	TDatabasePDG *fDBPDG; //! PDG database
1ee39b3a	159
1ee39b3a	160	// calibration containers
3ceb45ae	161	TObjArray *fCl; //! cluster2track calib
3ceb45ae	162	TObjArray *fMCcl; //! cluster2mc calib
1ee39b3a	163
3ceb45ae	164	ClassDef(AliTRDresolution, 10) // TRD tracking resolution task
1ee39b3a	165	};
1ee39b3a	166	#endif