[u/mrichter/AliRoot.git] / STEER / AliITSPidParams.h

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

/* $Id: $ */

///////////////////////////////////////////////////////////////////
//                                                               //
// Class to store parameters of ITS response funcions            //
// Origin: F.Prino, Torino, prino@to.infn.it                     //
//                                                               //
///////////////////////////////////////////////////////////////////

#include <TFormula.h>
#include <TNamed.h>

class AliITSPidParams : public TNamed {

 public:
  AliITSPidParams();
  AliITSPidParams(Char_t * name);
  ~AliITSPidParams();

  void InitDefaults();
  Double_t GetLandauGausNormPdgCode(Double_t dedx, Int_t pdgCode, Double_t mom, Int_t lay) const;
  Double_t GetLandauGausNorm(Double_t dedx, Int_t partType, Double_t mom, Int_t lay) const;

  // pion setters
  void SetSDDPionMPV(TFormula* form){
    if(fSDDPionMPV) delete fSDDPionMPV;
    fSDDPionMPV=new TFormula(*form);
  }
  void SetSDDPionLandauWidth(TFormula* form){
    if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
    fSDDPionLandauWidth=new TFormula(*form);
  }
  void SetSDDPionGaussWidth(TFormula* form){
    if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
    fSDDPionGaussWidth=new TFormula(*form);
  }
  void SetSSDPionMPV(TFormula* form){
    if(fSSDPionMPV) delete fSSDPionMPV;
    fSSDPionMPV=new TFormula(*form);
  }
  void SetSSDPionLandauWidth(TFormula* form){
    if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
    fSSDPionLandauWidth=new TFormula(*form);
  }
  void SetSSDPionGaussWidth(TFormula* form){
    if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
    fSSDPionGaussWidth=new TFormula(*form);
  }

  // kaon setters
  void SetSDDKaonMPV(TFormula* form){
    if(fSDDKaonMPV) delete fSDDKaonMPV;
    fSDDKaonMPV=new TFormula(*form);
  }
  void SetSDDKaonLandauWidth(TFormula* form){
    if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
    fSDDKaonLandauWidth=new TFormula(*form);
  }
  void SetSDDKaonGaussWidth(TFormula* form){
    if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
    fSDDKaonGaussWidth=new TFormula(*form);
  }
  void SetSSDKaonMPV(TFormula* form){
    if(fSSDKaonMPV) delete fSSDKaonMPV;
    fSSDKaonMPV=new TFormula(*form);
  }
  void SetSSDKaonLandauWidth(TFormula* form){
    if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
    fSSDKaonLandauWidth=new TFormula(*form);
  }
  void SetSSDKaonGaussWidth(TFormula* form){
    if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
    fSSDKaonGaussWidth=new TFormula(*form);
  }


  // proton setters
  void SetSDDProtMPV(TFormula* form){
    if(fSDDProtMPV) delete fSDDProtMPV;
    fSDDProtMPV=new TFormula(*form);
  }
  void SetSDDProtLandauWidth(TFormula* form){
    if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
    fSDDProtLandauWidth=new TFormula(*form);
  }
  void SetSDDProtGaussWidth(TFormula* form){
    if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
    fSDDProtGaussWidth=new TFormula(*form);
  }
  void SetSSDProtMPV(TFormula* form){
    if(fSSDProtMPV) delete fSSDProtMPV;
    fSSDProtMPV=new TFormula(*form);
  }
  void SetSSDProtLandauWidth(TFormula* form){
    if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
    fSSDProtLandauWidth=new TFormula(*form);
  }
  void SetSSDProtGaussWidth(TFormula* form){
    if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
    fSSDProtGaussWidth=new TFormula(*form);
  }


  // pion getters
  Double_t GetSDDPionMPV(Double_t mom) const {
    return fSDDPionMPV->Eval(mom);
  }
  Double_t GetSDDPionLandauWidth(Double_t mom) const {
    return fSDDPionLandauWidth->Eval(mom);
  }
  Double_t GetSDDPionGaussWidth(Double_t mom) const {
    return fSDDPionGaussWidth->Eval(mom);
  }
  Double_t GetSSDPionMPV(Double_t mom) const {
    return fSSDPionMPV->Eval(mom);
  }
  Double_t GetSSDPionLandauWidth(Double_t mom) const {
    return fSSDPionLandauWidth->Eval(mom);
  }
  Double_t GetSSDPionGaussWidth(Double_t mom) const {
    return fSSDPionGaussWidth->Eval(mom);
  }

  // kaon getters
  Double_t GetSDDKaonMPV(Double_t mom) const {
    return fSDDKaonMPV->Eval(mom);
  }
  Double_t GetSDDKaonLandauWidth(Double_t mom) const {
    return fSDDKaonLandauWidth->Eval(mom);
  }
  Double_t GetSDDKaonGaussWidth(Double_t mom) const {
    return fSDDKaonGaussWidth->Eval(mom);
  }
  Double_t GetSSDKaonMPV(Double_t mom) const {
    return fSSDKaonMPV->Eval(mom);
  }
  Double_t GetSSDKaonLandauWidth(Double_t mom) const {
    return fSSDKaonLandauWidth->Eval(mom);
  }
  Double_t GetSSDKaonGaussWidth(Double_t mom) const {
    return fSSDKaonGaussWidth->Eval(mom);
  }

  // proton getters
  Double_t GetSDDProtMPV(Double_t mom) const {
    return fSDDProtMPV->Eval(mom);
  }
  Double_t GetSDDProtLandauWidth(Double_t mom) const {
    return fSDDProtLandauWidth->Eval(mom);
  }
  Double_t GetSDDProtGaussWidth(Double_t mom) const {
    return fSDDProtGaussWidth->Eval(mom);
  }
  Double_t GetSSDProtMPV(Double_t mom) const {
    return fSSDProtMPV->Eval(mom);
  }
  Double_t GetSSDProtLandauWidth(Double_t mom) const {
    return fSSDProtLandauWidth->Eval(mom);
  }
  Double_t GetSSDProtGaussWidth(Double_t mom) const {
    return fSSDProtGaussWidth->Eval(mom);
  }

 private:

  AliITSPidParams(const AliITSPidParams& rec);
  AliITSPidParams& operator=(const AliITSPidParams &source);

  TFormula* fSDDPionMPV;         // pion dE/dx MPV vs. p in SDD
  TFormula* fSDDPionLandauWidth; // pion dE/dx Landau width vs. p in SDD
  TFormula* fSDDPionGaussWidth;  // pion dE/dx Gaussian width vs. p in SDD

  TFormula* fSSDPionMPV;         // pion dE/dx MPV vs. p in SSD
  TFormula* fSSDPionLandauWidth; // pion dE/dx Landau width vs. p in SSD
  TFormula* fSSDPionGaussWidth;  // pion dE/dx Gaussian width vs. p in SSD

  TFormula* fSDDKaonMPV;         // kaon dE/dx MPV vs. p in SDD
  TFormula* fSDDKaonLandauWidth; // kaon dE/dx Landau width vs. p in SDD
  TFormula* fSDDKaonGaussWidth;  // kaon dE/dx Gaussian width vs. p in SDD

  TFormula* fSSDKaonMPV;         // kaon dE/dx MPV vs. p in SSD
  TFormula* fSSDKaonLandauWidth; // kaon dE/dx Landau width vs. p in SSD
  TFormula* fSSDKaonGaussWidth;  // kaon dE/dx Gaussian width vs. p in SSD

  TFormula* fSDDProtMPV;         // kaon dE/dx MPV vs. p in SDD
  TFormula* fSDDProtLandauWidth; // kaon dE/dx Landau width vs. p in SDD
  TFormula* fSDDProtGaussWidth;  // kaon dE/dx Gaussian width vs. p in SDD

  TFormula* fSSDProtMPV;         // kaon dE/dx MPV vs. p in SSD
  TFormula* fSSDProtLandauWidth; // kaon dE/dx Landau width vs. p in SSD
  TFormula* fSSDProtGaussWidth;  // kaon dE/dx Gaussian width vs. p in SSD

  ClassDef(AliITSPidParams,1);
};
#endif
Commit	Line	Data
b536a002	1	#ifndef ALIITSPIDPARAMS_H
	2	#define ALIITSPIDPARAMS_H
	3	/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id: $ */
	7
	8	///////////////////////////////////////////////////////////////////
	9	// //
	10	// Class to store parameters of ITS response funcions //
	11	// Origin: F.Prino, Torino, prino@to.infn.it //
	12	// //
	13	///////////////////////////////////////////////////////////////////
	14
	15	#include <TFormula.h>
	16	#include <TNamed.h>
	17
	18	class AliITSPidParams : public TNamed {
	19
	20	public:
	21	AliITSPidParams();
	22	AliITSPidParams(Char_t * name);
	23	~AliITSPidParams();
	24
	25	void InitDefaults();
	26	Double_t GetLandauGausNormPdgCode(Double_t dedx, Int_t pdgCode, Double_t mom, Int_t lay) const;
	27	Double_t GetLandauGausNorm(Double_t dedx, Int_t partType, Double_t mom, Int_t lay) const;
	28
	29	// pion setters
	30	void SetSDDPionMPV(TFormula* form){
	31	if(fSDDPionMPV) delete fSDDPionMPV;
	32	fSDDPionMPV=new TFormula(*form);
	33	}
	34	void SetSDDPionLandauWidth(TFormula* form){
	35	if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
	36	fSDDPionLandauWidth=new TFormula(*form);
	37	}
	38	void SetSDDPionGaussWidth(TFormula* form){
	39	if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
	40	fSDDPionGaussWidth=new TFormula(*form);
	41	}
	42	void SetSSDPionMPV(TFormula* form){
	43	if(fSSDPionMPV) delete fSSDPionMPV;
	44	fSSDPionMPV=new TFormula(*form);
	45	}
	46	void SetSSDPionLandauWidth(TFormula* form){
	47	if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
	48	fSSDPionLandauWidth=new TFormula(*form);
	49	}
	50	void SetSSDPionGaussWidth(TFormula* form){
	51	if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
	52	fSSDPionGaussWidth=new TFormula(*form);
	53	}
	54
	55	// kaon setters
	56	void SetSDDKaonMPV(TFormula* form){
	57	if(fSDDKaonMPV) delete fSDDKaonMPV;
	58	fSDDKaonMPV=new TFormula(*form);
	59	}
	60	void SetSDDKaonLandauWidth(TFormula* form){
	61	if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
	62	fSDDKaonLandauWidth=new TFormula(*form);
	63	}
	64	void SetSDDKaonGaussWidth(TFormula* form){
65	if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
66	fSDDKaonGaussWidth=new TFormula(*form);
67	}
68	void SetSSDKaonMPV(TFormula* form){
69	if(fSSDKaonMPV) delete fSSDKaonMPV;
70	fSSDKaonMPV=new TFormula(*form);
71	}
72	void SetSSDKaonLandauWidth(TFormula* form){
73	if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
74	fSSDKaonLandauWidth=new TFormula(*form);
75	}
76	void SetSSDKaonGaussWidth(TFormula* form){
77	if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
78	fSSDKaonGaussWidth=new TFormula(*form);
79	}
80
81
82	// proton setters
83	void SetSDDProtMPV(TFormula* form){
84	if(fSDDProtMPV) delete fSDDProtMPV;
85	fSDDProtMPV=new TFormula(*form);
86	}
87	void SetSDDProtLandauWidth(TFormula* form){
88	if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
89	fSDDProtLandauWidth=new TFormula(*form);
90	}
91	void SetSDDProtGaussWidth(TFormula* form){
92	if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
93	fSDDProtGaussWidth=new TFormula(*form);
94	}
95	void SetSSDProtMPV(TFormula* form){
96	if(fSSDProtMPV) delete fSSDProtMPV;
97	fSSDProtMPV=new TFormula(*form);
98	}
99	void SetSSDProtLandauWidth(TFormula* form){
100	if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
101	fSSDProtLandauWidth=new TFormula(*form);
102	}
103	void SetSSDProtGaussWidth(TFormula* form){
104	if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
105	fSSDProtGaussWidth=new TFormula(*form);
106	}
107
108
109	// pion getters
110	Double_t GetSDDPionMPV(Double_t mom) const {
111	return fSDDPionMPV->Eval(mom);
112	}
113	Double_t GetSDDPionLandauWidth(Double_t mom) const {
114	return fSDDPionLandauWidth->Eval(mom);
115	}
116	Double_t GetSDDPionGaussWidth(Double_t mom) const {
117	return fSDDPionGaussWidth->Eval(mom);
118	}
119	Double_t GetSSDPionMPV(Double_t mom) const {
120	return fSSDPionMPV->Eval(mom);
121	}
122	Double_t GetSSDPionLandauWidth(Double_t mom) const {
123	return fSSDPionLandauWidth->Eval(mom);
124	}
125	Double_t GetSSDPionGaussWidth(Double_t mom) const {
126	return fSSDPionGaussWidth->Eval(mom);
127	}
128
129	// kaon getters
130	Double_t GetSDDKaonMPV(Double_t mom) const {
131	return fSDDKaonMPV->Eval(mom);
132	}
133	Double_t GetSDDKaonLandauWidth(Double_t mom) const {
134	return fSDDKaonLandauWidth->Eval(mom);
135	}
136	Double_t GetSDDKaonGaussWidth(Double_t mom) const {
137	return fSDDKaonGaussWidth->Eval(mom);
138	}
139	Double_t GetSSDKaonMPV(Double_t mom) const {
140	return fSSDKaonMPV->Eval(mom);
141	}
142	Double_t GetSSDKaonLandauWidth(Double_t mom) const {
143	return fSSDKaonLandauWidth->Eval(mom);
144	}
145	Double_t GetSSDKaonGaussWidth(Double_t mom) const {
146	return fSSDKaonGaussWidth->Eval(mom);
147	}
148
149	// proton getters
150	Double_t GetSDDProtMPV(Double_t mom) const {
151	return fSDDProtMPV->Eval(mom);
152	}
153	Double_t GetSDDProtLandauWidth(Double_t mom) const {
154	return fSDDProtLandauWidth->Eval(mom);
155	}
156	Double_t GetSDDProtGaussWidth(Double_t mom) const {
157	return fSDDProtGaussWidth->Eval(mom);
158	}
159	Double_t GetSSDProtMPV(Double_t mom) const {
160	return fSSDProtMPV->Eval(mom);
161	}
162	Double_t GetSSDProtLandauWidth(Double_t mom) const {
163	return fSSDProtLandauWidth->Eval(mom);
164	}
165	Double_t GetSSDProtGaussWidth(Double_t mom) const {
166	return fSSDProtGaussWidth->Eval(mom);
167	}
168
169	private:
170
171	AliITSPidParams(const AliITSPidParams& rec);
172	AliITSPidParams& operator=(const AliITSPidParams &source);
173
174	TFormula* fSDDPionMPV; // pion dE/dx MPV vs. p in SDD
175	TFormula* fSDDPionLandauWidth; // pion dE/dx Landau width vs. p in SDD
176	TFormula* fSDDPionGaussWidth; // pion dE/dx Gaussian width vs. p in SDD
177
178	TFormula* fSSDPionMPV; // pion dE/dx MPV vs. p in SSD
179	TFormula* fSSDPionLandauWidth; // pion dE/dx Landau width vs. p in SSD
180	TFormula* fSSDPionGaussWidth; // pion dE/dx Gaussian width vs. p in SSD
181
182	TFormula* fSDDKaonMPV; // kaon dE/dx MPV vs. p in SDD
183	TFormula* fSDDKaonLandauWidth; // kaon dE/dx Landau width vs. p in SDD
184	TFormula* fSDDKaonGaussWidth; // kaon dE/dx Gaussian width vs. p in SDD
185
186	TFormula* fSSDKaonMPV; // kaon dE/dx MPV vs. p in SSD
187	TFormula* fSSDKaonLandauWidth; // kaon dE/dx Landau width vs. p in SSD
188	TFormula* fSSDKaonGaussWidth; // kaon dE/dx Gaussian width vs. p in SSD
189
190	TFormula* fSDDProtMPV; // kaon dE/dx MPV vs. p in SDD
191	TFormula* fSDDProtLandauWidth; // kaon dE/dx Landau width vs. p in SDD
192	TFormula* fSDDProtGaussWidth; // kaon dE/dx Gaussian width vs. p in SDD
193
194	TFormula* fSSDProtMPV; // kaon dE/dx MPV vs. p in SSD
195	TFormula* fSSDProtLandauWidth; // kaon dE/dx Landau width vs. p in SSD
196	TFormula* fSSDProtGaussWidth; // kaon dE/dx Gaussian width vs. p in SSD
197
198	ClassDef(AliITSPidParams,1);
199	};
200	#endif