[u/mrichter/AliRoot.git] / ITS / UPGRADE / testITSU / DetectorK.h

#ifndef DETECTORK_H
#define DETECTORK_H

#include <TNamed.h>
#include <TClonesArray.h>
#include <TList.h>
#include <TGraph.h>
#include <Riostream.h>

/***********************************************************

Fast Simulation tool for Inner Tracker Systems

original code of using the billoir technique was developed
for the HFT (STAR), James H. Thomas, jhthomas@lbl.gov
http://rnc.lbl.gov/~jhthomas

Changes by S. Rossegger

July 2011  - Adding the possibility of "fake calculation" and "efficiency calculation" 
             with a number of "at least correct clusters on the track"
             Done using the complete combinatorics table with 3^nLayer track outcomes.

April 2011 - Now uses the Kalman method (aliroot implementation) instead of the Billoir
             technique ... (changes by Ruben Shahoyan)

March 2011 - Changes to comply with the Alice Offline coding conventions

Feb. 2011 - Improvement in "lowest pt allowed" -> now uses helix param. for calc. of a,b

          - Adding a more sophisticaed efficiency calculation which includes
            the possibility to make chi2 cuts via Confidence Levels (method of Ruben Shahoyan)
            plus adding 'basic' detection efficiencies per layer ...

          - Adding "ITS Stand alone" tracking capabilities via 
            forward+backward tracking -> Kalman smoothing is then 
            used for the parameter estimates (important for efficiencies)

Jan. 2011 - Inclusion of ImpactParameter Plots (with vtx estimates)
            to allow comparison with ITS performances in pp data

Dec. 2010 - Translation into C++ class format 
          - Adding various Setters and Getters to build the geometry 
	    (based on cylinders) plus handling of the layer properties 


***********************************************************/

class AliExternalTrackParam; 
#include <TMatrixD.h>

class TrackSol: public TObject
{
 public:
  enum {kInw,kOut,kCmb};
  //
 TrackSol(int nL, double pt, double eta, int q, double m=0.140) 
   : fPt(nL>0 ? pt : -1), fEta(eta), fMass(m), fCharge(q),  
    fTrackInw("AliExternalTrackParam",nL),
    fTrackOutB("AliExternalTrackParam",nL),
    fTrackOutA("AliExternalTrackParam",nL),
    fTrackCmb("AliExternalTrackParam",nL)
    {
      for (int i=3;i--;) fProb[i][0] = fProb[i][1] = 0;
    }
  //
  void Clear(Option_t*) {
    fTrackInw.Clear();
    fTrackOutB.Clear();
    fTrackOutA.Clear();
    fTrackCmb.Clear();
    fPt = -1;
    for (int i=3;i--;) fProb[i][0] = fProb[i][1] = 0;
  }
  //
  Double_t        fPt;
  Double_t        fEta;
  Double_t        fMass;
  Int_t           fCharge;
  Double_t        fProb[3][2]; // corr/fake prob for inw,out and cmb tracking
  TClonesArray fTrackInw;
  TClonesArray fTrackOutB; // outward before update
  TClonesArray fTrackOutA; // outward after update
  TClonesArray fTrackCmb;
  //
  ClassDef(TrackSol,1)
};


class CylLayerK : public TNamed {
public:

  CylLayerK(char *name) : TNamed(name,name) {}
  
  Float_t GetRadius()   const {return radius;}
  Float_t GetRadL()     const {return radL;}
  Float_t GetPhiRes()   const {return phiRes;}
  Float_t GetZRes()     const {return zRes;}
  Float_t GetLayerEff() const {return eff;}

  //  void Print() {printf("  r=%3.1lf X0=%1.6lf sigPhi=%1.4lf sigZ=%1.4lf\n",radius,radL,phiRes,zRes); }
  Float_t radius; Float_t radL; Float_t phiRes; Float_t zRes;   
  Float_t eff;
  Bool_t isDead;

 ClassDef(CylLayerK,1);
};


class DetectorK : public TNamed {

 public:
  
  DetectorK();
  DetectorK(char *name,char *title);
  virtual ~DetectorK();

  enum {kNptBins = 50}; // less then 400 !!
 
  void AddLayer(char *name, Float_t radius, Float_t radL, Float_t phiRes=999999, Float_t zRes=999999, Float_t eff=0.95);
  void KillLayer(char *name);
  void SetRadius(char *name, Float_t radius);
  void SetRadiationLength(char *name, Float_t radL);
  void SetResolution(char *name, Float_t phiRes=999999, Float_t zRes=999999);
  void SetLayerEfficiency(char *name, Float_t eff=0.95);
  void RemoveLayer(char *name);
  CylLayerK* FindLayer(char* name) const;
  CylLayerK* FindLayer(double r, int mode) const;
  Int_t      FindLayerID(double r, int mode) const;
  //
  Float_t GetRadius(char *name);
  Float_t GetRadiationLength(char *name);
  Float_t GetResolution(char *name, Int_t axis=0);
  Float_t GetLayerEfficiency(char *name);

  void PrintLayout(Bool_t full = kFALSE); 
  void PlotLayout(Int_t plotDead = kTRUE);
  
  void MakeAliceAllNew(Bool_t flagTPC =1,Bool_t flagMon=1);
  void MakeAliceCurrent(Int_t AlignResiduals = 0, Bool_t flagTPC =1);
  void AddTPC(Float_t phiResMean=0.1, Float_t zResMean=0.1, Int_t skip=1);
  void AddTRD(Float_t phiResMean=0.02, Float_t zResMean=2.5, Float_t lrEff=0.9);
  void RemoveTPC();

  void SetBField(Float_t bfield) {fBField = bfield; }
  Float_t GetBField() const {return fBField; }
  void SetLhcUPCscale(Float_t lhcUPCscale) {fLhcUPCscale = lhcUPCscale; }
  Float_t GetLhcUPCscale() const { return fLhcUPCscale; }
  void SetParticleMass(Float_t particleMass) {fParticleMass = particleMass; }
  Float_t GetParticleMass() const { return fParticleMass; }
  void SetIntegrationTime(Float_t integrationTime) {fIntegrationTime = integrationTime; }
  Float_t GetIntegrationTime() const { return fIntegrationTime; }
  void SetMaxRadiusOfSlowDetectors(Float_t maxRadiusSlowDet) {fMaxRadiusSlowDet =  maxRadiusSlowDet; }
  Float_t GetMaxRadiusOfSlowDetectors() const { return fMaxRadiusSlowDet; }
  void SetAvgRapidity(Float_t avgRapidity) {fAvgRapidity = avgRapidity; }
  Float_t GetAvgRapidity() const { return fAvgRapidity; }
  void SetConfidenceLevel(Float_t confLevel) {fConfLevel = confLevel; }
  Float_t GetConfidenceLevel() const { return fConfLevel; }

  void SetAtLeastHits(Int_t atLeast ) {fAtLeastHits = atLeast; }
  Int_t GetAtLeastHits() const { return fAtLeastHits; }

  void SetAtLeastCorr(Int_t atLeastCorr ) {fAtLeastCorr = atLeastCorr; }
  Int_t GetAtLeastCorr() const { return fAtLeastCorr; }
  void SetAtLeastFake(Int_t atLeastFake ) {fAtLeastFake = atLeastFake; }
  Int_t GetAtLeastFake() const { return fAtLeastFake; }

  void SetMaxSeedRadius(Double_t maxSeedRadius ) {fMaxSeedRadius = maxSeedRadius; }
  Int_t GetMaxSeedRadius() const { return fMaxSeedRadius; }

  void SetptScale(Double_t ptScale ) {fptScale = ptScale; }
  Int_t GetptScale() const { return fptScale; }

  
  void SetdNdEtaCent(Int_t dNdEtaCent ) {fdNdEtaCent = dNdEtaCent; }
  Float_t GetdNdEtaCent() const { return fdNdEtaCent; }
  
  
  Float_t GetNumberOfLayers()          const {return fNumberOfLayers; }
  Float_t GetNumberOfActiveLayers() const {return fNumberOfActiveLayers; }
  Float_t GetNumberOfActiveITSLayers() const {return fNumberOfActiveITSLayers; }

  void SolveViaBilloir(Int_t flagD0=1,Int_t print=1, Bool_t allPt=1, Double_t meanPt =0.095, char* detLayer=((char*)""));
  //
  Bool_t SolveTrack(TrackSol& ts);
  Bool_t CalcITSEff(TrackSol& ts, Bool_t verbose=kTRUE);
  Bool_t ExtrapolateToR(AliExternalTrackParam* probTr, double rTgt, double mass=0.14);
  //
  void   SetMinRadTrack(double r=132) {  fMinRadTrack = r; }
  Double_t GetMinRadTrack()  const { return fMinRadTrack;}

  //
  //
  // Helper functions
  Double_t ThetaMCS                 ( Double_t mass, Double_t RadLength, Double_t momentum ) const;
  Double_t ProbGoodHit              ( Double_t radius, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; 
  Double_t ProbGoodChiSqHit         ( Double_t radius, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; 
  Double_t ProbGoodChiSqPlusConfHit ( Double_t radius, Double_t leff, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; 
  Double_t ProbNullChiSqPlusConfHit ( Double_t radius, Double_t leff, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; 
 
  // Howard W. hit distribution and convolution integral
  Double_t Dist              ( Double_t Z, Double_t radius ) ;  
  Double_t HitDensity        ( Double_t radius )   ;
  Double_t UpcHitDensity     ( Double_t radius )   ;
  Double_t IntegratedHitDensity  ( Double_t multiplicity, Double_t radius )   ;
  Double_t OneEventHitDensity    ( Double_t multiplicity, Double_t radius ) const   ;
  Double_t D0IntegratedEfficiency( Double_t pt, Double_t corrEfficiency[][400] ) const ;
  
  TGraph* GetGraphMomentumResolution(Int_t color, Int_t linewidth=1);
  TGraph* GetGraphPointingResolution(Int_t axis,Int_t color, Int_t linewidth=1);
  TGraph* GetGraphPointingResolutionTeleEqu(Int_t axis,Int_t color, Int_t linewidth=1);
  TGraph* GetGraphLayerInfo(Int_t plot, Int_t color, Int_t linewidth=1);

  TGraph* GetGraphImpactParam(Int_t mode, Int_t axis, Int_t color, Int_t linewidth=1);

  TGraph* GetGraphRecoEfficiency(Int_t particle, Int_t color, Int_t linewidth=1); 
  TGraph* GetGraphRecoFakes(Int_t particle,Int_t color, Int_t linewidth);
  TGraph* GetGraphRecoPurity(Int_t particle,Int_t color, Int_t linewidth);

  TGraph* GetGraph(Int_t number, Int_t color, Int_t linewidth=1);

  void MakeStandardPlots(Bool_t add =0, Int_t color=1, Int_t linewidth=1,Bool_t onlyPionEff=0);

  // method to extend AliExternalTrackParam functionality
  static Bool_t GetXatLabR(AliExternalTrackParam* tr,Double_t r,Double_t &x, Double_t bz, Int_t dir=0);
  static Bool_t PropagateToR(AliExternalTrackParam* trc, double r, double b, int dir=0);
  Double_t* PrepareEffFakeKombinations(TMatrixD *probKomb, TMatrixD *probLay, double* prob=0);

  Bool_t IsITSLayer(const TString& lname);

  static Bool_t verboseR;
 protected:
 
  Int_t fNumberOfLayers;        // total number of layers in the model
  Int_t fNumberOfActiveLayers;  // number of active layers in the model
  Int_t fNumberOfActiveITSLayers;  // number of active ITS layers in the model
  TList fLayers;                // List of layer pointers
  Float_t fBField;              // Magnetic Field in Tesla
  Float_t fLhcUPCscale;         // UltraPeripheralElectrons: scale from RHIC to LHC
  Float_t fIntegrationTime;     // electronics integration time
  Float_t fConfLevel;           // Confidence Level for the tracking
  Float_t fAvgRapidity;         // rapidity of the track (= mean)
  Float_t fParticleMass;        // Particle used for tracking. Standard: mass of pion
  Double_t fMaxRadiusSlowDet;   // Maximum radius for slow detectors.  Fast detectors 
                                // and only fast detectors reside outside this radius.

  Int_t fAtLeastHits;     // min. number of hits for the track to account it
  Int_t fAtLeastCorr;     // min. number of correct hits for the track to be "good"
  Int_t fAtLeastFake;     // min. number of fake hits for the track to be "fake"

  Double_t fMaxSeedRadius; // max seeding radius, e.g. to exclude TRD
  Double_t fptScale;      // used for maxPt

  Int_t fdNdEtaCent;       // Multiplicity

  enum {kMaxNumberOfDetectors = 200};
 
  Double_t fTransMomenta[kNptBins];                          // array of transverse momenta
  Double_t fMomentumRes[kNptBins];                           // array of momentum resolution
  Double_t fResolutionRPhi[kNptBins];                        // array of rphi resolution
  Double_t fResolutionZ[kNptBins];                           // array of z resolution
  Double_t fDetPointRes[kMaxNumberOfDetectors][kNptBins];    // array of rphi resolution per layer
  Double_t fDetPointZRes[kMaxNumberOfDetectors][kNptBins];   // array of z resolution per layer
  Double_t fEfficiency[3][kNptBins];                         // efficiency for different particles
  Double_t fFake[3][kNptBins];                               // fake prob for different particles

  Int_t kDetLayer;                              // layer for which a few more details are extracted
  Double_t fResolutionRPhiLay[kNptBins];                        // array of rphi resolution
  Double_t fResolutionZLay[kNptBins];                           // array of z resolution
  Double_t fEfficProlongLay[kNptBins];                           // array of z resolution

  Double_t fMinRadTrack;

  static const Double_t kPtMinFix;
  static const Double_t kPtMaxFix;

  ClassDef(DetectorK,1);
};

#endif
Commit	Line	Data
36b05ae5	1	#ifndef DETECTORK_H
	2	#define DETECTORK_H
	3
	4	#include <TNamed.h>
fb4ff059	5	#include <TClonesArray.h>
36b05ae5	6	#include <TList.h>
	7	#include <TGraph.h>
	8	#include <Riostream.h>
	9
	10	/***********************************************************
	11
	12	Fast Simulation tool for Inner Tracker Systems
	13
	14	original code of using the billoir technique was developed
	15	for the HFT (STAR), James H. Thomas, jhthomas@lbl.gov
	16	http://rnc.lbl.gov/~jhthomas
	17
	18	Changes by S. Rossegger
	19
	20	July 2011 - Adding the possibility of "fake calculation" and "efficiency calculation"
	21	with a number of "at least correct clusters on the track"
	22	Done using the complete combinatorics table with 3^nLayer track outcomes.
	23
	24	April 2011 - Now uses the Kalman method (aliroot implementation) instead of the Billoir
	25	technique ... (changes by Ruben Shahoyan)
	26
	27	March 2011 - Changes to comply with the Alice Offline coding conventions
	28
	29	Feb. 2011 - Improvement in "lowest pt allowed" -> now uses helix param. for calc. of a,b
	30
	31	- Adding a more sophisticaed efficiency calculation which includes
	32	the possibility to make chi2 cuts via Confidence Levels (method of Ruben Shahoyan)
	33	plus adding 'basic' detection efficiencies per layer ...
	34
	35	- Adding "ITS Stand alone" tracking capabilities via
	36	forward+backward tracking -> Kalman smoothing is then
	37	used for the parameter estimates (important for efficiencies)
	38
	39	Jan. 2011 - Inclusion of ImpactParameter Plots (with vtx estimates)
	40	to allow comparison with ITS performances in pp data
	41
	42	Dec. 2010 - Translation into C++ class format
	43	- Adding various Setters and Getters to build the geometry
	44	(based on cylinders) plus handling of the layer properties
	45
	46
	47	***********************************************************/
	48
	49	class AliExternalTrackParam;
	50	#include <TMatrixD.h>
	51
45fa8186	52	class TrackSol: public TObject
fb4ff059	53	{
	54	public:
	55	enum {kInw,kOut,kCmb};
	56	//
	57	TrackSol(int nL, double pt, double eta, int q, double m=0.140)
	58	: fPt(nL>0 ? pt : -1), fEta(eta), fMass(m), fCharge(q),
	59	fTrackInw("AliExternalTrackParam",nL),
	60	fTrackOutB("AliExternalTrackParam",nL),
	61	fTrackOutA("AliExternalTrackParam",nL),
	62	fTrackCmb("AliExternalTrackParam",nL)
	63	{
	64	for (int i=3;i--;) fProb[i][0] = fProb[i][1] = 0;
	65	}
	66	//
	67	void Clear(Option_t*) {
	68	fTrackInw.Clear();
	69	fTrackOutB.Clear();
	70	fTrackOutA.Clear();
	71	fTrackCmb.Clear();
	72	fPt = -1;
	73	for (int i=3;i--;) fProb[i][0] = fProb[i][1] = 0;
	74	}
	75	//
	76	Double_t fPt;
	77	Double_t fEta;
	78	Double_t fMass;
	79	Int_t fCharge;
	80	Double_t fProb[3][2]; // corr/fake prob for inw,out and cmb tracking
	81	TClonesArray fTrackInw;
	82	TClonesArray fTrackOutB; // outward before update
	83	TClonesArray fTrackOutA; // outward after update
	84	TClonesArray fTrackCmb;
	85	//
	86	ClassDef(TrackSol,1)
	87	};
	88
	89
	90	class CylLayerK : public TNamed {
	91	public:
	92
	93	CylLayerK(char *name) : TNamed(name,name) {}
	94
	95	Float_t GetRadius() const {return radius;}
	96	Float_t GetRadL() const {return radL;}
	97	Float_t GetPhiRes() const {return phiRes;}
	98	Float_t GetZRes() const {return zRes;}
	99	Float_t GetLayerEff() const {return eff;}
	100
	101	// void Print() {printf(" r=%3.1lf X0=%1.6lf sigPhi=%1.4lf sigZ=%1.4lf\n",radius,radL,phiRes,zRes); }
	102	Float_t radius; Float_t radL; Float_t phiRes; Float_t zRes;
	103	Float_t eff;
	104	Bool_t isDead;
	105
	106	ClassDef(CylLayerK,1);
	107	};
	108
	109
36b05ae5	110	class DetectorK : public TNamed {
	111
	112	public:
	113
	114	DetectorK();
	115	DetectorK(char name,char title);
	116	virtual ~DetectorK();
	117
	118	enum {kNptBins = 50}; // less then 400 !!
	119
	120	void AddLayer(char *name, Float_t radius, Float_t radL, Float_t phiRes=999999, Float_t zRes=999999, Float_t eff=0.95);
36b05ae5	121	void KillLayer(char *name);
	122	void SetRadius(char *name, Float_t radius);
	123	void SetRadiationLength(char *name, Float_t radL);
	124	void SetResolution(char *name, Float_t phiRes=999999, Float_t zRes=999999);
	125	void SetLayerEfficiency(char *name, Float_t eff=0.95);
	126	void RemoveLayer(char *name);
fb4ff059	127	CylLayerK* FindLayer(char* name) const;
	128	CylLayerK* FindLayer(double r, int mode) const;
	129	Int_t FindLayerID(double r, int mode) const;
	130	//
36b05ae5	131	Float_t GetRadius(char *name);
	132	Float_t GetRadiationLength(char *name);
	133	Float_t GetResolution(char *name, Int_t axis=0);
	134	Float_t GetLayerEfficiency(char *name);
	135
e4f085eb	136	void PrintLayout(Bool_t full = kFALSE);
36b05ae5	137	void PlotLayout(Int_t plotDead = kTRUE);
	138
	139	void MakeAliceAllNew(Bool_t flagTPC =1,Bool_t flagMon=1);
	140	void MakeAliceCurrent(Int_t AlignResiduals = 0, Bool_t flagTPC =1);
e4f085eb	141	void AddTPC(Float_t phiResMean=0.1, Float_t zResMean=0.1, Int_t skip=1);
e4f085eb	142	void AddTRD(Float_t phiResMean=0.02, Float_t zResMean=2.5, Float_t lrEff=0.9);
36b05ae5	143	void RemoveTPC();
	144
	145	void SetBField(Float_t bfield) {fBField = bfield; }
	146	Float_t GetBField() const {return fBField; }
	147	void SetLhcUPCscale(Float_t lhcUPCscale) {fLhcUPCscale = lhcUPCscale; }
	148	Float_t GetLhcUPCscale() const { return fLhcUPCscale; }
	149	void SetParticleMass(Float_t particleMass) {fParticleMass = particleMass; }
	150	Float_t GetParticleMass() const { return fParticleMass; }
	151	void SetIntegrationTime(Float_t integrationTime) {fIntegrationTime = integrationTime; }
	152	Float_t GetIntegrationTime() const { return fIntegrationTime; }
	153	void SetMaxRadiusOfSlowDetectors(Float_t maxRadiusSlowDet) {fMaxRadiusSlowDet = maxRadiusSlowDet; }
	154	Float_t GetMaxRadiusOfSlowDetectors() const { return fMaxRadiusSlowDet; }
	155	void SetAvgRapidity(Float_t avgRapidity) {fAvgRapidity = avgRapidity; }
	156	Float_t GetAvgRapidity() const { return fAvgRapidity; }
	157	void SetConfidenceLevel(Float_t confLevel) {fConfLevel = confLevel; }
	158	Float_t GetConfidenceLevel() const { return fConfLevel; }
621913de	159
	160	void SetAtLeastHits(Int_t atLeast ) {fAtLeastHits = atLeast; }
	161	Int_t GetAtLeastHits() const { return fAtLeastHits; }
	162
36b05ae5	163	void SetAtLeastCorr(Int_t atLeastCorr ) {fAtLeastCorr = atLeastCorr; }
	164	Int_t GetAtLeastCorr() const { return fAtLeastCorr; }
	165	void SetAtLeastFake(Int_t atLeastFake ) {fAtLeastFake = atLeastFake; }
	166	Int_t GetAtLeastFake() const { return fAtLeastFake; }
	167
	168	void SetMaxSeedRadius(Double_t maxSeedRadius ) {fMaxSeedRadius = maxSeedRadius; }
	169	Int_t GetMaxSeedRadius() const { return fMaxSeedRadius; }
	170
	171	void SetptScale(Double_t ptScale ) {fptScale = ptScale; }
	172	Int_t GetptScale() const { return fptScale; }
	173
fb4ff059	174
36b05ae5	175
	176	void SetdNdEtaCent(Int_t dNdEtaCent ) {fdNdEtaCent = dNdEtaCent; }
	177	Float_t GetdNdEtaCent() const { return fdNdEtaCent; }
	178
	179
fb4ff059	180	Float_t GetNumberOfLayers() const {return fNumberOfLayers; }
36b05ae5	181	Float_t GetNumberOfActiveLayers() const {return fNumberOfActiveLayers; }
	182	Float_t GetNumberOfActiveITSLayers() const {return fNumberOfActiveITSLayers; }
	183
	184	void SolveViaBilloir(Int_t flagD0=1,Int_t print=1, Bool_t allPt=1, Double_t meanPt =0.095, char* detLayer=((char*)""));
fb4ff059	185	//
	186	Bool_t SolveTrack(TrackSol& ts);
	187	Bool_t CalcITSEff(TrackSol& ts, Bool_t verbose=kTRUE);
	188	Bool_t ExtrapolateToR(AliExternalTrackParam* probTr, double rTgt, double mass=0.14);
45fa8186	189	//
	190	void SetMinRadTrack(double r=132) { fMinRadTrack = r; }
	191	Double_t GetMinRadTrack() const { return fMinRadTrack;}
	192
	193	//
	194	//
36b05ae5	195	// Helper functions
	196	Double_t ThetaMCS ( Double_t mass, Double_t RadLength, Double_t momentum ) const;
	197	Double_t ProbGoodHit ( Double_t radius, Double_t searchRadiusRPhi, Double_t searchRadiusZ ) ;
	198	Double_t ProbGoodChiSqHit ( Double_t radius, Double_t searchRadiusRPhi, Double_t searchRadiusZ ) ;
	199	Double_t ProbGoodChiSqPlusConfHit ( Double_t radius, Double_t leff, Double_t searchRadiusRPhi, Double_t searchRadiusZ ) ;
	200	Double_t ProbNullChiSqPlusConfHit ( Double_t radius, Double_t leff, Double_t searchRadiusRPhi, Double_t searchRadiusZ ) ;
	201
	202	// Howard W. hit distribution and convolution integral
	203	Double_t Dist ( Double_t Z, Double_t radius ) ;
	204	Double_t HitDensity ( Double_t radius ) ;
	205	Double_t UpcHitDensity ( Double_t radius ) ;
	206	Double_t IntegratedHitDensity ( Double_t multiplicity, Double_t radius ) ;
	207	Double_t OneEventHitDensity ( Double_t multiplicity, Double_t radius ) const ;
	208	Double_t D0IntegratedEfficiency( Double_t pt, Double_t corrEfficiency[][400] ) const ;
	209
	210	TGraph* GetGraphMomentumResolution(Int_t color, Int_t linewidth=1);
	211	TGraph* GetGraphPointingResolution(Int_t axis,Int_t color, Int_t linewidth=1);
	212	TGraph* GetGraphPointingResolutionTeleEqu(Int_t axis,Int_t color, Int_t linewidth=1);
	213	TGraph* GetGraphLayerInfo(Int_t plot, Int_t color, Int_t linewidth=1);
	214
	215	TGraph* GetGraphImpactParam(Int_t mode, Int_t axis, Int_t color, Int_t linewidth=1);
	216
	217	TGraph* GetGraphRecoEfficiency(Int_t particle, Int_t color, Int_t linewidth=1);
	218	TGraph* GetGraphRecoFakes(Int_t particle,Int_t color, Int_t linewidth);
	219	TGraph* GetGraphRecoPurity(Int_t particle,Int_t color, Int_t linewidth);
	220
	221	TGraph* GetGraph(Int_t number, Int_t color, Int_t linewidth=1);
	222
	223	void MakeStandardPlots(Bool_t add =0, Int_t color=1, Int_t linewidth=1,Bool_t onlyPionEff=0);
	224
	225	// method to extend AliExternalTrackParam functionality
	226	static Bool_t GetXatLabR(AliExternalTrackParam* tr,Double_t r,Double_t &x, Double_t bz, Int_t dir=0);
	227	static Bool_t PropagateToR(AliExternalTrackParam* trc, double r, double b, int dir=0);
fb4ff059	228	Double_t* PrepareEffFakeKombinations(TMatrixD probKomb, TMatrixD probLay, double* prob=0);
36b05ae5	229
e4f085eb	230	Bool_t IsITSLayer(const TString& lname);
e4f085eb	231
f20edc66	232	static Bool_t verboseR;
36b05ae5	233	protected:
	234
	235	Int_t fNumberOfLayers; // total number of layers in the model
	236	Int_t fNumberOfActiveLayers; // number of active layers in the model
	237	Int_t fNumberOfActiveITSLayers; // number of active ITS layers in the model
	238	TList fLayers; // List of layer pointers
	239	Float_t fBField; // Magnetic Field in Tesla
	240	Float_t fLhcUPCscale; // UltraPeripheralElectrons: scale from RHIC to LHC
	241	Float_t fIntegrationTime; // electronics integration time
	242	Float_t fConfLevel; // Confidence Level for the tracking
	243	Float_t fAvgRapidity; // rapidity of the track (= mean)
	244	Float_t fParticleMass; // Particle used for tracking. Standard: mass of pion
	245	Double_t fMaxRadiusSlowDet; // Maximum radius for slow detectors. Fast detectors
	246	// and only fast detectors reside outside this radius.
621913de	247
621913de	248	Int_t fAtLeastHits; // min. number of hits for the track to account it
36b05ae5	249	Int_t fAtLeastCorr; // min. number of correct hits for the track to be "good"
	250	Int_t fAtLeastFake; // min. number of fake hits for the track to be "fake"
	251
	252	Double_t fMaxSeedRadius; // max seeding radius, e.g. to exclude TRD
	253	Double_t fptScale; // used for maxPt
	254
	255	Int_t fdNdEtaCent; // Multiplicity
	256
	257	enum {kMaxNumberOfDetectors = 200};
	258
	259	Double_t fTransMomenta[kNptBins]; // array of transverse momenta
	260	Double_t fMomentumRes[kNptBins]; // array of momentum resolution
	261	Double_t fResolutionRPhi[kNptBins]; // array of rphi resolution
	262	Double_t fResolutionZ[kNptBins]; // array of z resolution
	263	Double_t fDetPointRes[kMaxNumberOfDetectors][kNptBins]; // array of rphi resolution per layer
	264	Double_t fDetPointZRes[kMaxNumberOfDetectors][kNptBins]; // array of z resolution per layer
	265	Double_t fEfficiency[3][kNptBins]; // efficiency for different particles
	266	Double_t fFake[3][kNptBins]; // fake prob for different particles
	267
	268	Int_t kDetLayer; // layer for which a few more details are extracted
	269	Double_t fResolutionRPhiLay[kNptBins]; // array of rphi resolution
	270	Double_t fResolutionZLay[kNptBins]; // array of z resolution
	271	Double_t fEfficProlongLay[kNptBins]; // array of z resolution
	272
45fa8186	273	Double_t fMinRadTrack;
45fa8186	274
36b05ae5	275	static const Double_t kPtMinFix;
36b05ae5	276	static const Double_t kPtMaxFix;
36b05ae5	277
	278	ClassDef(DetectorK,1);
	279	};
	280
	281	#endif
	282