Hall-D Software  alpha
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
FitSpectra.C
Go to the documentation of this file.
1 int gRoutineSetupFlag = 0;
2 int gDrawFlag = 2; //0 = none, 1 = all, 2 = all but 1d-fits, 3 = only final fit
3 
4 void Setup_Routines(){
5  if(gRoutineSetupFlag == 1)
6  return;
7 
8  gSystem->Load("$(DECAYDRAW_PATH)/depends/$(OS_NAME)/libDecayDraw.so");
9  gROOT->LoadMacro("$(DECAYDRAW_PATH)/DecayDrawHistograms.C");
10  gROOT->LoadMacro("$(DECAYDRAW_PATH)/DecayDrawUtilities.C");
11  Setup_dqfFitter();
12 
13  DecayDrawInstructions *locDrawInstructions;
14  //default 1d mass fit & counts (widescreen)
15  locDrawInstructions = new DecayDrawInstructions();
16  locDrawInstructions->Set_OptFit(102);
17  locDrawInstructions->Set_NumPadsPerCanvas(25);
18  locDrawInstructions->Set_CanvasWidth(1400);
19  Set_ddhTemplateDrawInstructions(locDrawInstructions, 0);
20  //fit result graphs
21  locDrawInstructions = new DecayDrawInstructions();
22  locDrawInstructions->Set_DrawOption("ap");
23  locDrawInstructions->Set_OptFit(102);
24  locDrawInstructions->Set_HistOrGraphColor(1);
25  locDrawInstructions->Set_MarkerStyle(20);
26  locDrawInstructions->Set_MarkerSize(1);
27  Set_ddhTemplateDrawInstructions(locDrawInstructions, 1);
28 
29  gRoutineSetupFlag = 1;
30 }
31 
32 void Draw_ConfidenceLevels(const string& locFileName, int locCDCFlag){
33  Setup_Routines();
34 
35  TH1F* locHist;
36  TFile *locFile = new TFile(locFileName.c_str(), "READ");
37  unsigned int locNumHitsBins = (locCDCFlag == 1) ? 6 : 4;
38  unsigned int locNumBetaGammaBins = 6;
39  ostringstream locHistName;
40 
41  DecayDrawInstructions *locDrawInstructions;
42  locDrawInstructions = new DecayDrawInstructions();
43  locDrawInstructions->Set_OptFit(102);
44  locDrawInstructions->Set_NumPadsPerCanvas(25);
45  locDrawInstructions->Set_CanvasWidth(1400);
46  locDrawInstructions->Set_HistOrGraphColor(kTeal);
47  locDrawInstructions->Set_LogYFlag(1);
48 /*
49  if(locCDCFlag == 1)
50  locHist = (TH1F*)locFile->Get("dSelectorHist_ConfidenceLevel_CDC");
51  else
52  locHist = (TH1F*)locFile->Get("dSelectorHist_ConfidenceLevel_FDC");
53  DrawAndSave_ddhHistOrGraph<TH1F>(locHist, locDrawInstructions, 0);
54 
55  for(unsigned int loc_i = 0; loc_i < locNumHitsBins; loc_i++){
56  locHistName.str("");
57  locHistName << "dSelectorHist_ConfidenceLevel_";
58  if(locCDCFlag == 1)
59  locHistName << "CDC_" << 2*loc_i + 4 << "Hits";
60  else
61  locHistName << "FDC_" << 3*loc_i + 3 << "Hits";
62  locHist = (TH1F*)locFile->Get(locHistName.str().c_str());
63  DrawAndSave_ddhHistOrGraph<TH1F>(locHist, locDrawInstructions, 0);
64  }
65 */
66  for(unsigned int loc_i = 0; loc_i < locNumBetaGammaBins; loc_i++){
67  locHistName.str("");
68  locHistName << "dSelectorHist_ConfidenceLevel_";
69  if(locCDCFlag == 1)
70  locHistName << "CDC_BetaGammaBin" << loc_i + 1;
71  else
72  locHistName << "FDC_BetaGammaBin" << loc_i + 1;
73  locHist = (TH1F*)locFile->Get(locHistName.str().c_str());
74  DrawAndSave_ddhHistOrGraph<TH1F>(locHist, locDrawInstructions, 0);
75  }
76 }
77 
78 void Fit_dEdxUncertainty_Mean(const string& locFileName, int locParticleFlag, int locCDCFlag, int locDrawFlag = 1){
79  Setup_Routines();
80  gDrawFlag = locDrawFlag;
81 
82  TFile *locFile = new TFile(locFileName.c_str(), "READ");
83  TH2F *locHist;
84  TF1 *locFunc;
85 
86  float locMass, locMaximumMomentum, locMinBetaGamma, locMaxBeta, locMaxBetaGamma;
87  unsigned int locNumBinsToMergeX = 1, locNumBinsToMergeY = 1;
88  int locFitFlag;
89  TGraphErrors *locGraphErrors_Mean, *locGraphErrors_Sigma;
90  TObjArray *locdEdxArray_2D, *locdEdxArray_Means, *locdEdxArray_Sigmas;
91  DecayDrawInstructions* locDrawInstructions;
92  ostringstream locHistName, locFuncName;
93  double locFitRangeMin, locFitRangeMax;
94  vector<double> locInputParams;
95  double locdEdxAxisMin_Mean, locdEdxAxisMax_Mean, locdEdxAxisMin_Sigma, locdEdxAxisMax_Sigma, locdEdxAxisMax_2D;
96 
97  if(locParticleFlag == 1){ //proton
98  locMass = 0.93827203;
99  locMaximumMomentum = 2.0;
100  locMinBetaGamma = 0.3;
101  locNumBinsToMergeX = 4;
102  locNumBinsToMergeY = 2;
103  locFitFlag = 14;
104  locdEdxAxisMax_2D = 20.0;
105  locdEdxAxisMin_Mean = 1.0;
106  locdEdxAxisMax_Mean = 15.0;
107  locdEdxAxisMin_Sigma = 0.0;
108  locdEdxAxisMax_Sigma = 4.0;
109  locFitRangeMin = 0.3;
110  locFitRangeMax = 2.1;
111 
112  locInputParams.resize(4);
113  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.2; locInputParams[3] = 0.0;
114  }
115  if(locParticleFlag == 2){ //pi- or pi+
116  locMass = 0.1395700;
117  locMaximumMomentum = 2.0;
118  locMinBetaGamma = 0.0;
119  locdEdxAxisMax_2D = 20.0;
120  locdEdxAxisMin_Mean = 1.3;
121  locdEdxAxisMax_Mean = 1.8;
122  locdEdxAxisMin_Sigma = 0.1;
123  locdEdxAxisMax_Sigma = 0.65;
124  locNumBinsToMergeX = 32;
125  locNumBinsToMergeY = 1;
126  locFitRangeMin = 1.0;
127  locFitRangeMax = 14.5;
128  locFitFlag = 9;
129 
130  locInputParams.resize(4);
131  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.3; locInputParams[3] = 0.003;
132  }
133  if(locParticleFlag == 3){ //k+
134  locMass = 0.493677;
135  locMaximumMomentum = 2.0;
136  locMinBetaGamma = 0.0;
137  locdEdxAxisMax_2D = 20.0;
138  locdEdxAxisMin_Mean = 1.2;
139  locdEdxAxisMax_Mean = 2.6;
140  locdEdxAxisMin_Sigma = 0.1;
141  locdEdxAxisMax_Sigma = 0.65;
142  locNumBinsToMergeX = 8;
143  locNumBinsToMergeY = 1;
144  locFitRangeMin = (locCDCFlag == 0) ? 0.9 : 0.65;
145  locFitRangeMax = 4.0;
146  locFitFlag = 9;
147 
148  locInputParams.resize(4);
149  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.3; locInputParams[3] = 0.003;
150  }
151  locMaxBeta = locMaximumMomentum/sqrt(locMaximumMomentum*locMaximumMomentum + locMass*locMass);
152  locMaxBetaGamma = locMaxBeta/sqrt(1.0 - locMaxBeta*locMaxBeta);
153 
154  if(locCDCFlag == 1)
155  locHist = (TH2F*)locFile->Get("dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC");
156  else
157  locHist = (TH2F*)locFile->Get("dSelectorHist_dEdxVsBetaGamma_HitsCutoff_FDC");
158  locHist->Rebin2D(locNumBinsToMergeX, locNumBinsToMergeY);
159  locHist->GetXaxis()->SetRangeUser(locMinBetaGamma, locMaxBetaGamma);
160  locHist->GetYaxis()->SetRangeUser(0.0, locdEdxAxisMax_2D);
161  Fit_ToGaussians(locHist, locGraphErrors_Mean, locGraphErrors_Sigma, locFitFlag);
162  locGraphErrors_Mean->SetTitle("");
163  locGraphErrors_Sigma->SetTitle("");
164 
165 
166  if((locParticleFlag == 1) || (locParticleFlag == 3)){ //p, k+
167  Set_dqfDrawFuncsFlag(3);
168  Fit_dqfSignalPeak_Graph(locGraphErrors_Mean, 5, 1, locFitRangeMin, locFitRangeMax, locInputParams);
169  locFuncName.str("");
170  locFuncName << locGraphErrors_Mean->GetName() << "_fitfunc";
171  locFunc = locGraphErrors_Mean->GetFunction(locFuncName.str().c_str());
172  cout << locFunc->GetParameter(1) << ", " << locFunc->GetParameter(2) << ", " << locFunc->GetParameter(4) << ", " << locFunc->GetParameter(5) << endl;
173  Set_dqfDrawFuncsFlag(0);
174  }
175 
176 /*
177  locFunc = new TF1("gead", "[0]*log(x*x)/(x*x) + [1] + [2]*x", 3.0, 14.0);
178  locGraphErrors_Mean->Fit(locFunc, "QRN+SEX0");
179  locGraphErrors_Mean->GetListOfFunctions()->Add(locFunc);
180 */
181 
182  locDrawInstructions = new DecayDrawInstructions();
183  *locDrawInstructions = *(Get_ddhTemplateDrawInstructions(1));
184 
185  if((gDrawFlag == 1) || (gDrawFlag == 2))
186  DrawAndSave_ddhHistOrGraph<TH2F>(locHist, 0, "COLZ");
187  if((gDrawFlag == 1) || (gDrawFlag == 2) || (gDrawFlag == 3)){
188  locDrawInstructions->Set_YRangeMin(locdEdxAxisMin_Mean);
189  locDrawInstructions->Set_YRangeMax(locdEdxAxisMax_Mean);
190  DrawAndSave_ddhHistOrGraph<TGraphErrors>(locGraphErrors_Mean, Get_ddhTemplateDrawInstructions(1), 1);
191  locDrawInstructions->Set_YRangeMin(locdEdxAxisMin_Sigma);
192  locDrawInstructions->Set_YRangeMax(locdEdxAxisMax_Sigma);
193  DrawAndSave_ddhHistOrGraph<TGraphErrors>(locGraphErrors_Sigma, Get_ddhTemplateDrawInstructions(1), 1);
194  }
195 
196 }
197 
198 void Fit_dEdxUncertainty_FDC_NumHitsBinCompare(const string& locFileName, int locParticleFlag, int locDrawFlag = 1);
199 void Fit_dEdxUncertainty_FDC_NumHitsBinCompare(const string& locFileName, int locParticleFlag, int locDrawFlag){
200  Setup_Routines();
201  gDrawFlag = locDrawFlag;
202 
203  unsigned int locNumNumHitsBins = 4;
204  TFile *locFile = new TFile(locFileName.c_str(), "READ");
205  TH2F *locHist;
206  TF1 *locFunc;
207 
208  float locMass, locMaximumMomentum, locMinBetaGamma, locMaxBeta, locMaxBetaGamma;
209  unsigned int locNumBinsToMergeX = 1, locNumBinsToMergeY = 1;
210  int locFitFlag;
211  TGraphErrors *locGraphErrors_Mean, *locGraphErrors_Sigma;
212  TObjArray *locdEdxArray_2D, *locdEdxArray_Means, *locdEdxArray_Sigmas;
213  vector<int> locHistColors(locNumNumHitsBins, 1);
214  vector<int> locFitFlags(locNumNumHitsBins, 0);
215  vector<string> locLegendNames(locNumNumHitsBins, "");
216  DecayDrawInstructions* locDrawInstructions;
217  ostringstream locHistName, locFuncName;
218  double locFitRangeMin, locFitRangeMax;
219  vector<double> locInputParams;
220  double locdEdxAxisMin_Mean, locdEdxAxisMax_Mean, locdEdxAxisMin_Sigma, locdEdxAxisMax_Sigma, locdEdxAxisMax_2D;
221  vector<int> locNumBinsToMergeXVector(locNumNumHitsBins, 1);
222  vector<double> locFitRangeMinVector(locNumNumHitsBins, 0.0);
223 
224  if(locParticleFlag == 1){ //proton
225  locMass = 0.93827203;
226  locMaximumMomentum = 2.0;
227  locMinBetaGamma = 0.3;
228  locNumBinsToMergeX = 4;
229  locNumBinsToMergeY = 2;
230  locFitFlag = 1;
231  locdEdxAxisMax_2D = 20.0;
232  locdEdxAxisMin_Mean = 1.0;
233  locdEdxAxisMax_Mean = 15.0;
234  locdEdxAxisMin_Sigma = 0.0;
235  locdEdxAxisMax_Sigma = 4.0;
236 // locFitRangeMin = 0.6;
237  locFitRangeMax = 2.1;
238  locFitRangeMinVector[0] = 0.5; locFitRangeMinVector[1] = 0.5; locFitRangeMinVector[2] = 0.35; locFitRangeMinVector[3] = 0.48;
239 
240  locFitFlags[0] = 1; locFitFlags[1] = 2; locFitFlags[2] = 4; locFitFlags[3] = 2;
241  locInputParams.resize(4);
242  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.2; locInputParams[3] = 0.0;
243  locNumBinsToMergeXVector[0] = 8; locNumBinsToMergeXVector[1] = 8; locNumBinsToMergeXVector[2] = 8; locNumBinsToMergeXVector[3] = 4;
244  }
245  if(locParticleFlag == 2){ //pi- or pi+
246  locMass = 0.1395700;
247  locMaximumMomentum = 2.0;
248  locMinBetaGamma = 0.0;
249  locdEdxAxisMax_2D = 20.0;
250  locdEdxAxisMin_Mean = 1.3;
251  locdEdxAxisMax_Mean = 1.8;
252  locdEdxAxisMin_Sigma = 0.1;
253  locdEdxAxisMax_Sigma = 0.65;
254  locNumBinsToMergeX = 32;
255  locNumBinsToMergeY = 1;
256 // locFitRangeMin = 1.0;
257  locFitRangeMax = 14.5;
258  locFitRangeMinVector[0] = 1.0; locFitRangeMinVector[1] = 0.4; locFitRangeMinVector[2] = 0.4; locFitRangeMinVector[3] = 0.75;
259 
260  locFitFlags[0] = 8; locFitFlags[1] = 3; locFitFlags[2] = 9; locFitFlags[3] = 9;
261  locInputParams.resize(4);
262  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.3; locInputParams[3] = 0.003;
263  locNumBinsToMergeXVector[0] = 32; locNumBinsToMergeXVector[1] = 32; locNumBinsToMergeXVector[2] = 32; locNumBinsToMergeXVector[3] = 32;
264  }
265  if(locParticleFlag == 3){ //K+
266  locMass = 0.493677;
267  locMaximumMomentum = 2.0;
268  locMinBetaGamma = 0.0;
269  locdEdxAxisMax_2D = 20.0;
270  locdEdxAxisMin_Mean = 1.3;
271  locdEdxAxisMax_Mean = 1.8;
272  locdEdxAxisMin_Sigma = 0.1;
273  locdEdxAxisMax_Sigma = 0.65;
274  locNumBinsToMergeX = 8;
275  locNumBinsToMergeY = 1;
276 // locFitRangeMin = 1.0;
277  locFitRangeMax = 4.1;
278  locFitRangeMinVector[0] = 1.0; locFitRangeMinVector[1] = 1.0; locFitRangeMinVector[2] = 1.0; locFitRangeMinVector[3] = 1.0;
279 
280  locFitFlags[0] = 15; locFitFlags[1] = 16; locFitFlags[2] = 17; locFitFlags[3] = 18;
281  locInputParams.resize(4);
282  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.3; locInputParams[3] = 0.003;
283  locNumBinsToMergeXVector[0] = 16; locNumBinsToMergeXVector[1] = 16; locNumBinsToMergeXVector[2] = 16; locNumBinsToMergeXVector[3] = 16;
284  }
285  locMaxBeta = locMaximumMomentum/sqrt(locMaximumMomentum*locMaximumMomentum + locMass*locMass);
286  locMaxBetaGamma = locMaxBeta/sqrt(1.0 - locMaxBeta*locMaxBeta);
287 
288  TObjArray *locdEdxArray_2D = new TObjArray(locNumNumHitsBins);
289  TObjArray *locdEdxArray_Means = new TObjArray(locNumNumHitsBins);
290  TObjArray *locdEdxArray_Sigmas = new TObjArray(locNumNumHitsBins);
291 
292  for(unsigned int loc_i = 0; loc_i < locNumNumHitsBins; loc_i++){
293  locHistName.str("");
294  if(loc_i == 0)
295  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_FDC_3Hits";
296  if(loc_i == 1)
297  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_FDC_6Hits";
298  if(loc_i == 2)
299  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_FDC_9Hits";
300  if(loc_i == 3)
301  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_FDC_12Hits";
302  locHist = (TH2F*)locFile->Get(locHistName.str().c_str());
303  locHist->Rebin2D(locNumBinsToMergeXVector[loc_i], locNumBinsToMergeY);
304  locHist->GetXaxis()->SetRangeUser(locMinBetaGamma, locMaxBetaGamma);
305  locHist->GetYaxis()->SetRangeUser(0.0, locdEdxAxisMax_2D);
306  Fit_ToGaussians(locHist, locGraphErrors_Mean, locGraphErrors_Sigma, locFitFlags[loc_i]);
307  locGraphErrors_Mean->SetTitle("");
308  locGraphErrors_Sigma->SetTitle("");
309 
310  Set_dqfDrawFuncsFlag(3);
311  if((locParticleFlag == 1) && ((loc_i == 1) || (loc_i == 0))){ //cheat!
312  double *locErrors = locGraphErrors_Sigma->GetEY();
313  locErrors[3] /= 40.0;
314  }
315 
316  Fit_dqfSignalPeak_Graph(locGraphErrors_Sigma, 5, 1, locFitRangeMinVector[loc_i], locFitRangeMax, locInputParams);
317 // Fit_dqfSignalPeak_Graph(locGraphErrors_Sigma, 5, -1, locFitRangeMin, locFitRangeMax, locInputParams); //for exponential
318 // Fit_dqfSignalPeak_Graph(locGraphErrors_Sigma, 0, 1, locFitRangeMin, locFitRangeMax, locInputParams); //for linear
319  Set_dqfDrawFuncsFlag(0);
320  locFuncName.str("");
321  locFuncName << locGraphErrors_Sigma->GetName() << "_fitfunc";
322  locFunc = locGraphErrors_Sigma->GetFunction(locFuncName.str().c_str());
323  cout << locFunc->GetParameter(1) << ", " << locFunc->GetParameter(2) << ", " << locFunc->GetParameter(4) << ", " << locFunc->GetParameter(5) << endl;
324 
325  locdEdxArray_2D->AddAt(locHist, loc_i);
326  locdEdxArray_Means->AddAt(locGraphErrors_Mean, loc_i);
327  locdEdxArray_Sigmas->AddAt(locGraphErrors_Sigma, loc_i);
328  locHistColors[loc_i] = loc_i + 1;
329  locLegendNames[loc_i] = ((TH2F*)(*locdEdxArray_2D)[loc_i])->GetTitle();
330  }
331 
332  locDrawInstructions = new DecayDrawInstructions();
333  *locDrawInstructions = *(Get_ddhTemplateDrawInstructions(1));
334  locDrawInstructions->Set_HistOrGraphColorVector(locHistColors);
335  locDrawInstructions->Set_LegendNameVector(locLegendNames);
336  locDrawInstructions->Set_DrawOption("p");
337 
338 // if((gDrawFlag == 1) || (gDrawFlag == 2))
339 // DrawAndSave_ddhHistOrGraphArray<TH2F>(locdEdxArray_2D, 0, "COLZ");
340  if((gDrawFlag == 1) || (gDrawFlag == 2) || (gDrawFlag == 3)){
341  locDrawInstructions->Set_YRangeMin(locdEdxAxisMin_Mean);
342  locDrawInstructions->Set_YRangeMax(locdEdxAxisMax_Mean);
343 // DrawAndSave_ddhHistOrGraphSuperimposition<TGraphErrors>(locdEdxArray_Means, locDrawInstructions, 1);
344  locDrawInstructions->Set_YRangeMin(locdEdxAxisMin_Sigma);
345  locDrawInstructions->Set_YRangeMax(locdEdxAxisMax_Sigma);
346  DrawAndSave_ddhHistOrGraphSuperimposition<TGraphErrors>(locdEdxArray_Sigmas, locDrawInstructions, 1);
347  }
348 }
349 
350 void Fit_dEdxUncertainty_CDC_NumHitsBinCompare(const string& locFileName, int locParticleFlag, int locDrawFlag = 1);
351 void Fit_dEdxUncertainty_CDC_NumHitsBinCompare(const string& locFileName, int locParticleFlag, int locDrawFlag){
352  Setup_Routines();
353  gDrawFlag = locDrawFlag;
354 
355  unsigned int locNumNumHitsBins = 6;
356  TFile *locFile = new TFile(locFileName.c_str(), "READ");
357  TH2F *locHist;
358  TF1 *locFunc;
359 
360  float locMass, locMaximumMomentum, locMinBetaGamma, locMaxBeta, locMaxBetaGamma;
361  unsigned int locNumBinsToMergeX = 1, locNumBinsToMergeY = 1;
362  int locFitFlag;
363  TGraphErrors *locGraphErrors_Mean, *locGraphErrors_Sigma;
364  TObjArray *locdEdxArray_2D, *locdEdxArray_Means, *locdEdxArray_Sigmas;
365  vector<int> locHistColors(locNumNumHitsBins, 1);
366  vector<int> locFitFlags(locNumNumHitsBins, 0);
367  vector<string> locLegendNames(locNumNumHitsBins, "");
368  DecayDrawInstructions* locDrawInstructions;
369  ostringstream locHistName, locFuncName;
370  double locFitRangeMin, locFitRangeMax;
371  vector<double> locInputParams;
372  double locdEdxAxisMin_Mean, locdEdxAxisMax_Mean, locdEdxAxisMin_Sigma, locdEdxAxisMax_Sigma, locdEdxAxisMax_2D;
373  vector<int> locNumBinsToMergeXVector(locNumNumHitsBins, 1);
374  vector<double> locFitRangeMinVector(locNumNumHitsBins, 0.0);
375 
376  if(locParticleFlag == 1){ //proton
377  locMass = 0.93827203;
378  locMaximumMomentum = 2.0;
379  locMinBetaGamma = 0.3;
380  locFitFlag = 1;
381  locdEdxAxisMax_2D = 20.0;
382  locdEdxAxisMin_Mean = 1.0;
383  locdEdxAxisMax_Mean = 15.0;
384  locdEdxAxisMin_Sigma = 0.0;
385  locdEdxAxisMax_Sigma = 3.5;
386  locFitRangeMin = 0.45;
387  locFitRangeMax = 2.15;
388  locFitRangeMinVector[0] = 0.42; locFitRangeMinVector[1] = 0.42; locFitRangeMinVector[2] = 0.25;
389  locFitRangeMinVector[3] = 0.25; locFitRangeMinVector[4] = 0.25; locFitRangeMinVector[5] = 0.25;
390 
391  locFitFlags[0] = 12; locFitFlags[1] = 13; locFitFlags[2] = 7; locFitFlags[3] = 10; locFitFlags[4] = 10; locFitFlags[5] = 10;
392  locInputParams.resize(4);
393  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.2; locInputParams[3] = 0.0;
394  locNumBinsToMergeXVector[0] = 8; locNumBinsToMergeXVector[1] = 8; locNumBinsToMergeXVector[2] = 4;
395  locNumBinsToMergeXVector[3] = 4; locNumBinsToMergeXVector[4] = 4; locNumBinsToMergeXVector[5] = 4;
396  }
397  if(locParticleFlag == 2){ //pi- or pi+
398  locMass = 0.1395700;
399  locMaximumMomentum = 2.0;
400  locMinBetaGamma = 0.0;
401  locdEdxAxisMax_2D = 20.0;
402  locdEdxAxisMin_Mean = 1.3;
403  locdEdxAxisMax_Mean = 1.8;
404  locdEdxAxisMin_Sigma = 0.1;
405  locdEdxAxisMax_Sigma = 0.65;
406  locFitRangeMin = 1.0;
407  locFitRangeMax = 14.5;
408 
409  locFitRangeMinVector[0] = 0.8; locFitRangeMinVector[1] = 0.8; locFitRangeMinVector[2] = 0.8;
410  locFitRangeMinVector[3] = 0.8; locFitRangeMinVector[4] = 0.8; locFitRangeMinVector[5] = 0.8;
411  locFitFlags[0] = 5; locFitFlags[1] = 6; locFitFlags[2] = 6; locFitFlags[3] = 11; locFitFlags[4] = 11; locFitFlags[5] = 11;
412  locInputParams.resize(4);
413  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.3; locInputParams[3] = 0.003;
414  locNumBinsToMergeXVector[0] = 64; locNumBinsToMergeXVector[1] = 64; locNumBinsToMergeXVector[2] = 64;
415  locNumBinsToMergeXVector[3] = 64; locNumBinsToMergeXVector[4] = 32; locNumBinsToMergeXVector[5] = 32;
416  }
417  if(locParticleFlag == 3){ //k+
418  locMass = 0.493677;
419  locMaximumMomentum = 2.0;
420  locMinBetaGamma = 0.0;
421  locdEdxAxisMax_2D = 20.0;
422  locdEdxAxisMin_Mean = 1.3;
423  locdEdxAxisMax_Mean = 1.8;
424  locdEdxAxisMin_Sigma = 0.1;
425  locdEdxAxisMax_Sigma = 0.9;
426  locFitRangeMin = 1.0;
427  locFitRangeMax = 4.1;
428 
429  locFitRangeMinVector[0] = 1.0; locFitRangeMinVector[1] = 1.0; locFitRangeMinVector[2] = 1.0;
430  locFitRangeMinVector[3] = 1.0; locFitRangeMinVector[4] = 1.0; locFitRangeMinVector[5] = 1.0;
431  locFitFlags[0] = 19; locFitFlags[1] = 20; locFitFlags[2] = 21; locFitFlags[3] = 22; locFitFlags[4] = 22; locFitFlags[5] = 22;
432  locInputParams.resize(4);
433  locInputParams[0] = 1.4; locInputParams[1] = -1.5; locInputParams[2] = 0.3; locInputParams[3] = 0.003;
434  locNumBinsToMergeXVector[0] = 16; locNumBinsToMergeXVector[1] = 16; locNumBinsToMergeXVector[2] = 16;
435  locNumBinsToMergeXVector[3] = 16; locNumBinsToMergeXVector[4] = 16; locNumBinsToMergeXVector[5] = 16;
436  }
437  locMaxBeta = locMaximumMomentum/sqrt(locMaximumMomentum*locMaximumMomentum + locMass*locMass);
438  locMaxBetaGamma = locMaxBeta/sqrt(1.0 - locMaxBeta*locMaxBeta);
439 
440  TObjArray *locdEdxArray_2D = new TObjArray(locNumNumHitsBins);
441  TObjArray *locdEdxArray_Means = new TObjArray(locNumNumHitsBins);
442  TObjArray *locdEdxArray_Sigmas = new TObjArray(locNumNumHitsBins);
443 
444  for(unsigned int loc_i = 0; loc_i < locNumNumHitsBins; loc_i++){
445  locHistName.str("");
446 
447  if(loc_i == 0)
448  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC_4Hits";
449  if(loc_i == 1)
450  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC_6Hits";
451  if(loc_i == 2)
452  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC_8Hits";
453  if(loc_i == 3)
454  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC_10Hits";
455  if(loc_i == 4)
456  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC_12Hits";
457  if(loc_i == 5)
458  locHistName << "dSelectorHist_dEdxVsBetaGamma_HitsCutoff_CDC_14Hits";
459 
460  locHist = (TH2F*)locFile->Get(locHistName.str().c_str());
461  locHist->Rebin2D(locNumBinsToMergeXVector[loc_i], locNumBinsToMergeY);
462  locHist->GetXaxis()->SetRangeUser(locMinBetaGamma, locMaxBetaGamma);
463  locHist->GetYaxis()->SetRangeUser(0.0, locdEdxAxisMax_2D);
464  Fit_ToGaussians(locHist, locGraphErrors_Mean, locGraphErrors_Sigma, locFitFlags[loc_i]);
465  locGraphErrors_Mean->SetTitle("");
466  locGraphErrors_Sigma->SetTitle("");
467 
468  Set_dqfDrawFuncsFlag(3);
469  Fit_dqfSignalPeak_Graph(locGraphErrors_Sigma, 5, 1, locFitRangeMinVector[loc_i], locFitRangeMax, locInputParams);
470 // Fit_dqfSignalPeak_Graph(locGraphErrors_Sigma, 5, -1, locFitRangeMin, locFitRangeMax, locInputParams); //for exponential
471 // Fit_dqfSignalPeak_Graph(locGraphErrors_Sigma, 0, 1, locFitRangeMin, locFitRangeMax, locInputParams); //for linear
472  Set_dqfDrawFuncsFlag(0);
473  locFuncName.str("");
474  locFuncName << locGraphErrors_Sigma->GetName() << "_fitfunc";
475  locFunc = locGraphErrors_Sigma->GetFunction(locFuncName.str().c_str());
476  cout << locFunc->GetParameter(1) << ", " << locFunc->GetParameter(2) << ", " << locFunc->GetParameter(4) << ", " << locFunc->GetParameter(5) << endl;
477 
478  locdEdxArray_2D->AddAt(locHist, loc_i);
479  locdEdxArray_Means->AddAt(locGraphErrors_Mean, loc_i);
480  locdEdxArray_Sigmas->AddAt(locGraphErrors_Sigma, loc_i);
481  locHistColors[loc_i] = loc_i + 1;
482  locLegendNames[loc_i] = ((TH2F*)(*locdEdxArray_2D)[loc_i])->GetTitle();
483  }
484 
485  locDrawInstructions = new DecayDrawInstructions();
486  *locDrawInstructions = *(Get_ddhTemplateDrawInstructions(1));
487  locDrawInstructions->Set_HistOrGraphColorVector(locHistColors);
488  locDrawInstructions->Set_LegendNameVector(locLegendNames);
489  locDrawInstructions->Set_DrawOption("p");
490 
491 // if((gDrawFlag == 1) || (gDrawFlag == 2))
492 // DrawAndSave_ddhHistOrGraphArray<TH2F>(locdEdxArray_2D, 0, "COLZ");
493  if((gDrawFlag == 1) || (gDrawFlag == 2) || (gDrawFlag == 3)){
494  locDrawInstructions->Set_YRangeMin(locdEdxAxisMin_Mean);
495  locDrawInstructions->Set_YRangeMax(locdEdxAxisMax_Mean);
496 // DrawAndSave_ddhHistOrGraphSuperimposition<TGraphErrors>(locdEdxArray_Means, locDrawInstructions, 1);
497  locDrawInstructions->Set_YRangeMin(locdEdxAxisMin_Sigma);
498  locDrawInstructions->Set_YRangeMax(locdEdxAxisMax_Sigma);
499  DrawAndSave_ddhHistOrGraphSuperimposition<TGraphErrors>(locdEdxArray_Sigmas, locDrawInstructions, 1);
500  }
501 }
502 
503 void Fit_ToGaussians(const TH2F *loc2FHist, TGraphErrors *&locGraphErrors_Mean, TGraphErrors *&locGraphErrors_Sigma, int locFitFlag){
504 
505  TH1D *locFitHist;
506  TF1 *locFunction;
507  TGraphErrors *locGraphErrors;
508  TGraph *locGraph;
509  string locOriginalTitle = loc2FHist->GetTitle();
510  ostringstream locHistName, locHistTitle, locFuncName, locGraphName, locGraphTitle;
511  unsigned int loc_i, locNDF;
512  float locFitRangeMin, locFitRangeMax, locFitRange, locXOfPeak, locChiSq;
513  float locFitRangeMin_DistanceFromPeak, locFitRangeMax_DistanceFromPeak;
514 
515  int locNumMinCountsToFit = 200;
516 
517  int locMinBin = loc2FHist->GetXaxis()->GetFirst();
518  int locMaxBin = loc2FHist->GetXaxis()->GetLast();
519  int locNumBins = locMaxBin - locMinBin + 1;
520 
521  double *locXArray = new double[locNumBins];
522  double *locXUncertaintyArray = new double[locNumBins];
523  double *locMeanArray = new double[locNumBins];
524  double *locMeanUncertaintyArray = new double[locNumBins];
525  double *locSigmaArray = new double[locNumBins];
526  double *locSigmaUncertaintyArray = new double[locNumBins];
527  double *locChiSqPerNDFArray = new double[locNumBins];
528 
529  unsigned int locNumFitHists = 0;
530  TObjArray *locFitHistArray = new TObjArray(1);
531  for(loc_i = locMinBin; loc_i <= locMaxBin; loc_i++){
532  locHistName.str("");
533  locHistName << loc2FHist->GetName() << "_Projection_" << loc_i;
534  locFitHist = (TH1D*)loc2FHist->ProjectionY(locHistName.str().c_str(), loc_i, loc_i);
535  locHistTitle.str("");
536  if(locOriginalTitle != "")
537  locHistTitle << loc2FHist->GetTitle() << ", ";
538  locHistTitle << loc2FHist->GetXaxis()->GetBinLowEdge(loc_i) << " <= " << loc2FHist->GetXaxis()->GetTitle() << " < " << loc2FHist->GetXaxis()->GetBinUpEdge(loc_i);
539  locFitHist->SetTitle(locHistTitle.str().c_str());
540 
541  //rebinning
542  if(locFitHist->GetEntries() < locNumMinCountsToFit)
543  continue;
544 
545  //fit range
546  locXOfPeak = locFitHist->GetXaxis()->GetBinCenter(locFitHist->GetMaximumBin());
547 
548  if(locFitFlag == 1){
549  if(locNumFitHists >= 11){
550  locFitRangeMin_DistanceFromPeak = 0.7;
551  locFitRangeMax_DistanceFromPeak = 0.7;
552  }
553  if((locNumFitHists >= 9) && (locNumFitHists < 11)){
554  locFitRangeMin_DistanceFromPeak = 0.9;
555  locFitRangeMax_DistanceFromPeak = 0.9;
556  }
557  if((locNumFitHists > 6) && (locNumFitHists < 9)){
558  locFitRangeMin_DistanceFromPeak = 1.35;
559  locFitRangeMax_DistanceFromPeak = 1.35;
560  }
561  if((locNumFitHists >= 2) && (locNumFitHists <= 6)){
562  locFitRangeMin_DistanceFromPeak = 1.8;
563  locFitRangeMax_DistanceFromPeak = 2.1;
564  }
565  if(locNumFitHists < 2){
566  locFitRangeMin_DistanceFromPeak = 2.5;
567  locFitRangeMax_DistanceFromPeak = 2.5;
568  }
569  }
570  if(locFitFlag == 2){
571  locFitRangeMin_DistanceFromPeak = 0.45;
572  locFitRangeMax_DistanceFromPeak = 0.45;
573  if((locNumFitHists >= 11) && (locNumFitHists <= 20)){
574  locFitRangeMin_DistanceFromPeak = 0.7;
575  locFitRangeMax_DistanceFromPeak = 0.7;
576  }
577  if((locNumFitHists >= 9) && (locNumFitHists < 11)){
578  locFitRangeMin_DistanceFromPeak = 0.9;
579  locFitRangeMax_DistanceFromPeak = 0.9;
580  }
581  if((locNumFitHists > 6) && (locNumFitHists < 9)){
582  locFitRangeMin_DistanceFromPeak = 1.35;
583  locFitRangeMax_DistanceFromPeak = 1.35;
584  }
585  if((locNumFitHists >= 2) && (locNumFitHists <= 6)){
586  locFitRangeMin_DistanceFromPeak = 1.8;
587  locFitRangeMax_DistanceFromPeak = 2.1;
588  }
589  if(locNumFitHists < 2){
590  locFitRangeMin_DistanceFromPeak = 2.5;
591  locFitRangeMax_DistanceFromPeak = 2.5;
592  }
593  }
594  if(locFitFlag == 3){
595  locFitRangeMin_DistanceFromPeak = 0.5;
596  locFitRangeMax_DistanceFromPeak = 0.5;
597  if(locNumFitHists < 4){
598  locFitRangeMin_DistanceFromPeak = 0.9;
599  locFitRangeMax_DistanceFromPeak = 0.9;
600  }
601  }
602  if(locFitFlag == 4){
603  locFitRangeMin_DistanceFromPeak = 0.45;
604  locFitRangeMax_DistanceFromPeak = 0.45;
605  if((locNumFitHists >= 11) && (locNumFitHists <= 20)){
606  locFitRangeMin_DistanceFromPeak = 0.55;
607  locFitRangeMax_DistanceFromPeak = 0.55;
608  }
609  if((locNumFitHists >= 9) && (locNumFitHists < 11)){
610  locFitRangeMin_DistanceFromPeak = 0.9;
611  locFitRangeMax_DistanceFromPeak = 0.9;
612  }
613  if((locNumFitHists > 5) && (locNumFitHists < 9)){
614  locFitRangeMin_DistanceFromPeak = 0.65;
615  locFitRangeMax_DistanceFromPeak = 1.0;
616  }
617  if(locNumFitHists == 3){
618  locFitRangeMin_DistanceFromPeak = 1.8;
619  locFitRangeMax_DistanceFromPeak = 2.1;
620  }
621  if(locNumFitHists < 2){
622  locFitRangeMin_DistanceFromPeak = 2.5;
623  locFitRangeMax_DistanceFromPeak = 2.9;
624  }
625  if(locNumFitHists == 2){
626  locFitRangeMin_DistanceFromPeak = 2.8;
627  locFitRangeMax_DistanceFromPeak = 2.1;
628  }
629  if(locNumFitHists == 4){
630  locFitHist->Rebin(4);
631  locFitRangeMin_DistanceFromPeak = 1.5;
632  locFitRangeMax_DistanceFromPeak = 1.5;
633  }
634  if(locNumFitHists == 5){
635  locFitHist->Rebin(4);
636  locFitRangeMin_DistanceFromPeak = 0.7;
637  locFitRangeMax_DistanceFromPeak = 1.8;
638  }
639  }
640  if(locFitFlag == 5){
641  locFitRangeMin_DistanceFromPeak = 0.8;
642  locFitRangeMax_DistanceFromPeak = 0.6;
643  if(locNumFitHists < 4){
644  locFitRangeMin_DistanceFromPeak = 0.8;
645  locFitRangeMax_DistanceFromPeak = 0.8;
646  }
647  }
648  if(locFitFlag == 6){
649  locFitRangeMin_DistanceFromPeak = 0.6;
650  locFitRangeMax_DistanceFromPeak = 0.6;
651  if(locNumFitHists < 4){
652  locFitRangeMin_DistanceFromPeak = 0.8;
653  locFitRangeMax_DistanceFromPeak = 0.8;
654  }
655  if((locNumFitHists >= 4) && (locNumFitHists < 18)){
656  locFitRangeMin_DistanceFromPeak = 0.7;
657  locFitRangeMax_DistanceFromPeak = 0.6;
658  }
659  }
660  if(locFitFlag == 7){
661  locFitRangeMin_DistanceFromPeak = 0.65;
662  locFitRangeMax_DistanceFromPeak = 0.6;
663  if((locNumFitHists >= 14) && (locNumFitHists < 21)){
664  locFitRangeMin_DistanceFromPeak = 1.0;
665  locFitRangeMax_DistanceFromPeak = 0.7;
666  }
667  if((locNumFitHists >= 2) && (locNumFitHists < 14)){
668  locFitRangeMin_DistanceFromPeak = 2.2;
669  locFitRangeMax_DistanceFromPeak = 2.4;
670  }
671  if(locNumFitHists < 2){
672  locFitRangeMin_DistanceFromPeak = 3.5;
673  locFitRangeMax_DistanceFromPeak = 3.5;
674  }
675  }
676  if(locFitFlag == 8){
677  locFitRangeMin_DistanceFromPeak = 0.7;
678  locFitRangeMax_DistanceFromPeak = 0.7;
679  if(locNumFitHists < 4){
680  locFitRangeMin_DistanceFromPeak = 1.2;
681  locFitRangeMax_DistanceFromPeak = 1.2;
682  }
683  }
684  if(locFitFlag == 9){
685  locFitRangeMin_DistanceFromPeak = 0.4;
686  locFitRangeMax_DistanceFromPeak = 0.37;
687  if(locNumFitHists < 4){
688  locFitRangeMin_DistanceFromPeak = 0.6;
689  locFitRangeMax_DistanceFromPeak = 0.6;
690  }
691  }
692  if(locFitFlag == 10){
693  if(locNumFitHists >= 11){
694  locFitRangeMin_DistanceFromPeak = 0.7;
695  locFitRangeMax_DistanceFromPeak = 0.7;
696  }
697  if((locNumFitHists >= 9) && (locNumFitHists < 11)){
698  locFitRangeMin_DistanceFromPeak = 0.9;
699  locFitRangeMax_DistanceFromPeak = 0.9;
700  }
701  if((locNumFitHists > 6) && (locNumFitHists < 9)){
702  locFitRangeMin_DistanceFromPeak = 1.35;
703  locFitRangeMax_DistanceFromPeak = 1.35;
704  }
705  if((locNumFitHists >= 2) && (locNumFitHists <= 6)){
706  locFitRangeMin_DistanceFromPeak = 1.8;
707  locFitRangeMax_DistanceFromPeak = 2.1;
708  }
709  if(locNumFitHists < 2){
710  locFitRangeMin_DistanceFromPeak = 2.5;
711  locFitRangeMax_DistanceFromPeak = 2.5;
712  }
713  }
714  if(locFitFlag == 11){
715  locFitRangeMin_DistanceFromPeak = 0.4;
716  locFitRangeMax_DistanceFromPeak = 0.37;
717  if(locNumFitHists < 4){
718  locFitRangeMin_DistanceFromPeak = 0.6;
719  locFitRangeMax_DistanceFromPeak = 0.6;
720  }
721  }
722  if(locFitFlag == 12){
723  locFitHist->Rebin(2);
724  if(locNumFitHists >= 14){
725  locFitRangeMin_DistanceFromPeak = 0.7;
726  locFitRangeMax_DistanceFromPeak = 0.7;
727  }
728  if(locNumFitHists == 13){
729  locFitRangeMin_DistanceFromPeak = 0.9;
730  locFitRangeMax_DistanceFromPeak = 0.7;
731  }
732  if((locNumFitHists >= 11) && (locNumFitHists <= 12)){
733  locFitRangeMin_DistanceFromPeak = 1.1;
734  locFitRangeMax_DistanceFromPeak = 1.0;
735  }
736  if(locNumFitHists == 10){
737  locFitRangeMin_DistanceFromPeak = 0.8;
738  locFitRangeMax_DistanceFromPeak = 1.0;
739  }
740  if((locNumFitHists > 6) && (locNumFitHists <= 9)){
741  locFitRangeMin_DistanceFromPeak = 2.0;
742  locFitRangeMax_DistanceFromPeak = 1.3;
743  }
744  if((locNumFitHists >= 5) && (locNumFitHists <= 6)){
745  locFitRangeMin_DistanceFromPeak = 3.0;
746  locFitRangeMax_DistanceFromPeak = 2.0;
747  }
748  if(locNumFitHists == 4){
749  locFitRangeMin_DistanceFromPeak = 3.0;
750  locFitRangeMax_DistanceFromPeak = 3.0;
751  }
752  if((locNumFitHists >= 2) && (locNumFitHists <= 3)){
753  locFitRangeMin_DistanceFromPeak = 4.5;
754  locFitRangeMax_DistanceFromPeak = 4.5;
755  }
756  if(locNumFitHists == 1){
757  locFitRangeMin_DistanceFromPeak = 4.5;
758  locFitRangeMax_DistanceFromPeak = 4.5;
759  }
760  if(locNumFitHists == 0){
761  locFitRangeMin_DistanceFromPeak = 6.5;
762  locFitRangeMax_DistanceFromPeak = 3.5;
763  }
764  }
765  if(locFitFlag == 13){
766  locFitRangeMin_DistanceFromPeak = 0.55;
767  locFitRangeMax_DistanceFromPeak = 0.6;
768  if((locNumFitHists >= 14) && (locNumFitHists < 21)){
769  locFitRangeMin_DistanceFromPeak = 0.9;
770  locFitRangeMax_DistanceFromPeak = 0.7;
771  }
772  if((locNumFitHists >= 9) && (locNumFitHists < 14)){
773  locFitRangeMin_DistanceFromPeak = 1.3;
774  locFitRangeMax_DistanceFromPeak = 1.0;
775  }
776  if((locNumFitHists >= 7) && (locNumFitHists <= 8)){
777  locFitRangeMin_DistanceFromPeak = 1.8;
778  locFitRangeMax_DistanceFromPeak = 1.2;
779  }
780  if((locNumFitHists >= 5) && (locNumFitHists <= 6)){
781  locFitRangeMin_DistanceFromPeak = 2.2;
782  locFitRangeMax_DistanceFromPeak = 2.1;
783  }
784  if(locNumFitHists == 4){
785  locFitRangeMin_DistanceFromPeak = 2.2;
786  locFitRangeMax_DistanceFromPeak = 2.4;
787  }
788  if(locNumFitHists == 3){
789  locFitRangeMin_DistanceFromPeak = 2.2;
790  locFitRangeMax_DistanceFromPeak = 3.4;
791  }
792  if(locNumFitHists == 2){
793  locFitRangeMin_DistanceFromPeak = 3.4;
794  locFitRangeMax_DistanceFromPeak = 3.4;
795  }
796  if(locNumFitHists == 1){
797  locFitRangeMin_DistanceFromPeak = 3.5;
798  locFitRangeMax_DistanceFromPeak = 3.5;
799  }
800  if(locNumFitHists == 0){
801  locFitRangeMin_DistanceFromPeak = 5.5;
802  locFitRangeMax_DistanceFromPeak = 3.5;
803  }
804  }
805  if(locFitFlag == 14){
806  locFitRangeMin_DistanceFromPeak = 0.45;
807  locFitRangeMax_DistanceFromPeak = 0.45;
808  if((locNumFitHists >= 11) && (locNumFitHists <= 20)){
809  locFitRangeMin_DistanceFromPeak = 0.7;
810  locFitRangeMax_DistanceFromPeak = 0.7;
811  }
812  if((locNumFitHists >= 9) && (locNumFitHists < 11)){
813  locFitRangeMin_DistanceFromPeak = 0.9;
814  locFitRangeMax_DistanceFromPeak = 0.9;
815  }
816  if((locNumFitHists > 6) && (locNumFitHists < 9)){
817  locFitRangeMin_DistanceFromPeak = 1.2;
818  locFitRangeMax_DistanceFromPeak = 1.2;
819  }
820  if((locNumFitHists >= 5) && (locNumFitHists <= 6)){
821  locFitRangeMin_DistanceFromPeak = 1.6;
822  locFitRangeMax_DistanceFromPeak = 1.9;
823  }
824  if((locNumFitHists >= 3) && (locNumFitHists <= 4)){
825  locFitRangeMin_DistanceFromPeak = 2.1;
826  locFitRangeMax_DistanceFromPeak = 2.1;
827  }
828  if(locNumFitHists <= 2){
829  locFitRangeMin_DistanceFromPeak = 4.0;
830  locFitRangeMax_DistanceFromPeak = 4.0;
831  }
832  }
833  if(locFitFlag == 15){
834  locFitRangeMin_DistanceFromPeak = 0.7;
835  locFitRangeMax_DistanceFromPeak = 0.7;
836  if(locNumFitHists == 8){
837  locFitRangeMin_DistanceFromPeak = 0.8;
838  locFitRangeMax_DistanceFromPeak = 0.8;
839  }
840  if(locNumFitHists == 7){
841  locFitRangeMin_DistanceFromPeak = 1.1;
842  locFitRangeMax_DistanceFromPeak = 0.6;
843  }
844  if(locNumFitHists == 6){
845  locFitRangeMin_DistanceFromPeak = 1.1;
846  locFitRangeMax_DistanceFromPeak = 1.1;
847  }
848  if(locNumFitHists == 4){
849  locFitRangeMin_DistanceFromPeak = 0.7;
850  locFitRangeMax_DistanceFromPeak = 0.5;
851  }
852  if(locNumFitHists < 4){
853  locFitRangeMin_DistanceFromPeak = 1.2;
854  locFitRangeMax_DistanceFromPeak = 0.9;
855  }
856  }
857  if(locFitFlag == 16){
858  locFitRangeMin_DistanceFromPeak = 0.5;
859  locFitRangeMax_DistanceFromPeak = 0.5;
860  if(locNumFitHists == 8){
861  locFitRangeMin_DistanceFromPeak = 0.6;
862  locFitRangeMax_DistanceFromPeak = 0.5;
863  }
864  if(locNumFitHists == 7){
865  locFitRangeMin_DistanceFromPeak = 0.8;
866  locFitRangeMax_DistanceFromPeak = 0.6;
867  }
868  if(locNumFitHists == 6){
869  locFitRangeMin_DistanceFromPeak = 1.2;
870  locFitRangeMax_DistanceFromPeak = 1.3;
871  }
872  if(locNumFitHists == 3){
873  locFitRangeMin_DistanceFromPeak = 0.7;
874  locFitRangeMax_DistanceFromPeak = 0.7;
875  }
876  if(locNumFitHists < 3){
877  locFitRangeMin_DistanceFromPeak = 0.9;
878  locFitRangeMax_DistanceFromPeak = 0.9;
879  }
880  }
881  if(locFitFlag == 17){
882  locFitRangeMin_DistanceFromPeak = 0.4;
883  locFitRangeMax_DistanceFromPeak = 0.37;
884  if(locNumFitHists == 8){
885  locFitRangeMin_DistanceFromPeak = 0.6;
886  locFitRangeMax_DistanceFromPeak = 0.6;
887  }
888  if(locNumFitHists == 7){
889  locFitRangeMin_DistanceFromPeak = 1.2;
890  locFitRangeMax_DistanceFromPeak = 0.7;
891  }
892  if(locNumFitHists == 6){
893  locFitRangeMin_DistanceFromPeak = 0.5;
894  locFitRangeMax_DistanceFromPeak = 0.7;
895  }
896  if(locNumFitHists == 5){
897  locFitRangeMin_DistanceFromPeak = 0.5;
898  locFitRangeMax_DistanceFromPeak = 1.1;
899  }
900  if(locNumFitHists < 4){
901  locFitRangeMin_DistanceFromPeak = 0.6;
902  locFitRangeMax_DistanceFromPeak = 0.6;
903  }
904  if(locNumFitHists == 2){
905  locFitRangeMin_DistanceFromPeak = 0.6;
906  locFitRangeMax_DistanceFromPeak = 0.8;
907  }
908  }
909  if(locFitFlag == 18){
910  locFitRangeMin_DistanceFromPeak = 0.4;
911  locFitRangeMax_DistanceFromPeak = 0.37;
912  if((locNumFitHists >= 5) && (locNumFitHists <= 6)){
913  locFitRangeMin_DistanceFromPeak = 0.6;
914  locFitRangeMax_DistanceFromPeak = 0.6;
915  }
916  if(locNumFitHists < 3){
917  locFitRangeMin_DistanceFromPeak = 0.6;
918  locFitRangeMax_DistanceFromPeak = 0.6;
919  }
920  if(locNumFitHists == 1){
921  locFitRangeMin_DistanceFromPeak = 1.0;
922  locFitRangeMax_DistanceFromPeak = 1.3;
923  }
924  }
925  if(locFitFlag == 19){
926  locFitRangeMin_DistanceFromPeak = 0.8;
927  locFitRangeMax_DistanceFromPeak = 0.6;
928  if((locNumFitHists >= 10) && (locNumFitHists <= 14)){
929  locFitRangeMin_DistanceFromPeak = 1.2;
930  locFitRangeMax_DistanceFromPeak = 0.6;
931  }
932  if((locNumFitHists >= 8) && (locNumFitHists <= 9)){
933  locFitRangeMin_DistanceFromPeak = 1.0;
934  locFitRangeMax_DistanceFromPeak = 1.0;
935  }
936  if(locNumFitHists == 7){
937  locFitRangeMin_DistanceFromPeak = 1.2;
938  locFitRangeMax_DistanceFromPeak = 1.1;
939  }
940  if(locNumFitHists == 6){
941  locFitRangeMin_DistanceFromPeak = 1.1;
942  locFitRangeMax_DistanceFromPeak = 1.3;
943  }
944  if(locNumFitHists == 5){
945  locFitRangeMin_DistanceFromPeak = 0.8;
946  locFitRangeMax_DistanceFromPeak = 2.0;
947  }
948  if(locNumFitHists < 4){
949  locFitRangeMin_DistanceFromPeak = 0.8;
950  locFitRangeMax_DistanceFromPeak = 0.8;
951  }
952  }
953  if(locFitFlag == 20){
954  locFitRangeMin_DistanceFromPeak = 0.6;
955  locFitRangeMax_DistanceFromPeak = 0.6;
956  if((locNumFitHists >= 10) && (locNumFitHists < 18)){
957  locFitRangeMin_DistanceFromPeak = 0.7;
958  locFitRangeMax_DistanceFromPeak = 0.6;
959  }
960  if((locNumFitHists >= 8) && (locNumFitHists < 9)){
961  locFitRangeMin_DistanceFromPeak = 0.9;
962  locFitRangeMax_DistanceFromPeak = 0.9;
963  }
964  if(locNumFitHists == 7){
965  locFitRangeMin_DistanceFromPeak = 1.1;
966  locFitRangeMax_DistanceFromPeak = 0.8;
967  }
968  if(locNumFitHists == 6){
969  locFitRangeMin_DistanceFromPeak = 1.1;
970  locFitRangeMax_DistanceFromPeak = 1.2;
971  }
972  if(locNumFitHists == 5){
973  locFitRangeMin_DistanceFromPeak = 1.2;
974  locFitRangeMax_DistanceFromPeak = 1.2;
975  }
976  if(locNumFitHists == 4){
977  locFitRangeMin_DistanceFromPeak = 1.4;
978  locFitRangeMax_DistanceFromPeak = 1.5;
979  }
980  if(locNumFitHists < 4){
981  locFitRangeMin_DistanceFromPeak = 0.8;
982  locFitRangeMax_DistanceFromPeak = 0.8;
983  }
984  }
985  if(locFitFlag == 21){
986  locFitRangeMin_DistanceFromPeak = 0.6;
987  locFitRangeMax_DistanceFromPeak = 0.6;
988  if((locNumFitHists >= 8) && (locNumFitHists < 18)){
989  locFitRangeMin_DistanceFromPeak = 0.7;
990  locFitRangeMax_DistanceFromPeak = 0.6;
991  }
992  if(locNumFitHists == 7){
993  locFitRangeMin_DistanceFromPeak = 0.9;
994  locFitRangeMax_DistanceFromPeak = 0.8;
995  }
996  if(locNumFitHists == 6){
997  locFitRangeMin_DistanceFromPeak = 1.0;
998  locFitRangeMax_DistanceFromPeak = 1.0;
999  }
1000  if(locNumFitHists == 5){
1001  locFitRangeMin_DistanceFromPeak = 1.3;
1002  locFitRangeMax_DistanceFromPeak = 1.0;
1003  }
1004  if(locNumFitHists < 4){
1005  locFitRangeMin_DistanceFromPeak = 0.8;
1006  locFitRangeMax_DistanceFromPeak = 0.8;
1007  }
1008  }
1009  if(locFitFlag == 22){
1010  locFitRangeMin_DistanceFromPeak = 0.4;
1011  locFitRangeMax_DistanceFromPeak = 0.37;
1012  if(locNumFitHists == 9){
1013  locFitRangeMin_DistanceFromPeak = 0.4;
1014  locFitRangeMax_DistanceFromPeak = 0.55;
1015  }
1016  if((locNumFitHists >= 7) && (locNumFitHists <= 8)){
1017  locFitRangeMin_DistanceFromPeak = 0.6;
1018  locFitRangeMax_DistanceFromPeak = 0.6;
1019  }
1020  if(locNumFitHists == 6){
1021  locFitRangeMin_DistanceFromPeak = 0.7;
1022  locFitRangeMax_DistanceFromPeak = 0.7;
1023  }
1024  if(locNumFitHists == 5){
1025  locFitRangeMin_DistanceFromPeak = 0.9;
1026  locFitRangeMax_DistanceFromPeak = 0.5;
1027  }
1028  if(locNumFitHists < 4){
1029  locFitRangeMin_DistanceFromPeak = 0.6;
1030  locFitRangeMax_DistanceFromPeak = 0.6;
1031  }
1032  }
1033 
1034  locFitRangeMin = locXOfPeak - locFitRangeMin_DistanceFromPeak;
1035  locFitRangeMax = locXOfPeak + locFitRangeMax_DistanceFromPeak;
1036  locFitRange = locFitRangeMax - locFitRangeMin;
1037  Fit_dqfSignalPeak(locFitHist, 1, -1, locFitRangeMin, locFitRangeMax);
1038  locFitHist->GetXaxis()->SetRangeUser(locFitRangeMin - locFitRange, locFitRangeMax + locFitRange);
1039 
1040  locFuncName.str("");
1041  locFuncName << locFitHist->GetName() << "_fitfunc";
1042  locFunction = locFitHist->GetFunction(locFuncName.str().c_str());
1043 
1044  locXArray[locNumFitHists] = loc2FHist->GetXaxis()->GetBinCenter(loc_i);
1045  locXUncertaintyArray[locNumFitHists] = 0.0;
1046  locMeanArray[locNumFitHists] = locFunction->GetParameter(2);
1047  locMeanUncertaintyArray[locNumFitHists] = locFunction->GetParError(2);
1048  locSigmaArray[locNumFitHists] = locFunction->GetParameter(3);
1049  locSigmaUncertaintyArray[locNumFitHists] = locFunction->GetParError(3);
1050  locChiSq = locFunction->GetChisquare();
1051  locNDF = locFunction->GetNDF();
1052  locChiSqPerNDFArray[locNumFitHists] = locChiSq/(float(locNDF));
1053 
1054  locFitHistArray->AddAtAndExpand(locFitHist, locNumFitHists);
1055  ++locNumFitHists;
1056  }
1057 
1058  if(gDrawFlag == 1)
1059  DrawAndSave_ddhHistOrGraphArray<TH1D>(locFitHistArray, Get_ddhTemplateDrawInstructions(0), 0);
1060 
1061 
1062  for(loc_i = 0; loc_i < locNumFitHists; loc_i++)
1063  cout << " locBetaGamma[" << loc_i << "] = " << locXArray[loc_i] << ";";
1064  cout << endl;
1065 
1066  for(loc_i = 0; loc_i < locNumFitHists; loc_i++)
1067  cout << " locdEdxMean[" << loc_i << "] = " << locMeanArray[loc_i] << ";";
1068  cout << endl;
1069 
1070  for(loc_i = 0; loc_i < locNumFitHists; loc_i++)
1071  cout << " locdEdxSigma[" << loc_i << "] = " << locSigmaArray[loc_i] << ";";
1072  cout << endl;
1073 
1074 
1075  locGraphErrors_Mean = new TGraphErrors(locNumFitHists, locXArray, locMeanArray, locXUncertaintyArray, locMeanUncertaintyArray);
1076  locGraphName.str("");
1077  locGraphName << loc2FHist->GetName() << "_Means";
1078  locGraphErrors_Mean->SetName(locGraphName.str().c_str());
1079  locGraphErrors_Mean->SetTitle(loc2FHist->GetTitle());
1080  locGraphErrors_Mean->GetXaxis()->SetTitle(loc2FHist->GetXaxis()->GetTitle());
1081  locGraphTitle.str("");
1082  locGraphTitle << loc2FHist->GetYaxis()->GetTitle() << " #mu";
1083  locGraphErrors_Mean->GetYaxis()->SetTitle(locGraphTitle.str().c_str());
1084 
1085  locGraphErrors_Sigma = new TGraphErrors(locNumFitHists, locXArray, locSigmaArray, locXUncertaintyArray, locSigmaUncertaintyArray);
1086  locGraphName.str("");
1087  locGraphName << loc2FHist->GetName() << "_Sigmas";
1088  locGraphErrors_Sigma->SetName(locGraphName.str().c_str());
1089  locGraphErrors_Sigma->SetTitle(loc2FHist->GetTitle());
1090  locGraphErrors_Sigma->GetXaxis()->SetTitle(loc2FHist->GetXaxis()->GetTitle());
1091  locGraphTitle.str("");
1092  locGraphTitle << loc2FHist->GetYaxis()->GetTitle() << " #sigma";
1093  locGraphErrors_Sigma->GetYaxis()->SetTitle(locGraphTitle.str().c_str());
1094 
1095  locGraph = new TGraph(locNumFitHists, locXArray, locChiSqPerNDFArray);
1096  locGraphName.str("");
1097  locGraphName << loc2FHist->GetName() << "_ChiSqPerNDF";
1098  locGraph->SetName(locGraphName.str().c_str());
1099  locGraph->SetTitle(loc2FHist->GetTitle());
1100  locGraph->GetXaxis()->SetTitle(loc2FHist->GetXaxis()->GetTitle());
1101  locGraph->GetYaxis()->SetTitle("Fit #chi^{2}/NDF");
1102 // if((gDrawFlag == 1) || (gDrawFlag == 2))
1103 // DrawAndSave_ddhHistOrGraph<TGraph>(locGraph, Get_ddhTemplateDrawInstructions(1), 1);
1104 }
1105 
1106 void Draw_ProtonPiPlusOverlap(){
1107  Setup_Routines();
1108 
1109  double *locBetaGamma, *locPArray, *locdEdxMean, *locdEdxSigma, *locXUncertaintyArray;
1110  unsigned int locNumPoints;
1111  double locMass;
1112  TGraphErrors *locGraphErrors;
1113  TObjArray *locVsPArray = new TObjArray(6);
1114  TObjArray *locVsBetaGammaArray = new TObjArray(6);
1115 
1116 
1117  DecayDrawInstructions* locDrawInstructions;
1118  vector<int> locHistColors(6, 1);
1119  vector<string> locLegendNames(6, "");
1120 
1121  locHistColors[0] = 1; locHistColors[1] = 2; locHistColors[2] = 3; locHistColors[3] = 4; locHistColors[4] = 5; locHistColors[5] = 6;
1122  locLegendNames[0] = "FDC Protons"; locLegendNames[1] = "CDC Protons"; locLegendNames[2] = "FDC #pi^{+}'s"; locLegendNames[3] = "CDC #pi^{+}'s";
1123  locLegendNames[4] = "FDC K^{+}'s"; locLegendNames[5] = "CDC K^{+}'s";
1124  locDrawInstructions = new DecayDrawInstructions();
1125  *locDrawInstructions = *(Get_ddhTemplateDrawInstructions(1));
1126  locDrawInstructions->Set_HistOrGraphColorVector(locHistColors);
1127  locDrawInstructions->Set_LegendNameVector(locLegendNames);
1128  locDrawInstructions->Set_DrawOption("p");
1129 
1130  //PROTON, FDC
1131  locNumPoints = 47;
1132  locMass = 0.93827203;
1133  locBetaGamma = new double[locNumPoints];
1134  locdEdxMean = new double[locNumPoints];
1135  locdEdxSigma = new double[locNumPoints];
1136  locPArray = new double[locNumPoints];
1137  locXUncertaintyArray = new double[locNumPoints];
1138  locBetaGamma[0] = 0.3; locBetaGamma[1] = 0.34; locBetaGamma[2] = 0.38; locBetaGamma[3] = 0.42; locBetaGamma[4] = 0.46; locBetaGamma[5] = 0.5; locBetaGamma[6] = 0.54; locBetaGamma[7] = 0.58; locBetaGamma[8] = 0.62; locBetaGamma[9] = 0.66; locBetaGamma[10] = 0.7; locBetaGamma[11] = 0.74; locBetaGamma[12] = 0.78; locBetaGamma[13] = 0.82; locBetaGamma[14] = 0.86; locBetaGamma[15] = 0.9; locBetaGamma[16] = 0.94; locBetaGamma[17] = 0.98; locBetaGamma[18] = 1.02; locBetaGamma[19] = 1.06; locBetaGamma[20] = 1.1; locBetaGamma[21] = 1.14; locBetaGamma[22] = 1.18; locBetaGamma[23] = 1.22; locBetaGamma[24] = 1.26; locBetaGamma[25] = 1.3; locBetaGamma[26] = 1.34; locBetaGamma[27] = 1.38; locBetaGamma[28] = 1.42; locBetaGamma[29] = 1.46; locBetaGamma[30] = 1.5; locBetaGamma[31] = 1.54; locBetaGamma[32] = 1.58; locBetaGamma[33] = 1.62; locBetaGamma[34] = 1.66; locBetaGamma[35] = 1.7; locBetaGamma[36] = 1.74; locBetaGamma[37] = 1.78; locBetaGamma[38] = 1.82; locBetaGamma[39] = 1.86; locBetaGamma[40] = 1.9; locBetaGamma[41] = 1.94; locBetaGamma[42] = 1.98; locBetaGamma[43] = 2.02; locBetaGamma[44] = 2.06; locBetaGamma[45] = 2.1; locBetaGamma[46] = 2.14;
1139  locdEdxMean[0] = 14.3659; locdEdxMean[1] = 11.6386; locdEdxMean[2] = 10.1905; locdEdxMean[3] = 9.04111; locdEdxMean[4] = 7.78774; locdEdxMean[5] = 6.78761; locdEdxMean[6] = 5.8374; locdEdxMean[7] = 5.06118; locdEdxMean[8] = 4.4717; locdEdxMean[9] = 4.0293; locdEdxMean[10] = 3.64625; locdEdxMean[11] = 3.36446; locdEdxMean[12] = 3.37726; locdEdxMean[13] = 2.91828; locdEdxMean[14] = 2.72075; locdEdxMean[15] = 2.57965; locdEdxMean[16] = 2.46508; locdEdxMean[17] = 2.35995; locdEdxMean[18] = 2.29682; locdEdxMean[19] = 2.22206; locdEdxMean[20] = 2.14525; locdEdxMean[21] = 2.07374; locdEdxMean[22] = 2.01049; locdEdxMean[23] = 1.96039; locdEdxMean[24] = 1.91539; locdEdxMean[25] = 1.86384; locdEdxMean[26] = 1.82845; locdEdxMean[27] = 1.79351; locdEdxMean[28] = 1.75973; locdEdxMean[29] = 1.73746; locdEdxMean[30] = 1.71082; locdEdxMean[31] = 1.68394; locdEdxMean[32] = 1.65828; locdEdxMean[33] = 1.64309; locdEdxMean[34] = 1.62569; locdEdxMean[35] = 1.61136; locdEdxMean[36] = 1.59284; locdEdxMean[37] = 1.58204; locdEdxMean[38] = 1.56831; locdEdxMean[39] = 1.55495; locdEdxMean[40] = 1.54746; locdEdxMean[41] = 1.53769; locdEdxMean[42] = 1.52752; locdEdxMean[43] = 1.52087; locdEdxMean[44] = 1.51577; locdEdxMean[45] = 1.50627; locdEdxMean[46] = 1.50409;
1140  locdEdxSigma[0] = 2.93573; locdEdxSigma[1] = 2.33335; locdEdxSigma[2] = 2.08781; locdEdxSigma[3] = 1.71181; locdEdxSigma[4] = 1.50988; locdEdxSigma[5] = 1.33544; locdEdxSigma[6] = 1.04385; locdEdxSigma[7] = 0.850859; locdEdxSigma[8] = 0.741105; locdEdxSigma[9] = 0.658413; locdEdxSigma[10] = 0.579022; locdEdxSigma[11] = 0.518601; locdEdxSigma[12] = 2.4537; locdEdxSigma[13] = 0.437453; locdEdxSigma[14] = 0.423342; locdEdxSigma[15] = 0.399433; locdEdxSigma[16] = 0.374628; locdEdxSigma[17] = 0.360932; locdEdxSigma[18] = 0.346619; locdEdxSigma[19] = 0.3374; locdEdxSigma[20] = 0.328811; locdEdxSigma[21] = 0.297946; locdEdxSigma[22] = 0.286214; locdEdxSigma[23] = 0.277289; locdEdxSigma[24] = 0.273103; locdEdxSigma[25] = 0.263827; locdEdxSigma[26] = 0.255441; locdEdxSigma[27] = 0.25133; locdEdxSigma[28] = 0.248591; locdEdxSigma[29] = 0.243123; locdEdxSigma[30] = 0.242105; locdEdxSigma[31] = 0.239135; locdEdxSigma[32] = 0.232915; locdEdxSigma[33] = 0.233682; locdEdxSigma[34] = 0.229795; locdEdxSigma[35] = 0.227354; locdEdxSigma[36] = 0.225178; locdEdxSigma[37] = 0.224466; locdEdxSigma[38] = 0.221981; locdEdxSigma[39] = 0.217982; locdEdxSigma[40] = 0.216642; locdEdxSigma[41] = 0.217325; locdEdxSigma[42] = 0.216148; locdEdxSigma[43] = 0.215665; locdEdxSigma[44] = 0.214442; locdEdxSigma[45] = 0.213614; locdEdxSigma[46] = 0.217714;
1141  for(unsigned int loc_i = 0; loc_i < locNumPoints; loc_i++){
1142  locXUncertaintyArray[loc_i] = 0.0;
1143  locPArray[loc_i] = locMass*locBetaGamma[loc_i];
1144  }
1145  locGraphErrors = new TGraphErrors(locNumPoints, locBetaGamma, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1146  locGraphErrors->GetXaxis()->SetTitle("#beta#gamma");
1147  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1148  locVsBetaGammaArray->AddAt(locGraphErrors, 0);
1149  locGraphErrors = new TGraphErrors(locNumPoints, locPArray, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1150  locGraphErrors->GetXaxis()->SetTitle("p (GeV/c)");
1151  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1152  locVsPArray->AddAt(locGraphErrors, 0);
1153 
1154  //PROTON, CDC
1155  locNumPoints = 47;
1156  locMass = 0.93827203;
1157  locBetaGamma = new double[locNumPoints];
1158  locdEdxMean = new double[locNumPoints];
1159  locdEdxSigma = new double[locNumPoints];
1160  locPArray = new double[locNumPoints];
1161  locXUncertaintyArray = new double[locNumPoints];
1162  locBetaGamma[0] = 0.3; locBetaGamma[1] = 0.34; locBetaGamma[2] = 0.38; locBetaGamma[3] = 0.42; locBetaGamma[4] = 0.46; locBetaGamma[5] = 0.5; locBetaGamma[6] = 0.54; locBetaGamma[7] = 0.58; locBetaGamma[8] = 0.62; locBetaGamma[9] = 0.66; locBetaGamma[10] = 0.7; locBetaGamma[11] = 0.74; locBetaGamma[12] = 0.78; locBetaGamma[13] = 0.82; locBetaGamma[14] = 0.86; locBetaGamma[15] = 0.9; locBetaGamma[16] = 0.94; locBetaGamma[17] = 0.98; locBetaGamma[18] = 1.02; locBetaGamma[19] = 1.06; locBetaGamma[20] = 1.1; locBetaGamma[21] = 1.14; locBetaGamma[22] = 1.18; locBetaGamma[23] = 1.22; locBetaGamma[24] = 1.26; locBetaGamma[25] = 1.3; locBetaGamma[26] = 1.34; locBetaGamma[27] = 1.38; locBetaGamma[28] = 1.42; locBetaGamma[29] = 1.46; locBetaGamma[30] = 1.5; locBetaGamma[31] = 1.54; locBetaGamma[32] = 1.58; locBetaGamma[33] = 1.62; locBetaGamma[34] = 1.66; locBetaGamma[35] = 1.7; locBetaGamma[36] = 1.74; locBetaGamma[37] = 1.78; locBetaGamma[38] = 1.82; locBetaGamma[39] = 1.86; locBetaGamma[40] = 1.9; locBetaGamma[41] = 1.94; locBetaGamma[42] = 1.98; locBetaGamma[43] = 2.02; locBetaGamma[44] = 2.06; locBetaGamma[45] = 2.1; locBetaGamma[46] = 2.14;
1163  locdEdxMean[0] = 13.2769; locdEdxMean[1] = 11.1142; locdEdxMean[2] = 10.0385; locdEdxMean[3] = 9.13612; locdEdxMean[4] = 8.09766; locdEdxMean[5] = 6.75607; locdEdxMean[6] = 5.93831; locdEdxMean[7] = 5.2655; locdEdxMean[8] = 4.75216; locdEdxMean[9] = 4.30025; locdEdxMean[10] = 3.96891; locdEdxMean[11] = 3.65299; locdEdxMean[12] = 3.41423; locdEdxMean[13] = 3.19939; locdEdxMean[14] = 3.00491; locdEdxMean[15] = 2.8645; locdEdxMean[16] = 2.71925; locdEdxMean[17] = 2.58784; locdEdxMean[18] = 2.49657; locdEdxMean[19] = 2.40005; locdEdxMean[20] = 2.30766; locdEdxMean[21] = 2.23464; locdEdxMean[22] = 2.17738; locdEdxMean[23] = 2.11424; locdEdxMean[24] = 2.05425; locdEdxMean[25] = 2.00659; locdEdxMean[26] = 1.97077; locdEdxMean[27] = 1.93114; locdEdxMean[28] = 1.89473; locdEdxMean[29] = 1.85834; locdEdxMean[30] = 1.82908; locdEdxMean[31] = 1.80608; locdEdxMean[32] = 1.78316; locdEdxMean[33] = 1.75923; locdEdxMean[34] = 1.73596; locdEdxMean[35] = 1.71507; locdEdxMean[36] = 1.69805; locdEdxMean[37] = 1.68427; locdEdxMean[38] = 1.67062; locdEdxMean[39] = 1.65653; locdEdxMean[40] = 1.64473; locdEdxMean[41] = 1.63283; locdEdxMean[42] = 1.62268; locdEdxMean[43] = 1.61341; locdEdxMean[44] = 1.60417; locdEdxMean[45] = 1.59654; locdEdxMean[46] = 1.59605;
1164  locdEdxSigma[0] = 3.19788; locdEdxSigma[1] = 2.53706; locdEdxSigma[2] = 2.02203; locdEdxSigma[3] = 1.31974; locdEdxSigma[4] = 1.1821; locdEdxSigma[5] = 0.916922; locdEdxSigma[6] = 0.775039; locdEdxSigma[7] = 0.6374; locdEdxSigma[8] = 0.547259; locdEdxSigma[9] = 0.473546; locdEdxSigma[10] = 0.426132; locdEdxSigma[11] = 0.386837; locdEdxSigma[12] = 0.351433; locdEdxSigma[13] = 0.341537; locdEdxSigma[14] = 0.318642; locdEdxSigma[15] = 0.306191; locdEdxSigma[16] = 0.29701; locdEdxSigma[17] = 0.282137; locdEdxSigma[18] = 0.274505; locdEdxSigma[19] = 0.267861; locdEdxSigma[20] = 0.260041; locdEdxSigma[21] = 0.235912; locdEdxSigma[22] = 0.23393; locdEdxSigma[23] = 0.228528; locdEdxSigma[24] = 0.225075; locdEdxSigma[25] = 0.216987; locdEdxSigma[26] = 0.214381; locdEdxSigma[27] = 0.211059; locdEdxSigma[28] = 0.209439; locdEdxSigma[29] = 0.205865; locdEdxSigma[30] = 0.202402; locdEdxSigma[31] = 0.200022; locdEdxSigma[32] = 0.198706; locdEdxSigma[33] = 0.195332; locdEdxSigma[34] = 0.191766; locdEdxSigma[35] = 0.191046; locdEdxSigma[36] = 0.187931; locdEdxSigma[37] = 0.187142; locdEdxSigma[38] = 0.186757; locdEdxSigma[39] = 0.184169; locdEdxSigma[40] = 0.182682; locdEdxSigma[41] = 0.181118; locdEdxSigma[42] = 0.179834; locdEdxSigma[43] = 0.177071; locdEdxSigma[44] = 0.175781; locdEdxSigma[45] = 0.175693; locdEdxSigma[46] = 0.18061;
1165  for(unsigned int loc_i = 0; loc_i < locNumPoints; loc_i++){
1166  locXUncertaintyArray[loc_i] = 0.0;
1167  locPArray[loc_i] = locMass*locBetaGamma[loc_i];
1168  }
1169  locGraphErrors = new TGraphErrors(locNumPoints, locBetaGamma, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1170  locGraphErrors->GetXaxis()->SetTitle("#beta#gamma");
1171  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1172  locVsBetaGammaArray->AddAt(locGraphErrors, 1);
1173  locGraphErrors = new TGraphErrors(locNumPoints, locPArray, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1174  locGraphErrors->GetXaxis()->SetTitle("p (GeV/c)");
1175  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1176  locVsPArray->AddAt(locGraphErrors, 1);
1177 
1178  //PIPLUS, FDC
1179  locNumPoints = 44;
1180  locMass = 0.1395700;
1181  locBetaGamma = new double[locNumPoints];
1182  locdEdxMean = new double[locNumPoints];
1183  locdEdxSigma = new double[locNumPoints];
1184  locPArray = new double[locNumPoints];
1185  locXUncertaintyArray = new double[locNumPoints];
1186  locBetaGamma[0] = 0.48; locBetaGamma[1] = 0.8; locBetaGamma[2] = 1.12; locBetaGamma[3] = 1.44; locBetaGamma[4] = 1.76; locBetaGamma[5] = 2.08; locBetaGamma[6] = 2.4; locBetaGamma[7] = 2.72; locBetaGamma[8] = 3.04; locBetaGamma[9] = 3.36; locBetaGamma[10] = 3.68; locBetaGamma[11] = 4; locBetaGamma[12] = 4.32; locBetaGamma[13] = 4.64; locBetaGamma[14] = 4.96; locBetaGamma[15] = 5.28; locBetaGamma[16] = 5.6; locBetaGamma[17] = 5.92; locBetaGamma[18] = 6.24; locBetaGamma[19] = 6.56; locBetaGamma[20] = 6.88; locBetaGamma[21] = 7.2; locBetaGamma[22] = 7.52; locBetaGamma[23] = 7.84; locBetaGamma[24] = 8.16; locBetaGamma[25] = 8.48; locBetaGamma[26] = 8.8; locBetaGamma[27] = 9.12; locBetaGamma[28] = 9.44; locBetaGamma[29] = 9.76; locBetaGamma[30] = 10.08; locBetaGamma[31] = 10.4; locBetaGamma[32] = 10.72; locBetaGamma[33] = 11.04; locBetaGamma[34] = 11.36; locBetaGamma[35] = 11.68; locBetaGamma[36] = 12; locBetaGamma[37] = 12.32; locBetaGamma[38] = 12.64; locBetaGamma[39] = 12.96; locBetaGamma[40] = 13.28; locBetaGamma[41] = 13.6; locBetaGamma[42] = 13.92; locBetaGamma[43] = 14.24;
1187  locdEdxMean[0] = 1.32105; locdEdxMean[1] = 1.50904; locdEdxMean[2] = 1.50873; locdEdxMean[3] = 1.57426; locdEdxMean[4] = 1.52213; locdEdxMean[5] = 1.45914; locdEdxMean[6] = 1.4271; locdEdxMean[7] = 1.42623; locdEdxMean[8] = 1.42268; locdEdxMean[9] = 1.42632; locdEdxMean[10] = 1.43233; locdEdxMean[11] = 1.43742; locdEdxMean[12] = 1.4467; locdEdxMean[13] = 1.45642; locdEdxMean[14] = 1.46337; locdEdxMean[15] = 1.4719; locdEdxMean[16] = 1.48252; locdEdxMean[17] = 1.49443; locdEdxMean[18] = 1.50234; locdEdxMean[19] = 1.513; locdEdxMean[20] = 1.52394; locdEdxMean[21] = 1.5289; locdEdxMean[22] = 1.53878; locdEdxMean[23] = 1.54396; locdEdxMean[24] = 1.55427; locdEdxMean[25] = 1.56105; locdEdxMean[26] = 1.5674; locdEdxMean[27] = 1.57221; locdEdxMean[28] = 1.58027; locdEdxMean[29] = 1.5865; locdEdxMean[30] = 1.59519; locdEdxMean[31] = 1.60211; locdEdxMean[32] = 1.60751; locdEdxMean[33] = 1.61522; locdEdxMean[34] = 1.62066; locdEdxMean[35] = 1.6277; locdEdxMean[36] = 1.63227; locdEdxMean[37] = 1.63661; locdEdxMean[38] = 1.64457; locdEdxMean[39] = 1.65043; locdEdxMean[40] = 1.6557; locdEdxMean[41] = 1.66085; locdEdxMean[42] = 1.66486; locdEdxMean[43] = 1.66916;
1188  locdEdxSigma[0] = 0.384194; locdEdxSigma[1] = 0.481736; locdEdxSigma[2] = 0.408882; locdEdxSigma[3] = 0.308842; locdEdxSigma[4] = 0.238201; locdEdxSigma[5] = 0.205383; locdEdxSigma[6] = 0.199131; locdEdxSigma[7] = 0.183296; locdEdxSigma[8] = 0.17939; locdEdxSigma[9] = 0.180875; locdEdxSigma[10] = 0.180979; locdEdxSigma[11] = 0.181938; locdEdxSigma[12] = 0.185807; locdEdxSigma[13] = 0.186497; locdEdxSigma[14] = 0.188448; locdEdxSigma[15] = 0.190472; locdEdxSigma[16] = 0.189878; locdEdxSigma[17] = 0.189112; locdEdxSigma[18] = 0.189443; locdEdxSigma[19] = 0.192163; locdEdxSigma[20] = 0.19386; locdEdxSigma[21] = 0.194046; locdEdxSigma[22] = 0.194451; locdEdxSigma[23] = 0.194133; locdEdxSigma[24] = 0.195598; locdEdxSigma[25] = 0.198318; locdEdxSigma[26] = 0.198263; locdEdxSigma[27] = 0.198669; locdEdxSigma[28] = 0.19729; locdEdxSigma[29] = 0.197867; locdEdxSigma[30] = 0.199663; locdEdxSigma[31] = 0.201134; locdEdxSigma[32] = 0.201602; locdEdxSigma[33] = 0.202371; locdEdxSigma[34] = 0.202888; locdEdxSigma[35] = 0.201155; locdEdxSigma[36] = 0.205072; locdEdxSigma[37] = 0.201526; locdEdxSigma[38] = 0.206744; locdEdxSigma[39] = 0.209571; locdEdxSigma[40] = 0.207218; locdEdxSigma[41] = 0.204573; locdEdxSigma[42] = 0.20254; locdEdxSigma[43] = 0.208395;
1189  for(unsigned int loc_i = 0; loc_i < locNumPoints; loc_i++){
1190  locXUncertaintyArray[loc_i] = 0.0;
1191  locPArray[loc_i] = locMass*locBetaGamma[loc_i];
1192  }
1193  locGraphErrors = new TGraphErrors(locNumPoints, locBetaGamma, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1194  locGraphErrors->GetXaxis()->SetTitle("#beta#gamma");
1195  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1196  locVsBetaGammaArray->AddAt(locGraphErrors, 2);
1197  locGraphErrors = new TGraphErrors(locNumPoints, locPArray, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1198  locGraphErrors->GetXaxis()->SetTitle("p (GeV/c)");
1199  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1200  locVsPArray->AddAt(locGraphErrors, 2);
1201 
1202  //PIPLUS, CDC
1203  locNumPoints = 44;
1204  locMass = 0.1395700;
1205  locBetaGamma = new double[locNumPoints];
1206  locdEdxMean = new double[locNumPoints];
1207  locdEdxSigma = new double[locNumPoints];
1208  locPArray = new double[locNumPoints];
1209  locXUncertaintyArray = new double[locNumPoints];
1210  locBetaGamma[0] = 0.48; locBetaGamma[1] = 0.8; locBetaGamma[2] = 1.12; locBetaGamma[3] = 1.44; locBetaGamma[4] = 1.76; locBetaGamma[5] = 2.08; locBetaGamma[6] = 2.4; locBetaGamma[7] = 2.72; locBetaGamma[8] = 3.04; locBetaGamma[9] = 3.36; locBetaGamma[10] = 3.68; locBetaGamma[11] = 4; locBetaGamma[12] = 4.32; locBetaGamma[13] = 4.64; locBetaGamma[14] = 4.96; locBetaGamma[15] = 5.28; locBetaGamma[16] = 5.6; locBetaGamma[17] = 5.92; locBetaGamma[18] = 6.24; locBetaGamma[19] = 6.56; locBetaGamma[20] = 6.88; locBetaGamma[21] = 7.2; locBetaGamma[22] = 7.52; locBetaGamma[23] = 7.84; locBetaGamma[24] = 8.16; locBetaGamma[25] = 8.48; locBetaGamma[26] = 8.8; locBetaGamma[27] = 9.12; locBetaGamma[28] = 9.44; locBetaGamma[29] = 9.76; locBetaGamma[30] = 10.08; locBetaGamma[31] = 10.4; locBetaGamma[32] = 10.72; locBetaGamma[33] = 11.04; locBetaGamma[34] = 11.36; locBetaGamma[35] = 11.68; locBetaGamma[36] = 12; locBetaGamma[37] = 12.32; locBetaGamma[38] = 12.64; locBetaGamma[39] = 12.96; locBetaGamma[40] = 13.28; locBetaGamma[41] = 13.6; locBetaGamma[42] = 13.92; locBetaGamma[43] = 14.24;
1211  locdEdxMean[0] = 2.40705; locdEdxMean[1] = 2.64016; locdEdxMean[2] = 1.97719; locdEdxMean[3] = 1.74434; locdEdxMean[4] = 1.60673; locdEdxMean[5] = 1.52877; locdEdxMean[6] = 1.47792; locdEdxMean[7] = 1.44914; locdEdxMean[8] = 1.44456; locdEdxMean[9] = 1.44089; locdEdxMean[10] = 1.44077; locdEdxMean[11] = 1.44643; locdEdxMean[12] = 1.46221; locdEdxMean[13] = 1.47146; locdEdxMean[14] = 1.48451; locdEdxMean[15] = 1.49671; locdEdxMean[16] = 1.50718; locdEdxMean[17] = 1.51892; locdEdxMean[18] = 1.53035; locdEdxMean[19] = 1.54224; locdEdxMean[20] = 1.5531; locdEdxMean[21] = 1.56325; locdEdxMean[22] = 1.57347; locdEdxMean[23] = 1.58422; locdEdxMean[24] = 1.59239; locdEdxMean[25] = 1.60057; locdEdxMean[26] = 1.61224; locdEdxMean[27] = 1.62025; locdEdxMean[28] = 1.6288; locdEdxMean[29] = 1.63748; locdEdxMean[30] = 1.64582; locdEdxMean[31] = 1.65254; locdEdxMean[32] = 1.65864; locdEdxMean[33] = 1.66693; locdEdxMean[34] = 1.67503; locdEdxMean[35] = 1.68328; locdEdxMean[36] = 1.68964; locdEdxMean[37] = 1.69732; locdEdxMean[38] = 1.70258; locdEdxMean[39] = 1.70849; locdEdxMean[40] = 1.71469; locdEdxMean[41] = 1.72359; locdEdxMean[42] = 1.73032; locdEdxMean[43] = 1.73672;
1212  locdEdxSigma[0] = 0.00923813; locdEdxSigma[1] = 0.753794; locdEdxSigma[2] = 0.461342; locdEdxSigma[3] = 0.273398; locdEdxSigma[4] = 0.239905; locdEdxSigma[5] = 0.23336; locdEdxSigma[6] = 0.231064; locdEdxSigma[7] = 0.216753; locdEdxSigma[8] = 0.205846; locdEdxSigma[9] = 0.202349; locdEdxSigma[10] = 0.19949; locdEdxSigma[11] = 0.19614; locdEdxSigma[12] = 0.192053; locdEdxSigma[13] = 0.189132; locdEdxSigma[14] = 0.18807; locdEdxSigma[15] = 0.186939; locdEdxSigma[16] = 0.186402; locdEdxSigma[17] = 0.18636; locdEdxSigma[18] = 0.185533; locdEdxSigma[19] = 0.185677; locdEdxSigma[20] = 0.184546; locdEdxSigma[21] = 0.183511; locdEdxSigma[22] = 0.183899; locdEdxSigma[23] = 0.183173; locdEdxSigma[24] = 0.182368; locdEdxSigma[25] = 0.182132; locdEdxSigma[26] = 0.183335; locdEdxSigma[27] = 0.182698; locdEdxSigma[28] = 0.1839; locdEdxSigma[29] = 0.184523; locdEdxSigma[30] = 0.183395; locdEdxSigma[31] = 0.182982; locdEdxSigma[32] = 0.181914; locdEdxSigma[33] = 0.183204; locdEdxSigma[34] = 0.182819; locdEdxSigma[35] = 0.184335; locdEdxSigma[36] = 0.183594; locdEdxSigma[37] = 0.183738; locdEdxSigma[38] = 0.181587; locdEdxSigma[39] = 0.183005; locdEdxSigma[40] = 0.181546; locdEdxSigma[41] = 0.183761; locdEdxSigma[42] = 0.181959; locdEdxSigma[43] = 0.185626;
1213  for(unsigned int loc_i = 0; loc_i < locNumPoints; loc_i++){
1214  locXUncertaintyArray[loc_i] = 0.0;
1215  locPArray[loc_i] = locMass*locBetaGamma[loc_i];
1216  }
1217  locGraphErrors = new TGraphErrors(locNumPoints, locBetaGamma, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1218  locGraphErrors->GetXaxis()->SetTitle("#beta#gamma");
1219  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1220  locVsBetaGammaArray->AddAt(locGraphErrors, 3);
1221  locGraphErrors = new TGraphErrors(locNumPoints, locPArray, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1222  locGraphErrors->GetXaxis()->SetTitle("p (GeV/c)");
1223  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1224  locVsPArray->AddAt(locGraphErrors, 3);
1225 
1226 
1227  //KPLUS, FDC
1228  locNumPoints = 50;
1229  locMass = 0.493677;
1230  locBetaGamma = new double[locNumPoints];
1231  locdEdxMean = new double[locNumPoints];
1232  locdEdxSigma = new double[locNumPoints];
1233  locPArray = new double[locNumPoints];
1234  locXUncertaintyArray = new double[locNumPoints];
1235  locBetaGamma[0] = 0.12; locBetaGamma[1] = 0.2; locBetaGamma[2] = 0.28; locBetaGamma[3] = 0.36; locBetaGamma[4] = 0.44; locBetaGamma[5] = 0.52; locBetaGamma[6] = 0.6; locBetaGamma[7] = 0.68; locBetaGamma[8] = 0.76; locBetaGamma[9] = 0.84; locBetaGamma[10] = 0.92; locBetaGamma[11] = 1; locBetaGamma[12] = 1.08; locBetaGamma[13] = 1.16; locBetaGamma[14] = 1.24; locBetaGamma[15] = 1.32; locBetaGamma[16] = 1.4; locBetaGamma[17] = 1.48; locBetaGamma[18] = 1.56; locBetaGamma[19] = 1.64; locBetaGamma[20] = 1.72; locBetaGamma[21] = 1.8; locBetaGamma[22] = 1.88; locBetaGamma[23] = 1.96; locBetaGamma[24] = 2.04; locBetaGamma[25] = 2.12; locBetaGamma[26] = 2.2; locBetaGamma[27] = 2.28; locBetaGamma[28] = 2.36; locBetaGamma[29] = 2.44; locBetaGamma[30] = 2.52; locBetaGamma[31] = 2.6; locBetaGamma[32] = 2.68; locBetaGamma[33] = 2.76; locBetaGamma[34] = 2.84; locBetaGamma[35] = 2.92; locBetaGamma[36] = 3; locBetaGamma[37] = 3.08; locBetaGamma[38] = 3.16; locBetaGamma[39] = 3.24; locBetaGamma[40] = 3.32; locBetaGamma[41] = 3.4; locBetaGamma[42] = 3.48; locBetaGamma[43] = 3.56; locBetaGamma[44] = 3.64; locBetaGamma[45] = 3.72; locBetaGamma[46] = 3.8; locBetaGamma[47] = 3.88; locBetaGamma[48] = 3.96; locBetaGamma[49] = 4.04;
1236  locdEdxMean[0] = 1.35012; locdEdxMean[1] = 1.38705; locdEdxMean[2] = 1.4757; locdEdxMean[3] = 1.39719; locdEdxMean[4] = 1.35641; locdEdxMean[5] = 1.38561; locdEdxMean[6] = 1.39104; locdEdxMean[7] = 1.37202; locdEdxMean[8] = 1.37453; locdEdxMean[9] = 1.39048; locdEdxMean[10] = 2.47808; locdEdxMean[11] = 2.27568; locdEdxMean[12] = 2.1479; locdEdxMean[13] = 2.00315; locdEdxMean[14] = 1.88838; locdEdxMean[15] = 1.78769; locdEdxMean[16] = 1.72742; locdEdxMean[17] = 1.68317; locdEdxMean[18] = 1.64201; locdEdxMean[19] = 1.61215; locdEdxMean[20] = 1.59323; locdEdxMean[21] = 1.56803; locdEdxMean[22] = 1.54727; locdEdxMean[23] = 1.5315; locdEdxMean[24] = 1.5186; locdEdxMean[25] = 1.50544; locdEdxMean[26] = 1.49661; locdEdxMean[27] = 1.48962; locdEdxMean[28] = 1.48178; locdEdxMean[29] = 1.47437; locdEdxMean[30] = 1.46332; locdEdxMean[31] = 1.46012; locdEdxMean[32] = 1.45291; locdEdxMean[33] = 1.45176; locdEdxMean[34] = 1.44809; locdEdxMean[35] = 1.44591; locdEdxMean[36] = 1.44005; locdEdxMean[37] = 1.43917; locdEdxMean[38] = 1.43704; locdEdxMean[39] = 1.43816; locdEdxMean[40] = 1.43037; locdEdxMean[41] = 1.43408; locdEdxMean[42] = 1.43274; locdEdxMean[43] = 1.43441; locdEdxMean[44] = 1.43; locdEdxMean[45] = 1.43307; locdEdxMean[46] = 1.4322; locdEdxMean[47] = 1.42994; locdEdxMean[48] = 1.43297; locdEdxMean[49] = 1.43424;
1237  locdEdxSigma[0] = 0.342043; locdEdxSigma[1] = 0.415316; locdEdxSigma[2] = 0.469585; locdEdxSigma[3] = 0.426567; locdEdxSigma[4] = 0.311762; locdEdxSigma[5] = 0.276792; locdEdxSigma[6] = 0.258224; locdEdxSigma[7] = 0.240704; locdEdxSigma[8] = 0.234693; locdEdxSigma[9] = 0.234922; locdEdxSigma[10] = 0.43263; locdEdxSigma[11] = 0.371096; locdEdxSigma[12] = 0.39021; locdEdxSigma[13] = 0.323567; locdEdxSigma[14] = 0.344277; locdEdxSigma[15] = 0.332502; locdEdxSigma[16] = 0.297985; locdEdxSigma[17] = 0.266577; locdEdxSigma[18] = 0.249613; locdEdxSigma[19] = 0.235291; locdEdxSigma[20] = 0.227965; locdEdxSigma[21] = 0.221766; locdEdxSigma[22] = 0.216916; locdEdxSigma[23] = 0.210419; locdEdxSigma[24] = 0.205736; locdEdxSigma[25] = 0.208651; locdEdxSigma[26] = 0.206319; locdEdxSigma[27] = 0.204752; locdEdxSigma[28] = 0.20364; locdEdxSigma[29] = 0.200502; locdEdxSigma[30] = 0.203598; locdEdxSigma[31] = 0.200443; locdEdxSigma[32] = 0.19678; locdEdxSigma[33] = 0.199707; locdEdxSigma[34] = 0.201759; locdEdxSigma[35] = 0.203394; locdEdxSigma[36] = 0.197385; locdEdxSigma[37] = 0.196626; locdEdxSigma[38] = 0.198206; locdEdxSigma[39] = 0.198421; locdEdxSigma[40] = 0.197648; locdEdxSigma[41] = 0.198405; locdEdxSigma[42] = 0.195213; locdEdxSigma[43] = 0.197544; locdEdxSigma[44] = 0.196865; locdEdxSigma[45] = 0.198364; locdEdxSigma[46] = 0.197348; locdEdxSigma[47] = 0.197956; locdEdxSigma[48] = 0.193743; locdEdxSigma[49] = 0.195151;
1238  for(unsigned int loc_i = 0; loc_i < locNumPoints; loc_i++){
1239  locXUncertaintyArray[loc_i] = 0.0;
1240  locPArray[loc_i] = locMass*locBetaGamma[loc_i];
1241  }
1242  locGraphErrors = new TGraphErrors(locNumPoints, locBetaGamma, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1243  locGraphErrors->GetXaxis()->SetTitle("#beta#gamma");
1244  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1245  locVsBetaGammaArray->AddAt(locGraphErrors, 4);
1246  locGraphErrors = new TGraphErrors(locNumPoints, locPArray, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1247  locGraphErrors->GetXaxis()->SetTitle("p (GeV/c)");
1248  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1249  locVsPArray->AddAt(locGraphErrors, 4);
1250 
1251  //KPLUS, CDC
1252  locNumPoints = 49;
1253  locMass = 0.493677;
1254  locBetaGamma = new double[locNumPoints];
1255  locdEdxMean = new double[locNumPoints];
1256  locdEdxSigma = new double[locNumPoints];
1257  locPArray = new double[locNumPoints];
1258  locXUncertaintyArray = new double[locNumPoints];
1259  locBetaGamma[0] = 0.2; locBetaGamma[1] = 0.28; locBetaGamma[2] = 0.36; locBetaGamma[3] = 0.44; locBetaGamma[4] = 0.52; locBetaGamma[5] = 0.6; locBetaGamma[6] = 0.68; locBetaGamma[7] = 0.76; locBetaGamma[8] = 0.84; locBetaGamma[9] = 0.92; locBetaGamma[10] = 1; locBetaGamma[11] = 1.08; locBetaGamma[12] = 1.16; locBetaGamma[13] = 1.24; locBetaGamma[14] = 1.32; locBetaGamma[15] = 1.4; locBetaGamma[16] = 1.48; locBetaGamma[17] = 1.56; locBetaGamma[18] = 1.64; locBetaGamma[19] = 1.72; locBetaGamma[20] = 1.8; locBetaGamma[21] = 1.88; locBetaGamma[22] = 1.96; locBetaGamma[23] = 2.04; locBetaGamma[24] = 2.12; locBetaGamma[25] = 2.2; locBetaGamma[26] = 2.28; locBetaGamma[27] = 2.36; locBetaGamma[28] = 2.44; locBetaGamma[29] = 2.52; locBetaGamma[30] = 2.6; locBetaGamma[31] = 2.68; locBetaGamma[32] = 2.76; locBetaGamma[33] = 2.84; locBetaGamma[34] = 2.92; locBetaGamma[35] = 3; locBetaGamma[36] = 3.08; locBetaGamma[37] = 3.16; locBetaGamma[38] = 3.24; locBetaGamma[39] = 3.32; locBetaGamma[40] = 3.4; locBetaGamma[41] = 3.48; locBetaGamma[42] = 3.56; locBetaGamma[43] = 3.64; locBetaGamma[44] = 3.72; locBetaGamma[45] = 3.8; locBetaGamma[46] = 3.88; locBetaGamma[47] = 3.96; locBetaGamma[48] = 4.04;
1260  locdEdxMean[0] = 3.2117; locdEdxMean[1] = 1.92621; locdEdxMean[2] = 1.63171; locdEdxMean[3] = 1.54946; locdEdxMean[4] = 1.43884; locdEdxMean[5] = 1.43401; locdEdxMean[6] = 4.03109; locdEdxMean[7] = 3.45989; locdEdxMean[8] = 3.04638; locdEdxMean[9] = 2.74302; locdEdxMean[10] = 2.49407; locdEdxMean[11] = 2.30716; locdEdxMean[12] = 2.15957; locdEdxMean[13] = 2.03802; locdEdxMean[14] = 1.95242; locdEdxMean[15] = 1.87438; locdEdxMean[16] = 1.80751; locdEdxMean[17] = 1.76246; locdEdxMean[18] = 1.71855; locdEdxMean[19] = 1.67958; locdEdxMean[20] = 1.65377; locdEdxMean[21] = 1.62775; locdEdxMean[22] = 1.60503; locdEdxMean[23] = 1.58512; locdEdxMean[24] = 1.57129; locdEdxMean[25] = 1.55657; locdEdxMean[26] = 1.54396; locdEdxMean[27] = 1.53245; locdEdxMean[28] = 1.52701; locdEdxMean[29] = 1.5202; locdEdxMean[30] = 1.51276; locdEdxMean[31] = 1.50879; locdEdxMean[32] = 1.5018; locdEdxMean[33] = 1.49804; locdEdxMean[34] = 1.49589; locdEdxMean[35] = 1.494; locdEdxMean[36] = 1.49093; locdEdxMean[37] = 1.4921; locdEdxMean[38] = 1.49017; locdEdxMean[39] = 1.48867; locdEdxMean[40] = 1.48755; locdEdxMean[41] = 1.48844; locdEdxMean[42] = 1.48861; locdEdxMean[43] = 1.48829; locdEdxMean[44] = 1.49078; locdEdxMean[45] = 1.49107; locdEdxMean[46] = 1.49341; locdEdxMean[47] = 1.49496; locdEdxMean[48] = 1.49551;
1261  locdEdxSigma[0] = 0.00990457; locdEdxSigma[1] = 0.713109; locdEdxSigma[2] = 0.422844; locdEdxSigma[3] = 0.319996; locdEdxSigma[4] = 0.228746; locdEdxSigma[5] = 0.299985; locdEdxSigma[6] = 0.534387; locdEdxSigma[7] = 0.446107; locdEdxSigma[8] = 0.381853; locdEdxSigma[9] = 0.334705; locdEdxSigma[10] = 0.292848; locdEdxSigma[11] = 0.279025; locdEdxSigma[12] = 0.256161; locdEdxSigma[13] = 0.246785; locdEdxSigma[14] = 0.233125; locdEdxSigma[15] = 0.227021; locdEdxSigma[16] = 0.218084; locdEdxSigma[17] = 0.210811; locdEdxSigma[18] = 0.205133; locdEdxSigma[19] = 0.198922; locdEdxSigma[20] = 0.195733; locdEdxSigma[21] = 0.191139; locdEdxSigma[22] = 0.188482; locdEdxSigma[23] = 0.184758; locdEdxSigma[24] = 0.183807; locdEdxSigma[25] = 0.18163; locdEdxSigma[26] = 0.179246; locdEdxSigma[27] = 0.178835; locdEdxSigma[28] = 0.178264; locdEdxSigma[29] = 0.176596; locdEdxSigma[30] = 0.174917; locdEdxSigma[31] = 0.174964; locdEdxSigma[32] = 0.172598; locdEdxSigma[33] = 0.171251; locdEdxSigma[34] = 0.172524; locdEdxSigma[35] = 0.171673; locdEdxSigma[36] = 0.171231; locdEdxSigma[37] = 0.170838; locdEdxSigma[38] = 0.16876; locdEdxSigma[39] = 0.167956; locdEdxSigma[40] = 0.167727; locdEdxSigma[41] = 0.168108; locdEdxSigma[42] = 0.167474; locdEdxSigma[43] = 0.16609; locdEdxSigma[44] = 0.166928; locdEdxSigma[45] = 0.164927; locdEdxSigma[46] = 0.166005; locdEdxSigma[47] = 0.166381; locdEdxSigma[48] = 0.165866;
1262  for(unsigned int loc_i = 0; loc_i < locNumPoints; loc_i++){
1263  locXUncertaintyArray[loc_i] = 0.0;
1264  locPArray[loc_i] = locMass*locBetaGamma[loc_i];
1265  }
1266  locGraphErrors = new TGraphErrors(locNumPoints, locBetaGamma, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1267  locGraphErrors->GetXaxis()->SetTitle("#beta#gamma");
1268  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1269  locVsBetaGammaArray->AddAt(locGraphErrors, 5);
1270  locGraphErrors = new TGraphErrors(locNumPoints, locPArray, locdEdxMean, locXUncertaintyArray, locdEdxSigma);
1271  locGraphErrors->GetXaxis()->SetTitle("p (GeV/c)");
1272  locGraphErrors->GetYaxis()->SetTitle("#frac{dE}{dx} #mu");
1273  locVsPArray->AddAt(locGraphErrors, 5);
1274 
1275  DrawAndSave_ddhHistOrGraphSuperimposition<TGraphErrors>(locVsBetaGammaArray, locDrawInstructions, 1);
1276  DrawAndSave_ddhHistOrGraphSuperimposition<TGraphErrors>(locVsPArray, locDrawInstructions, 1);
1277 }
1278 
Fit_dEdxUncertainty_FDC_NumHitsBinCompare
void Fit_dEdxUncertainty_FDC_NumHitsBinCompare(const string &locFileName, int locParticleFlag, int locDrawFlag=1)
Definition: FitSpectra.C:199
Setup_Routines
void Setup_Routines()
Definition: FitSpectra.C:4
Draw_ProtonPiPlusOverlap
void Draw_ProtonPiPlusOverlap()
Definition: FitSpectra.C:1106
Draw_ConfidenceLevels
void Draw_ConfidenceLevels(const string &locFileName, int locCDCFlag)
Definition: FitSpectra.C:32
Fit_ToGaussians
void Fit_ToGaussians(const TH2F *loc2FHist, TGraphErrors *&locGraphErrors_Mean, TGraphErrors *&locGraphErrors_Sigma, int locFitFlag)
Definition: FitSpectra.C:503
Fit_dEdxUncertainty_Mean
void Fit_dEdxUncertainty_Mean(const string &locFileName, int locParticleFlag, int locCDCFlag, int locDrawFlag=1)
Definition: FitSpectra.C:78
Fit_dEdxUncertainty_CDC_NumHitsBinCompare
void Fit_dEdxUncertainty_CDC_NumHitsBinCompare(const string &locFileName, int locParticleFlag, int locDrawFlag=1)
Definition: FitSpectra.C:351
locHist
TH2D * locHist
Definition: HistMacro_TrackMultiplicity.C:11
gDrawFlag
int gDrawFlag
Definition: FitSpectra.C:2
sqrt
double sqrt(double)
gRoutineSetupFlag
int gRoutineSetupFlag
Definition: FitSpectra.C:1