[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCAPerformance.h

//-*- Mode: C++ -*-
// $Id$
// ************************************************************************
// This file is property of and copyright by the ALICE HLT Project        *
// ALICE Experiment at CERN, All rights reserved.                         *
// See cxx source for full Copyright notice                               *
//                                                                        *
//*************************************************************************

#ifndef ALIHLTTPCCAPERFORMANCE_H
#define ALIHLTTPCCAPERFORMANCE_H

#include "AliHLTTPCCADef.h"
#include "Riostream.h"

class TObject;
class TParticle;
class AliHLTTPCCAMCTrack;
class AliHLTTPCCAMCPoint;
class AliHLTTPCCAGBTracker;
class TDirectory;
class TH1D;
class TH2D;
class TProfile;

/**
 * @class AliHLTTPCCAPerformance
 *
 * Does performance evaluation of the HLT Cellular Automaton-based tracker
 * It checks performance for AliHLTTPCCATracker slice tracker
 * and for AliHLTTPCCAGBTracker global tracker
 *
 */
class AliHLTTPCCAPerformance
{

  public:

    struct AliHLTTPCCAHitLabel {
      int fLab[3]; //* array of 3 MC labels
    };

    AliHLTTPCCAPerformance();
    AliHLTTPCCAPerformance( const AliHLTTPCCAPerformance& );
    const AliHLTTPCCAPerformance &operator=( const AliHLTTPCCAPerformance& ) const;

    virtual ~AliHLTTPCCAPerformance();

    static AliHLTTPCCAPerformance &Instance();

    void SetTracker( AliHLTTPCCAGBTracker * const Tracker );
    void StartEvent();
    void SetNHits( int NHits );
    void SetNMCTracks( int NMCTracks );
    void SetNMCPoints( int NMCPoints );

    void ReadHitLabel( int HitID,
                       int lab0, int lab1, int lab2 );
    void ReadMCTrack( int index, const TParticle *part );
    void ReadMCTPCTrack( int index, float X, float Y, float Z,
                         float Px, float Py, float Pz );

    void ReadMCPoint( int TrackID, float X, float Y, float Z, float Time, int iSlice );

    void CreateHistos();
    void WriteHistos();
    void SlicePerformance( int iSlice, bool PrintFlag  );
    void SliceTrackletPerformance( int iSlice, bool PrintFlag );
    void SliceTrackCandPerformance( int iSlice, bool PrintFlag );

    void Performance( fstream *StatFile = 0 );

    void WriteMCEvent( ostream &out ) const;
    void ReadMCEvent( istream &in );
    void WriteMCPoints( ostream &out ) const;
    void ReadMCPoints( istream &in );
    bool DoClusterPulls() const { return fDoClusterPulls; }
    void SetDoClusterPulls( bool v ) { fDoClusterPulls = v; }
    AliHLTTPCCAHitLabel *HitLabels() const { return fHitLabels;}
    AliHLTTPCCAMCTrack *MCTracks() const { return fMCTracks; }
    int NMCTracks() const { return fNMCTracks; }

    TH1D *HNHitsPerSeed() const { return fhNHitsPerSeed;}
    TH1D *HNHitsPerTrackCand() const { return fhNHitsPerTrackCand; }

    TH1D *LinkChiRight( int i ) const { return fhLinkChiRight[i]; }
    TH1D *LinkChiWrong( int i ) const { return fhLinkChiWrong[i]; }

    void LinkPerformance( int iSlice );

  protected:

    AliHLTTPCCAGBTracker *fTracker; //* pointer to the tracker


    AliHLTTPCCAHitLabel *fHitLabels; //* array of hit MC labels
    int fNHits;                    //* number of hits
    AliHLTTPCCAMCTrack *fMCTracks;   //* array of MC tracks
    int fNMCTracks;                //* number of MC tracks
    AliHLTTPCCAMCPoint *fMCPoints;   //* array of MC points
    int fNMCPoints;                //* number of MC points
    bool fDoClusterPulls;          //* do cluster pulls (very slow)
    int fStatNEvents; //* n of events proceed
    double fStatTime; //* reco time;

    int fStatSeedNRecTot; //* total n of reconstructed tracks
    int fStatSeedNRecOut; //* n of reconstructed tracks in Out set
    int fStatSeedNGhost;//* n of reconstructed tracks in Ghost set
    int fStatSeedNMCAll;//* n of MC tracks
    int fStatSeedNRecAll; //* n of reconstructed tracks in All set
    int fStatSeedNClonesAll;//* total n of reconstructed tracks in Clone set
    int fStatSeedNMCRef; //* n of MC reference tracks
    int fStatSeedNRecRef; //* n of reconstructed tracks in Ref set
    int fStatSeedNClonesRef; //* n of reconstructed clones in Ref set

    int fStatCandNRecTot; //* total n of reconstructed tracks
    int fStatCandNRecOut; //* n of reconstructed tracks in Out set
    int fStatCandNGhost;//* n of reconstructed tracks in Ghost set
    int fStatCandNMCAll;//* n of MC tracks
    int fStatCandNRecAll; //* n of reconstructed tracks in All set
    int fStatCandNClonesAll;//* total n of reconstructed tracks in Clone set
    int fStatCandNMCRef; //* n of MC reference tracks
    int fStatCandNRecRef; //* n of reconstructed tracks in Ref set
    int fStatCandNClonesRef; //* n of reconstructed clones in Ref set

    int fStatNRecTot; //* total n of reconstructed tracks
    int fStatNRecOut; //* n of reconstructed tracks in Out set
    int fStatNGhost;//* n of reconstructed tracks in Ghost set
    int fStatNMCAll;//* n of MC tracks
    int fStatNRecAll; //* n of reconstructed tracks in All set
    int fStatNClonesAll;//* total n of reconstructed tracks in Clone set
    int fStatNMCRef; //* n of MC reference tracks
    int fStatNRecRef; //* n of reconstructed tracks in Ref set
    int fStatNClonesRef; //* n of reconstructed clones in Ref set

    int fStatGBNRecTot; //* global tracker: total n of reconstructed tracks
    int fStatGBNRecOut; //* global tracker: n of reconstructed tracks in Out set
    int fStatGBNGhost;//* global tracker: n of reconstructed tracks in Ghost set
    int fStatGBNMCAll;//* global tracker: n of MC tracks
    int fStatGBNRecAll; //* global tracker: n of reconstructed tracks in All set
    int fStatGBNClonesAll;//* global tracker: total n of reconstructed tracks in Clone set
    int fStatGBNMCRef; //* global tracker: n of MC reference tracks
    int fStatGBNRecRef; //* global tracker: n of reconstructed tracks in Ref set
    int fStatGBNClonesRef; //* global tracker: n of reconstructed clones in Ref set

    TDirectory *fHistoDir; //* ROOT directory with histogramms

    TH1D
    *fhResY,       //* track Y resolution at the TPC entrance
    *fhResZ,       //* track Z resolution at the TPC entrance
    *fhResSinPhi,  //* track SinPhi resolution at the TPC entrance
    *fhResDzDs,    //* track DzDs resolution at the TPC entrance
    *fhResPt,      //* track Pt relative resolution at the TPC entrance
    *fhPullY,      //* track Y pull at the TPC entrance
    *fhPullZ,      //* track Z pull at the TPC entrance
    *fhPullSinPhi, //* track SinPhi pull at the TPC entrance
    *fhPullDzDs, //* track DzDs pull at the TPC entrance
    *fhPullQPt,    //* track Q/Pt pull at the TPC entrance
    *fhPullYS,       //* sqrt(chi2/ndf) deviation of the track parameters Y and SinPhi at the TPC entrance
    *fhPullZT;      //* sqrt(chi2/ndf) deviation of the track parameters Z and DzDs at the TPC entrance

    TProfile *fhCluShared; //* ratio of the shared clusters

    TH1D
    *fhCluResY,  //* cluster resolution Y
    *fhCluResZ,  //* cluster resolution Z
    *fhCluErrY,  //* cluster error in Y
    *fhCluErrZ,  //* cluster error in Z
    *fhCluPullY, //* cluster  pull Y
    *fhCluPullZ, //* cluster  pull Z
    *fhCluResY1, //* cluster resolution Y, Pt>1
    *fhCluResZ1, //* cluster resolution Z, Pt>1
    *fhCluErrY1, //* cluster error in Y, Pt>1
    *fhCluErrZ1, //* cluster error in Z, Pt>1
    *fhCluPullY1,//* cluster  pull Y, Pt>1
    *fhCluPullZ1,//* cluster  pull Z, Pt>1
    *fhCluOrigErrY,  //* cluster original error in Y
    *fhCluOrigErrZ,  //* cluster original error in Z
    *fhCluOrigPullY, //* cluster original  pull Y
    *fhCluOrigPullZ, //* cluster original  pull Z
    *fhCluOrigResY1, //* cluster original resolution Y, Pt>1
    *fhCluOrigResZ1, //* cluster original resolution Z, Pt>1
    *fhCluOrigErrY1, //* cluster original error in Y, Pt>1
    *fhCluOrigErrZ1, //* cluster original error in Z, Pt>1
    *fhCluOrigPullY1,//* cluster  original pull Y, Pt>1
    *fhCluOrigPullZ1;//* cluster  original pull Z, Pt>1


    TH1D
    *fhCellPurity,//* cell purity
    *fhCellNHits//* cell n hits
    ;

    TProfile
    *fhCellPurityVsN, //* cell purity vs N hits
    *fhCellPurityVsPt,//* cell purity vs MC Pt
    *fhEffVsP, //* reconstruction efficiency vs P plot
    *fhSeedEffVsP, //* reconstruction efficiency vs P plot
    *fhCandEffVsP, //* reconstruction efficiency vs P plot
    *fhGBEffVsP, //* global reconstruction efficiency vs P plot
    *fhGBEffVsPt, //* global reconstruction efficiency vs P plot
    *fhNeighQuality, // quality for neighbours finder
    *fhNeighEff,// efficiency for neighbours finder
    *fhNeighQualityVsPt,// quality for neighbours finder vs track Pt
    *fhNeighEffVsPt;// efficiency for neighbours finder vs track Pt
    TH1D
    *fhNeighDy, // dy for neighbours
    *fhNeighDz,// dz for neighbours
    *fhNeighChi;// chi2^0.5 for neighbours
    TH2D
    *fhNeighDyVsPt, // dy for neighbours vs track Pt
    *fhNeighDzVsPt,// dz for neighbours vs track Pt
    *fhNeighChiVsPt, // chi2^0.5 for neighbours vs track Pt
    *fhNeighNCombVsArea; // N neighbours in the search area

    TH1D
    *fhNHitsPerSeed, // n hits per track seed
    *fhNHitsPerTrackCand; // n hits per track candidate

    TH1D
    *fhTrackLengthRef, // reconstructed track length, %
    *fhRefRecoX,// parameters of non-reconstructed ref. mc track
    *fhRefRecoY,// parameters of non-reconstructed ref. mc track
    *fhRefRecoZ,// parameters of non-reconstructed ref. mc track
    *fhRefRecoP, // parameters of non-reconstructed ref. mc track
    *fhRefRecoPt,// parameters of non-reconstructed ref. mc track
    *fhRefRecoAngleY,// parameters of non-reconstructed ref. mc track
    *fhRefRecoAngleZ,// parameters of non-reconstructed ref. mc track
    *fhRefRecoNHits,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoX,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoY,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoZ,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoP, // parameters of non-reconstructed ref. mc track
    *fhRefNotRecoPt,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoAngleY,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoAngleZ,// parameters of non-reconstructed ref. mc track
    *fhRefNotRecoNHits;// parameters of non-reconstructed ref. mc track

    TProfile * fhLinkEff[4]; // link efficiency
    TH1D *fhLinkAreaY[4]; // area in Y for the link finder
    TH1D *fhLinkAreaZ[4]; // area in Z for the link finder
    TH1D *fhLinkChiRight[4]; // sqrt(chi^2) for right neighbours
    TH1D *fhLinkChiWrong[4]; // sqrt(chi^2) for wrong neighbours

    static void WriteDir2Current( TObject *obj );

};

#endif
Commit	Line	Data
d54804bf	1	//-- Mode: C++ --
d54804bf	2	// $Id$
ce565086	3	// ************************************************************************
fbb9b71b	4	// This file is property of and copyright by the ALICE HLT Project *
ce565086	5	// ALICE Experiment at CERN, All rights reserved. *
	6	// See cxx source for full Copyright notice *
	7	// *
	8	//*************************************************************************
d54804bf	9
	10	#ifndef ALIHLTTPCCAPERFORMANCE_H
	11	#define ALIHLTTPCCAPERFORMANCE_H
	12
00d07bcd	13	#include "AliHLTTPCCADef.h"
ce565086	14	#include "Riostream.h"
d54804bf	15
00d07bcd	16	class TObject;
d54804bf	17	class TParticle;
d54804bf	18	class AliHLTTPCCAMCTrack;
eb30eb49	19	class AliHLTTPCCAMCPoint;
d54804bf	20	class AliHLTTPCCAGBTracker;
	21	class TDirectory;
	22	class TH1D;
eb30eb49	23	class TH2D;
d54804bf	24	class TProfile;
	25
	26	/**
	27	* @class AliHLTTPCCAPerformance
fbb9b71b	28	*
d54804bf	29	* Does performance evaluation of the HLT Cellular Automaton-based tracker
fbb9b71b	30	* It checks performance for AliHLTTPCCATracker slice tracker
d54804bf	31	* and for AliHLTTPCCAGBTracker global tracker
	32	*
	33	*/
00d07bcd	34	class AliHLTTPCCAPerformance
d54804bf	35	{
d54804bf	36
fbb9b71b	37	public:
	38
	39	struct AliHLTTPCCAHitLabel {
	40	int fLab[3]; //* array of 3 MC labels
	41	};
	42
	43	AliHLTTPCCAPerformance();
	44	AliHLTTPCCAPerformance( const AliHLTTPCCAPerformance& );
	45	const AliHLTTPCCAPerformance &operator=( const AliHLTTPCCAPerformance& ) const;
	46
	47	virtual ~AliHLTTPCCAPerformance();
	48
	49	static AliHLTTPCCAPerformance &Instance();
	50
	51	void SetTracker( AliHLTTPCCAGBTracker * const Tracker );
	52	void StartEvent();
	53	void SetNHits( int NHits );
	54	void SetNMCTracks( int NMCTracks );
	55	void SetNMCPoints( int NMCPoints );
	56
	57	void ReadHitLabel( int HitID,
	58	int lab0, int lab1, int lab2 );
	59	void ReadMCTrack( int index, const TParticle *part );
	60	void ReadMCTPCTrack( int index, float X, float Y, float Z,
	61	float Px, float Py, float Pz );
	62
	63	void ReadMCPoint( int TrackID, float X, float Y, float Z, float Time, int iSlice );
	64
	65	void CreateHistos();
	66	void WriteHistos();
	67	void SlicePerformance( int iSlice, bool PrintFlag );
	68	void SliceTrackletPerformance( int iSlice, bool PrintFlag );
	69	void SliceTrackCandPerformance( int iSlice, bool PrintFlag );
	70
	71	void Performance( fstream *StatFile = 0 );
	72
	73	void WriteMCEvent( ostream &out ) const;
	74	void ReadMCEvent( istream &in );
	75	void WriteMCPoints( ostream &out ) const;
	76	void ReadMCPoints( istream &in );
	77	bool DoClusterPulls() const { return fDoClusterPulls; }
	78	void SetDoClusterPulls( bool v ) { fDoClusterPulls = v; }
	79	AliHLTTPCCAHitLabel *HitLabels() const { return fHitLabels;}
	80	AliHLTTPCCAMCTrack *MCTracks() const { return fMCTracks; }
	81	int NMCTracks() const { return fNMCTracks; }
	82
	83	TH1D *HNHitsPerSeed() const { return fhNHitsPerSeed;}
	84	TH1D *HNHitsPerTrackCand() const { return fhNHitsPerTrackCand; }
	85
	86	TH1D *LinkChiRight( int i ) const { return fhLinkChiRight[i]; }
	87	TH1D *LinkChiWrong( int i ) const { return fhLinkChiWrong[i]; }
	88
	89	void LinkPerformance( int iSlice );
	90
	91	protected:
	92
	93	AliHLTTPCCAGBTracker fTracker; // pointer to the tracker
	94
	95
	96	AliHLTTPCCAHitLabel fHitLabels; // array of hit MC labels
	97	int fNHits; //* number of hits
	98	AliHLTTPCCAMCTrack fMCTracks; // array of MC tracks
	99	int fNMCTracks; //* number of MC tracks
	100	AliHLTTPCCAMCPoint fMCPoints; // array of MC points
101	int fNMCPoints; //* number of MC points
102	bool fDoClusterPulls; //* do cluster pulls (very slow)
103	int fStatNEvents; //* n of events proceed
104	double fStatTime; //* reco time;
105
106	int fStatSeedNRecTot; //* total n of reconstructed tracks
107	int fStatSeedNRecOut; //* n of reconstructed tracks in Out set
108	int fStatSeedNGhost;//* n of reconstructed tracks in Ghost set
109	int fStatSeedNMCAll;//* n of MC tracks
110	int fStatSeedNRecAll; //* n of reconstructed tracks in All set
111	int fStatSeedNClonesAll;//* total n of reconstructed tracks in Clone set
112	int fStatSeedNMCRef; //* n of MC reference tracks
113	int fStatSeedNRecRef; //* n of reconstructed tracks in Ref set
114	int fStatSeedNClonesRef; //* n of reconstructed clones in Ref set
115
116	int fStatCandNRecTot; //* total n of reconstructed tracks
117	int fStatCandNRecOut; //* n of reconstructed tracks in Out set
118	int fStatCandNGhost;//* n of reconstructed tracks in Ghost set
119	int fStatCandNMCAll;//* n of MC tracks
120	int fStatCandNRecAll; //* n of reconstructed tracks in All set
121	int fStatCandNClonesAll;//* total n of reconstructed tracks in Clone set
122	int fStatCandNMCRef; //* n of MC reference tracks
123	int fStatCandNRecRef; //* n of reconstructed tracks in Ref set
124	int fStatCandNClonesRef; //* n of reconstructed clones in Ref set
125
126	int fStatNRecTot; //* total n of reconstructed tracks
127	int fStatNRecOut; //* n of reconstructed tracks in Out set
128	int fStatNGhost;//* n of reconstructed tracks in Ghost set
129	int fStatNMCAll;//* n of MC tracks
130	int fStatNRecAll; //* n of reconstructed tracks in All set
131	int fStatNClonesAll;//* total n of reconstructed tracks in Clone set
132	int fStatNMCRef; //* n of MC reference tracks
133	int fStatNRecRef; //* n of reconstructed tracks in Ref set
134	int fStatNClonesRef; //* n of reconstructed clones in Ref set
135
136	int fStatGBNRecTot; //* global tracker: total n of reconstructed tracks
137	int fStatGBNRecOut; //* global tracker: n of reconstructed tracks in Out set
138	int fStatGBNGhost;//* global tracker: n of reconstructed tracks in Ghost set
139	int fStatGBNMCAll;//* global tracker: n of MC tracks
140	int fStatGBNRecAll; //* global tracker: n of reconstructed tracks in All set
141	int fStatGBNClonesAll;//* global tracker: total n of reconstructed tracks in Clone set
142	int fStatGBNMCRef; //* global tracker: n of MC reference tracks
143	int fStatGBNRecRef; //* global tracker: n of reconstructed tracks in Ref set
144	int fStatGBNClonesRef; //* global tracker: n of reconstructed clones in Ref set
145
146	TDirectory fHistoDir; // ROOT directory with histogramms
147
148	TH1D
149	fhResY, // track Y resolution at the TPC entrance
150	fhResZ, // track Z resolution at the TPC entrance
151	fhResSinPhi, // track SinPhi resolution at the TPC entrance
152	fhResDzDs, // track DzDs resolution at the TPC entrance
153	fhResPt, // track Pt relative resolution at the TPC entrance
154	fhPullY, // track Y pull at the TPC entrance
155	fhPullZ, // track Z pull at the TPC entrance
156	fhPullSinPhi, // track SinPhi pull at the TPC entrance
157	fhPullDzDs, // track DzDs pull at the TPC entrance
158	fhPullQPt, // track Q/Pt pull at the TPC entrance
159	fhPullYS, // sqrt(chi2/ndf) deviation of the track parameters Y and SinPhi at the TPC entrance
160	fhPullZT; // sqrt(chi2/ndf) deviation of the track parameters Z and DzDs at the TPC entrance
161
0d5d04a1	162	TProfile fhCluShared; // ratio of the shared clusters
eb30eb49	163
fbb9b71b	164	TH1D
0d5d04a1	165	fhCluResY, // cluster resolution Y
	166	fhCluResZ, // cluster resolution Z
	167	fhCluErrY, // cluster error in Y
	168	fhCluErrZ, // cluster error in Z
	169	fhCluPullY, // cluster pull Y
	170	fhCluPullZ, // cluster pull Z
	171	fhCluResY1, // cluster resolution Y, Pt>1
	172	fhCluResZ1, // cluster resolution Z, Pt>1
	173	fhCluErrY1, // cluster error in Y, Pt>1
	174	fhCluErrZ1, // cluster error in Z, Pt>1
	175	fhCluPullY1,// cluster pull Y, Pt>1
	176	fhCluPullZ1,// cluster pull Z, Pt>1
	177	fhCluOrigErrY, // cluster original error in Y
	178	fhCluOrigErrZ, // cluster original error in Z
	179	fhCluOrigPullY, // cluster original pull Y
	180	fhCluOrigPullZ, // cluster original pull Z
	181	fhCluOrigResY1, // cluster original resolution Y, Pt>1
	182	fhCluOrigResZ1, // cluster original resolution Z, Pt>1
	183	fhCluOrigErrY1, // cluster original error in Y, Pt>1
	184	fhCluOrigErrZ1, // cluster original error in Z, Pt>1
	185	fhCluOrigPullY1,// cluster original pull Y, Pt>1
	186	fhCluOrigPullZ1;// cluster original pull Z, Pt>1
	187
eb30eb49	188
fbb9b71b	189	TH1D
d54804bf	190	fhCellPurity,// cell purity
	191	fhCellNHits// cell n hits
	192	;
	193
fbb9b71b	194	TProfile
00d07bcd	195	fhCellPurityVsN, // cell purity vs N hits
	196	fhCellPurityVsPt,// cell purity vs MC Pt
	197	fhEffVsP, // reconstruction efficiency vs P plot
ce565086	198	fhSeedEffVsP, // reconstruction efficiency vs P plot
ce565086	199	fhCandEffVsP, // reconstruction efficiency vs P plot
00d07bcd	200	fhGBEffVsP, // global reconstruction efficiency vs P plot
4687b8fc	201	fhGBEffVsPt, // global reconstruction efficiency vs P plot
fbb9b71b	202	*fhNeighQuality, // quality for neighbours finder
00d07bcd	203	*fhNeighEff,// efficiency for neighbours finder
	204	*fhNeighQualityVsPt,// quality for neighbours finder vs track Pt
	205	*fhNeighEffVsPt;// efficiency for neighbours finder vs track Pt
fbb9b71b	206	TH1D
fbb9b71b	207	*fhNeighDy, // dy for neighbours
00d07bcd	208	*fhNeighDz,// dz for neighbours
00d07bcd	209	*fhNeighChi;// chi2^0.5 for neighbours
fbb9b71b	210	TH2D
00d07bcd	211	*fhNeighDyVsPt, // dy for neighbours vs track Pt
	212	*fhNeighDzVsPt,// dz for neighbours vs track Pt
	213	*fhNeighChiVsPt, // chi2^0.5 for neighbours vs track Pt
	214	*fhNeighNCombVsArea; // N neighbours in the search area
d54804bf	215
fbb9b71b	216	TH1D
693d2443	217	*fhNHitsPerSeed, // n hits per track seed
	218	*fhNHitsPerTrackCand; // n hits per track candidate
	219
fbb9b71b	220	TH1D
693d2443	221	*fhTrackLengthRef, // reconstructed track length, %
	222	*fhRefRecoX,// parameters of non-reconstructed ref. mc track
	223	*fhRefRecoY,// parameters of non-reconstructed ref. mc track
	224	*fhRefRecoZ,// parameters of non-reconstructed ref. mc track
	225	*fhRefRecoP, // parameters of non-reconstructed ref. mc track
	226	*fhRefRecoPt,// parameters of non-reconstructed ref. mc track
	227	*fhRefRecoAngleY,// parameters of non-reconstructed ref. mc track
	228	*fhRefRecoAngleZ,// parameters of non-reconstructed ref. mc track
	229	*fhRefRecoNHits,// parameters of non-reconstructed ref. mc track
	230	*fhRefNotRecoX,// parameters of non-reconstructed ref. mc track
	231	*fhRefNotRecoY,// parameters of non-reconstructed ref. mc track
	232	*fhRefNotRecoZ,// parameters of non-reconstructed ref. mc track
	233	*fhRefNotRecoP, // parameters of non-reconstructed ref. mc track
	234	*fhRefNotRecoPt,// parameters of non-reconstructed ref. mc track
	235	*fhRefNotRecoAngleY,// parameters of non-reconstructed ref. mc track
	236	*fhRefNotRecoAngleZ,// parameters of non-reconstructed ref. mc track
	237	*fhRefNotRecoNHits;// parameters of non-reconstructed ref. mc track
	238
fbb9b71b	239	TProfile * fhLinkEff[4]; // link efficiency
	240	TH1D *fhLinkAreaY[4]; // area in Y for the link finder
	241	TH1D *fhLinkAreaZ[4]; // area in Z for the link finder
	242	TH1D *fhLinkChiRight[4]; // sqrt(chi^2) for right neighbours
	243	TH1D *fhLinkChiWrong[4]; // sqrt(chi^2) for wrong neighbours
	244
	245	static void WriteDir2Current( TObject *obj );
ce565086	246
d54804bf	247	};
	248
	249	#endif