ATLAS Offline Software
TRTCalib_bhadd.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 #include <fstream>
5 #include <sstream>
6 #include <iomanip>
7 #include <cstdlib>
8 #include <cstdio>
9 #include <cmath>
10 #include <TMath.h>
11 #include <iostream>
12 #include <sys/time.h>
13 #include <sys/resource.h>
14 #include <sys/sysinfo.h>
15 #include <map>
16 #include <vector>
17 #include <TFile.h>
18 #include <TNtuple.h>
19 #include <TH2F.h>
20 #include <TH1D.h>
21 #include <TVectorD.h>
22 using namespace std;
23 
24 int Simple1dHist(float min, float max, int nbins, float value)
25 {
26  if ((value < min) or (value > max))
27  return -1;
28  int binno = (int)(nbins * ((value - min) / (max - min)));
29  return binno;
30 }
31 
32 int Simple2dHist(float minx, float maxx, int nbinsx, float miny, float maxy, int nbinsy, float valuex, float valuey)
33 {
34  if (valuex < minx or valuex > maxx or valuey < miny or valuey > maxy)
35  return -1;
36  int binnox = (int)(nbinsx * ((valuex - minx) / (maxx - minx)));
37  int binnoy = (int)(nbinsy * ((valuey - miny) / (maxy - miny)));
38  return binnoy * nbinsx + binnox;
39 }
40 
41 void process_mem_usage(double &vm_usage, double &resident_set)
42 {
43  using std::ifstream;
44  using std::ios_base;
45  using std::string;
46 
47  vm_usage = 0.0;
48  resident_set = 0.0;
49 
50  // 'file' stat seems to give the most reliable results
51  //
52  ifstream stat_stream("/proc/self/stat", ios_base::in);
53 
54  // dummy vars for leading entries in stat that we don't care about
55  //
56  string pid, comm, state, ppid, pgrp, session, tty_nr;
57  string tpgid, flags, minflt, cminflt, majflt, cmajflt;
58  string utime, stime, cutime, cstime, priority, nice;
59  string O, itrealvalue, starttime;
60 
61  // the two fields we want
62  //
63  unsigned long vsize;
64  long rss;
65 
66  stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt >> utime >> stime >> cutime >> cstime >> priority >> nice >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest
67 
68  long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
69  vm_usage = vsize / 1024.0;
70  resident_set = rss * page_size_kb;
71 }
72 
73 //=========================================
74 
75 class CalHist
76 {
77 public:
78  CalHist();
79  ~CalHist();
80  int IncreaseBin(short, unsigned short);
81  // void Print(int);
82  void GetArray(std::vector<int> &, int);
83  // void AddHist(int*, int);
84  int maxvalue;
85 
86 private:
87  // int* array;
88  map<short, unsigned short> m_hist;
89 };
90 
91 CalHist::CalHist()
92 {
93  maxvalue = 0;
94 }
95 
96 CalHist::~CalHist() {}
97 
98 int CalHist::IncreaseBin(short bin, unsigned short value)
99 {
100  if (m_hist.find(bin) == m_hist.end())
101  {
102  m_hist[bin] = value;
103  if (m_hist[bin] > maxvalue)
104  maxvalue = m_hist[bin];
105  return 1;
106  }
107  else
108  {
109  m_hist[bin] = m_hist[bin] + value;
110  if (m_hist[bin] > maxvalue)
111  maxvalue = m_hist[bin];
112  return 0;
113  }
114 }
115 
116 /*
117 void CalHist::Print(int nbins){
118  for (int ibin=0; ibin<=nbins; ibin++){
119  if(hist.find(ibin) != hist.end()) cout << hist[ibin] << " ";
120  else cout << "0 ";
121  }
122  cout << endl;
123 }
124 */
125 void CalHist::GetArray(std::vector<int>& array, int nbins)
126 {
127  for (int ibin = 0; ibin < nbins; ibin++)
128  {
129  if (m_hist.find(ibin) != m_hist.end())
130  array.at(ibin) = m_hist[ibin];
131  else
132  array.at(ibin) = 0;
133  }
134 }
135 
136 // void CalHist::AddHist(int* array, int nbins){
137 //
138 // }
139 
140 //=========================================
141 
142 class CompBHist
143 {
144 
145 public:
146  CompBHist(int, const std::vector<int> & , int, int);
147  ~CompBHist();
148  CompBHist(const CompBHist &) = delete;
149  CompBHist &operator=(const CompBHist &) = delete;
150 
151  int Print();
152  void Write(ofstream *);
153  int GetStat(int);
154  int *hist{};
155  int id{};
156  int npop{};
157 };
158 
159 CompBHist::CompBHist(int sid, const std::vector<int> & uchist, int ntbins, int nrbins)
160 {
161 
162  id = sid;
163  npop = 0;
164  std::vector<std::vector<int>> tmp(2, std::vector<int>(ntbins * nrbins + 200, 0));
165 
166  for (int ibin = 0; ibin < ntbins * nrbins + 200; ibin++)
167  {
168  if (uchist.at(ibin) > 0)
169  {
170  tmp.at(0).at(npop) = ibin;
171  tmp.at(1).at(npop) = uchist.at(ibin);
172  npop++;
173  }
174  }
175 
176  hist = new int[npop * 2 + 2];
177  hist[0] = npop;
178  hist[npop * 2 + 1] = id;
179  for (int ipop = 0; ipop < npop; ipop++)
180  {
181  hist[ipop * 2 + 1] = tmp.at(0).at(ipop);
182  hist[ipop * 2 + 2] = tmp.at(1).at(ipop);
183  }
184 }
185 
186 CompBHist::~CompBHist()
187 {
188  delete[] hist;
189 }
190 
191 int CompBHist::Print()
192 {
193  // for(int ipop=0;ipop<1;ipop++) cout << hist[ipop] << " ";
194  cout << npop << " " << id << " ";
195  for (int ipop = 0; ipop < 2 * npop + 2; ipop++)
196  cout << hist[ipop] << " ";
197  cout << endl;
198  return 0;
199 }
200 
201 void CompBHist::Write(ofstream *file)
202 {
203  file->write((char *)hist, (npop * 2 + 2) * sizeof(int));
204 }
205 
206 int CompBHist::GetStat(int val)
207 {
208 
209  int stat[3];
210  stat[0] = 0;
211  stat[1] = 0;
212  stat[2] = 0;
213 
214  for (int ipop = 0; ipop < 2 * npop; ipop = ipop + 2)
215  {
216  if (hist[ipop] < 100)
217  stat[0] += hist[ipop + 1];
218  else if (hist[ipop] >= 100 && hist[ipop] < 200)
219  stat[1] += hist[ipop + 1];
220  else
221  stat[2] += hist[ipop + 1];
222  }
223 
224  return stat[val];
225 }
226 
227 //=========================================
228 
229 class trackdata
230 {
231 public:
232  float run, event, track, nhits, epnew, epold, t0, t, ttrack, theta, phi, pt, d0, trackres, trackresMean;
233 };
234 
235 struct calibpars
236 {
237  float t0;
238  float dt0;
239 };
240 
241 map<string, calibpars> readoldpars()
242 {
243  string line;
244  ifstream oldconstfile("precision_constants.txt");
245  int det, lay, mod, stl, stw;
246  float t0, dt0;
247  map<string, calibpars> oldparsmap;
248  char key[100];
249 
250  if (oldconstfile.is_open())
251  {
252  while (!oldconstfile.eof())
253  {
254  getline(oldconstfile, line);
255  if (line.size() > 25 && line.size() < 55)
256  {
257  sscanf(line.data(), "%d %d %d %d %d : %e %e", &det, &lay, &mod, &stl, &stw, &t0, &dt0);
258  if (det >= -3 && lay > -1 && mod > -1 && stl > -1 && stw > -1)
259  {
260  sprintf(key, "_%i_%i_%i_%i_%i", det, lay, mod, stl, stw);
261  oldparsmap[string(key)].t0 = t0;
262  oldparsmap[string(key)].dt0 = dt0;
263  }
264  }
265  }
266  oldconstfile.close();
267  }
268  else{
269  // Output to std::cout since for online calibration this file is not used.
270  std::cout << "Unable to open precision t0 file!\n";
271  }
272 
273 
274  return oldparsmap;
275 }
276 
277 int dump_tracktuple(map<string, trackdata> *trackmap)
278 {
279 
280  TFile *ttfile = new TFile("tracktuple.root", "UPDATE");
281  TNtuple *tracktup = new TNtuple("tracktuple", "track data", "run:evt:track:epnew:epold:nhits:t0:t:ttrack:theta:phi:d0:pt:trackres:trackresMean");
282  for (std::map<std::string, trackdata>::iterator iep = trackmap->begin(); iep != trackmap->end(); ++iep)
283  {
284  tracktup->Fill(iep->second.run, iep->second.event, iep->second.track, iep->second.epnew / iep->second.nhits, iep->second.epold, iep->second.nhits, iep->second.t0 / iep->second.nhits, iep->second.t / iep->second.nhits, iep->second.ttrack / iep->second.nhits, iep->second.theta, iep->second.phi, iep->second.d0, iep->second.pt, (iep->second.trackres / iep->second.nhits), (iep->second.trackresMean / iep->second.nhits));
285  }
286  ttfile->Write();
287  ttfile->Close();
288  // tracktup->Delete();
289  return 0;
290 }
291 
292 int dump_hists(map<int, CalHist *> *histmap, int ntbins, int nrbins, int /*ntres*/, char *fname, int fileno)
293 {
294 
295  std::vector<int> temparray(ntbins * nrbins + 200, 0);
296  int maxnpop = 0;
297  int totnpop = 0;
298  ofstream ofile(Form("%s.part%i", fname, fileno), ios::out | ios::binary | ios::app);
299  for (map<int, CalHist *>::iterator it = histmap->begin(); it != histmap->end(); ++it)
300  {
301  it->second->GetArray(temparray, ntbins * nrbins + 200);
302  CompBHist *cbhist = new CompBHist(it->first, temparray, ntbins, nrbins);
303  cbhist->Write(&ofile);
304  if (cbhist->npop > maxnpop)
305  maxnpop = cbhist->npop;
306  totnpop += cbhist->npop;
307  delete cbhist;
308  }
309 
310  cout << "DUMPING " << histmap->size() << " HISTOGRAMS, MAX NONZERO BINS: " << maxnpop << ", AVERAGE NONZERO BINS: " << (float)totnpop / histmap->size() << endl;
311 
312  ofile.close();
313 
314  return 0;
315 }
316 
317 //=========================================
318 
319 int main(int argc, char *argv[])
320 {
321 
322  bool existAr = false;
323 
324  float ptcutforerrors = 2;
325  // int who = RUSAGE_SELF;
326  // struct rusage usage;
327  // struct sysinfo sinfo;
328  // int ret;
329  double vm, rss;
330 
331  float run, evt, trk, det, lay, mod, stl, stw, brd, chp, fsid, r, dr, t, rtrack, ttrack, drtrack, t0, ephase, theta, phi, pt, d0, ToT, HT, qoverp, isArgonStraw;
332  int sid;
333  pt = 0;
334  d0 = 0;
335  phi = 0;
336  theta = 0;
337  map<int, CalHist *> histmap;
338  map<string, trackdata> trackmap;
339 
340  int ntbins = 55, nrbins = 100, ntresbins = 100, nresbins = 100, nhistbins, maxvalue = 0;
341  // int ntbins=64,nrbins=64,ntresbins=100,nresbins=100,nhistbins,maxvalue=0;
342  double minr = 0, maxr = 2, mint = -5, maxt = 50, mintres = -10, maxtres = 10, minres = -0.6, maxres = 0.6;
343  // double minr=0,maxr=2,mint=-10,maxt=80,mintres=-25,maxtres=25,minres=-1.0,maxres=1.0;
344 
345  // int ntbins=64,nrbins=64,ntresbins=100,nresbins=100,nhistbins,maxvalue=0;
346  // double minr=0,maxr=2,mint=-10,maxt=80,mintres=-25,maxtres=25,minres=-1.0,maxres=1.0;
347 
348  // sscanf (argv[1],"%i",&ntbins);
349  // sscanf (argv[2],"%i",&nrbins);
350  nhistbins = ntbins * nrbins + 200;
351 
352  int npop;
353  // char header[50];
354  std::vector<int> histdata(nhistbins, 0);
355 
356  int nhits = 0, nhists = 0;
357  int ntres = 0, nres = 0, nrt = 0;
358  int nhistsadd = 0, nbinsadd = 0, nhiststmp = 0;
359 
360  int nfiles = argc - 2;
361  cout << "PROCESSING " << nfiles << " FILE(S)" << endl
362  << endl;
363 
364  ofstream ofilestat((string(argv[1]) + ".stat").data(), ios::out);
365 
366  TH1F *residual_ref = new TH1F("residual_-2_0_0_1", "residual_-2_0_0_1", nresbins, minres, maxres);
367  TH1F *timeresidual_ref = new TH1F("timeresidual_1_0_0_0_1", "timeresidual_1_0_0_0_1", ntresbins, mintres, maxtres);
368  TH2F *rt_ref = new TH2F("rt_-1_2", "rt_-1_2", ntbins, mint, maxt, nrbins, minr, maxr);
369  TH2F *rt_ref2 = new TH2F("rt_-1", "rt_-1", ntbins, mint, maxt, nrbins, minr, maxr);
370 
371  TH2F *reshist_trt = new TH2F("residual_trt", "residual_trt", ntbins, mint, maxt, 100, -0.4, 0.4);
372  TH2F *reshist_bar = new TH2F("residual_bar", "residual_bar", ntbins, mint, maxt, 100, -0.4, 0.4);
373  TH2F *reshist1 = new TH2F("residual_1", "residual_1", ntbins, mint, maxt, 100, -0.4, 0.4);
374  TH2F *reshist2 = new TH2F("residual_-1", "residual_-1", ntbins, mint, maxt, 100, -0.4, 0.4);
375  TH2F *reshist3 = new TH2F("residual_2", "residual_2", ntbins, mint, maxt, 100, -0.4, 0.4);
376  TH2F *reshist4 = new TH2F("residual_-2", "residual_-2", ntbins, mint, maxt, 100, -0.4, 0.4);
377 
378  TH2F *treshist_trt = new TH2F("timeresidual_trt", "timeresidual_trt", 50, mintres, maxtres, nrbins, minr, maxr);
379  TH2F *treshist_bar = new TH2F("timeresidual_bar", "timeresidual_bar", 50, mintres, maxtres, nrbins, minr, maxr);
380  TH2F *treshist1 = new TH2F("timeresidual_1", "timeresidual_1", 50, mintres, maxtres, nrbins, minr, maxr);
381  TH2F *treshist2 = new TH2F("timeresidual_-1", "timeresidual_-1", 50, mintres, maxtres, nrbins, minr, maxr);
382  TH2F *treshist3 = new TH2F("timeresidual_2", "timeresidual_2", 50, mintres, maxtres, nrbins, minr, maxr);
383  TH2F *treshist4 = new TH2F("timeresidual_-2", "timeresidual_-2", 50, mintres, maxtres, nrbins, minr, maxr);
384 
385  map<string, calibpars> pt0map = readoldpars();
386 
387  // Histograms to do error study: Barrel/Ecs:
388 
389  // Pt dependent:
390 
391  // Pull All hits:
392  TH2F *pull_trt = new TH2F("pull_trt", "pull_TRT_allhits", 16, 0, 16, 200, -4, 4);
393  TH2F *pull_ba = new TH2F("pull_ba", "pull_BarrelA_allhits", 16, 0, 16, 200, -4, 4);
394  TH2F *pull_bc = new TH2F("pull_bc", "pull_BarrelC_allhits", 16, 0, 16, 200, -4, 4);
395  TH2F *pull_ea = new TH2F("pull_ea", "pull_EndcapA_allhits", 16, 0, 16, 200, -4, 4);
396  TH2F *pull_ec = new TH2F("pull_ec", "pull_EndcapC_allhits", 16, 0, 16, 200, -4, 4);
397 
398  // Residual All hits:
399  TH2F *residual_trt = new TH2F("residual_allhits", "residual_TRT_allhits", 16, 0, 16, 200, -2, 2);
400  TH2F *residual_ba = new TH2F("residual_ba", "residual_BarrelA_allhits", 16, 0, 16, 200, -2, 2);
401  TH2F *residual_bc = new TH2F("residual_bc", "residual_BarrelC_allhits", 16, 0, 16, 200, -2, 2);
402  TH2F *residual_ea = new TH2F("residual_ea", "residual_EndcapA_allhits", 16, 0, 16, 200, -2, 2);
403  TH2F *residual_ec = new TH2F("residual_ec", "residual_EndcapC_allhits", 16, 0, 16, 200, -2, 2);
404 
405  // Time Residual All hits:
406  TH2F *tresidual_trt = new TH2F("tresidual_trt", "tresidual_TRT_allhits", 16, 0, 16, 200, -20, 20);
407  TH2F *tresidual_ba = new TH2F("tresidual_ba", "tresidual_BarrelA_allhits", 16, 0, 16, 200, -20, 20);
408  TH2F *tresidual_bc = new TH2F("tresidual_bc", "tresidual_BarrelC_allhits", 16, 0, 16, 200, -20, 20);
409  TH2F *tresidual_ea = new TH2F("tresidual_ea", "tresidual_EndcapA_allhits", 16, 0, 16, 200, -20, 20);
410  TH2F *tresidual_ec = new TH2F("tresidual_ec", "tresidual_EndcapC_allhits", 16, 0, 16, 200, -20, 20);
411 
412  // Pull Precision hits:
413  TH2F *pull_trtP = new TH2F("pull_trtP", "pull_TRT_Phits", 16, 0, 16, 200, -4, 4);
414  TH2F *pull_baP = new TH2F("pull_baP", "pull_BarrelA_Phits", 16, 0, 16, 200, -4, 4);
415  TH2F *pull_bcP = new TH2F("pull_bcP", "pull_BarrelC_Phits", 16, 0, 16, 200, -4, 4);
416  TH2F *pull_eaP = new TH2F("pull_eaP", "pull_EndcapA_Phits", 16, 0, 16, 200, -4, 4);
417  TH2F *pull_ecP = new TH2F("pull_ecP", "pull_EndcapC_Phits", 16, 0, 16, 200, -4, 4);
418  // Residaul Precision hits:
419  TH2F *residual_trtP = new TH2F("residual_trtP", "residual_TRT_Phits", 16, 0, 16, 200, -2, 2);
420  TH2F *residual_baP = new TH2F("residual_baP", "residual_BarrelA_Phits", 16, 0, 16, 200, -2, 2);
421  TH2F *residual_bcP = new TH2F("residual_bcP", "residual_BarrelC_Phits", 16, 0, 16, 200, -2, 2);
422  TH2F *residual_eaP = new TH2F("residual_eaP", "residual_EndcapA_Phits", 16, 0, 16, 200, -2, 2);
423  TH2F *residual_ecP = new TH2F("residual_ecP", "residual_EndcapC_Phits", 16, 0, 16, 200, -2, 2);
424  // Residaul Precision hits:
425  TH2F *tresidual_trtP = new TH2F("tresidual_trtP", "residual_TRT_Phits", 16, 0, 16, 200, -20, 20);
426  TH2F *tresidual_baP = new TH2F("tresidual_baP", "residual_BarrelA_Phits", 16, 0, 16, 200, -20, 20);
427  TH2F *tresidual_bcP = new TH2F("tresidual_bcP", "residual_BarrelC_Phits", 16, 0, 16, 200, -20, 20);
428  TH2F *tresidual_eaP = new TH2F("tresidual_eaP", "residual_EndcapA_Phits", 16, 0, 16, 200, -20, 20);
429  TH2F *tresidual_ecP = new TH2F("tresidual_ecP", "residual_EndcapC_Phits", 16, 0, 16, 200, -20, 20);
430  // Track Errors :
431  TH2F *trackerrors_trtP = new TH2F("trackerrors_trt", "trackerrors_vs_pt_trt", 16, 0, 16, 200, 0, 0.2);
432  TH2F *trackerrors_baP = new TH2F("trackerrors_ba", "trackerrors_vs_pt_BarrelA", 16, 0, 16, 200, 0, .2);
433  TH2F *trackerrors_bcP = new TH2F("trackerrors_bc", "trackerrors_vs_pt_BarrelC", 16, 0, 16, 200, 0, .2);
434  TH2F *trackerrors_eaP = new TH2F("trackerrors_ea", "trackerrors_vs_pt_EndcapA", 16, 0, 16, 200, 0, .2);
435  TH2F *trackerrors_ecP = new TH2F("trackerrors_ec", "trackerrors_vs_pt_EndcapC", 16, 0, 16, 200, 0, .2);
436 
437  // for (map<string,calibpars>::iterator iot=pt0map.begin(); iot!=pt0map.end(); iot++) {
438 
439  // Time Bin Dependent:
440 
441  int ntbins2 = 30;
442  float tmin = -10;
443  float tmax = 75;
444 
445  // TH2 to Store the Pull vs width:
446  TH2F *pull_vs_tb_trt = new TH2F("pull_vs_tb_trt", "pull_vs_timebin_trt", ntbins2, tmin, tmax, 200, -4, 4);
447  TH2F *pull_vs_tb_ba = new TH2F("pull_vs_tb_ba", "pull_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, -4, 4);
448  TH2F *pull_vs_tb_bc = new TH2F("pull_vs_tb_bc", "pull_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, -4, 4);
449  TH2F *pull_vs_tb_ea = new TH2F("pull_vs_tb_ea", "pull_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, -4, 4);
450  TH2F *pull_vs_tb_ec = new TH2F("pull_vs_tb_ec", "pull_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, -4, 4);
451 
452  // TH2 to Store the ErrorsUsed vs width:
453  TH2F *errors_vs_tb_trt = new TH2F("errors_vs_tb_trt", "errors_vs_timebin_trt", ntbins2, tmin, tmax, 200, 0, 0.4);
454  TH2F *errors_vs_tb_ba = new TH2F("errors_vs_tb_ba", "errors_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, 0, 0.4);
455  TH2F *errors_vs_tb_bc = new TH2F("errors_vs_tb_bc", "errors_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, 0, 0.4);
456  TH2F *errors_vs_tb_ea = new TH2F("errors_vs_tb_ea", "errors_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, 0, 0.4);
457  TH2F *errors_vs_tb_ec = new TH2F("errors_vs_tb_ec", "errors_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, 0, 0.4);
458 
459  // TH2 to Store the ErrorsUsed vs width:
460  TH2F *residual_vs_tb_trt = new TH2F("residual_vs_tb_trt", "residual_vs_timebin_trt", ntbins2, tmin, tmax, 200, -2, .2);
461  TH2F *residual_vs_tb_ba = new TH2F("residual_vs_tb_ba", "residual_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, -2, .2);
462  TH2F *residual_vs_tb_bc = new TH2F("residual_vs_tb_bc", "residual_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, -2, .2);
463  TH2F *residual_vs_tb_ea = new TH2F("residual_vs_tb_ea", "residual_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, -2, .2);
464  TH2F *residual_vs_tb_ec = new TH2F("residual_vs_tb_ec", "residual_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, -2, .2);
465 
466  // TH2 to Store the Track Errors vs width:
467  TH2F *trackerrors_vs_tb_trt = new TH2F("trackerrors_vs_tb_trt", "trackerrors_vs_timebin_trt", ntbins2, tmin, tmax, 200, 0, 0.2);
468  TH2F *trackerrors_vs_tb_ba = new TH2F("trackerrors_vs_tb_ba", "trackerrors_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, 0, .2);
469  TH2F *trackerrors_vs_tb_bc = new TH2F("trackerrors_vs_tb_bc", "trackerrors_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, 0, .2);
470  TH2F *trackerrors_vs_tb_ea = new TH2F("trackerrors_vs_tb_ea", "trackerrors_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, 0, .2);
471  TH2F *trackerrors_vs_tb_ec = new TH2F("trackerrors_vs_tb_ec", "trackerrors_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, 0, .2);
472 
473  // Histograms to store the ToT Corrections, TIME RESIDUAL:
474  TH2F *tres_vs_ToT_trt = new TH2F("tres_vs_ToT_trt", "tres_vs_ToT_trt", 24, -0.5, 23.5, 200, -20, 20);
475  TH2F *tres_vs_ToT_ba = new TH2F("tres_vs_ToT_ba", "tres_vs_ToT_ba", 24, -0.5, 23.5, 200, -20, 20);
476  TH2F *tres_vs_ToT_bc = new TH2F("tres_vs_ToT_bc", "tres_vs_ToT_bc", 24, -0.5, 23.5, 200, -20, 20);
477  TH2F *tres_vs_ToT_ea = new TH2F("tres_vs_ToT_ea", "tres_vs_ToT_ea", 24, -0.5, 23.5, 200, -20, 20);
478  TH2F *tres_vs_ToT_ec = new TH2F("tres_vs_ToT_ec", "tres_vs_ToT_ec", 24, -0.5, 23.5, 200, -20, 20);
479 
480  // Residual:
481  TH2F *res_vs_ToT_trt = new TH2F("res_vs_ToT_trt", "res_vs_ToT_trt", 24, -0.5, 23.5, 200, -2, 2);
482  TH2F *res_vs_ToT_ba = new TH2F("res_vs_ToT_ba", "res_vs_ToT_ba", 24, -0.5, 23.5, 200, -2, 2);
483  TH2F *res_vs_ToT_bc = new TH2F("res_vs_ToT_bc", "res_vs_ToT_bc", 24, -0.5, 23.5, 200, -2, 2);
484  TH2F *res_vs_ToT_ea = new TH2F("res_vs_ToT_ea", "res_vs_ToT_ea", 24, -0.5, 23.5, 200, -2, 2);
485  TH2F *res_vs_ToT_ec = new TH2F("res_vs_ToT_ec", "res_vs_ToT_ec", 24, -0.5, 23.5, 200, -2, 2);
486 
487  // Histograms to store the HT Corrections, TIME RESIDUAL:
488  TH2F *tres_vs_HT_trt = new TH2F("tres_vs_HT_trt", "tres_vs_HT_trt", 2, -0.5, 1.5, 200, -20, 20);
489  TH2F *tres_vs_HT_ba = new TH2F("tres_vs_HT_ba", "tres_vs_HT_ba", 2, -0.5, 1.5, 200, -20, 20);
490  TH2F *tres_vs_HT_bc = new TH2F("tres_vs_HT_bc", "tres_vs_HT_bc", 2, -0.5, 1.5, 200, -20, 20);
491  TH2F *tres_vs_HT_ea = new TH2F("tres_vs_HT_ea", "tres_vs_HT_ea", 2, -0.5, 1.5, 200, -20, 20);
492  TH2F *tres_vs_HT_ec = new TH2F("tres_vs_HT_ec", "tres_vs_HT_ec", 2, -0.5, 1.5, 200, -20, 20);
493 
494  // Residual:
495  TH2F *res_vs_HT_trt = new TH2F("res_vs_HT_trt", "res_vs_HT_trt", 2, -0.5, 1.5, 200, -2, 2);
496  TH2F *res_vs_HT_ba = new TH2F("res_vs_HT_ba", "res_vs_HT_ba", 2, -0.5, 1.5, 200, -2, 2);
497  TH2F *res_vs_HT_bc = new TH2F("res_vs_HT_bc", "res_vs_HT_bc", 2, -0.5, 1.5, 200, -2, 2);
498  TH2F *res_vs_HT_ea = new TH2F("res_vs_HT_ea", "res_vs_HT_ea", 2, -0.5, 1.5, 200, -2, 2);
499  TH2F *res_vs_HT_ec = new TH2F("res_vs_HT_ec", "res_vs_HT_ec", 2, -0.5, 1.5, 200, -2, 2);
500 
501  // Histograms to store the sin(theta)/p Corrections, TIME RESIDUAL:
502  TH2F *tres_vs_SinOverP_trt = new TH2F("tres_vs_SinOverP_trt", "tres_vs_SinOverP_trt", 24, 0., 1., 200, -20., 20.);
503  TH2F *tres_vs_SinOverP_ba = new TH2F("tres_vs_SinOverP_ba", "tres_vs_SinOverP_ba", 24, 0., 1., 200, -20., 20.);
504  TH2F *tres_vs_SinOverP_bc = new TH2F("tres_vs_SinOverP_bc", "tres_vs_SinOverP_bc", 24, 0., 1., 200, -20., 20.);
505  TH2F *tres_vs_SinOverP_ea = new TH2F("tres_vs_SinOverP_ea", "tres_vs_SinOverP_ea", 24, 0., 1., 200, -20., 20.);
506  TH2F *tres_vs_SinOverP_ec = new TH2F("tres_vs_SinOverP_ec", "tres_vs_SinOverP_ec", 24, 0., 1., 200, -20., 20.);
507 
508  // Residual:
509  TH2F *res_vs_SinOverP_trt = new TH2F("res_vs_SinOverP_trt", "res_vs_SinOverP_trt", 24, 0., 1., 200, -2., 2.);
510  TH2F *res_vs_SinOverP_ba = new TH2F("res_vs_SinOverP_ba", "res_vs_SinOverP_ba", 24, 0., 1., 200, -2., 2.);
511  TH2F *res_vs_SinOverP_bc = new TH2F("res_vs_SinOverP_bc", "res_vs_SinOverP_bc", 24, 0., 1., 200, -2., 2.);
512  TH2F *res_vs_SinOverP_ea = new TH2F("res_vs_SinOverP_ea", "res_vs_SinOverP_ea", 24, 0., 1., 200, -2., 2.);
513  TH2F *res_vs_SinOverP_ec = new TH2F("res_vs_SinOverP_ec", "res_vs_SinOverP_ec", 24, 0., 1., 200, -2., 2.);
514 
515  // Histograms to store the sin(theta)/p Corrections, TIME RESIDUAL:
516  TH2F *tres_vs_CosOverP_trt = new TH2F("tres_vs_CosOverP_trt", "tres_vs_CosOverP_trt", 24, 0., 1., 200, -20., 20.);
517  TH2F *tres_vs_CosOverP_ba = new TH2F("tres_vs_CosOverP_ba", "tres_vs_CosOverP_ba", 24, 0., 1., 200, -20., 20.);
518  TH2F *tres_vs_CosOverP_bc = new TH2F("tres_vs_CosOverP_bc", "tres_vs_CosOverP_bc", 24, 0., 1., 200, -20., 20.);
519  TH2F *tres_vs_CosOverP_ea = new TH2F("tres_vs_CosOverP_ea", "tres_vs_CosOverP_ea", 24, 0., 1., 200, -20., 20.);
520  TH2F *tres_vs_CosOverP_ec = new TH2F("tres_vs_CosOverP_ec", "tres_vs_CosOverP_ec", 24, 0., 1., 200, -20., 20.);
521 
522  // Residual:
523  TH2F *res_vs_CosOverP_trt = new TH2F("res_vs_CosOverP_trt", "res_vs_CosOverP_trt", 24, 0., 1., 200, -2., 2.);
524  TH2F *res_vs_CosOverP_ba = new TH2F("res_vs_CosOverP_ba", "res_vs_CosOverP_ba", 24, 0., 1., 200, -2., 2.);
525  TH2F *res_vs_CosOverP_bc = new TH2F("res_vs_CosOverP_bc", "res_vs_CosOverP_bc", 24, 0., 1., 200, -2., 2.);
526  TH2F *res_vs_CosOverP_ea = new TH2F("res_vs_CosOverP_ea", "res_vs_CosOverP_ea", 24, 0., 1., 200, -2., 2.);
527  TH2F *res_vs_CosOverP_ec = new TH2F("res_vs_CosOverP_ec", "res_vs_CosOverP_ec", 24, 0., 1., 200, -2., 2.);
528 
529  // HISTOGRAMS FOR ARGON STRAWS!!!!
530  TH2F *resArhist_trt = new TH2F("residualAr_trt", "residualAr_trt", ntbins, mint, maxt, 100, -0.4, 0.4);
531  TH2F *resArhist_bar = new TH2F("residualAr_bar", "residualAr_bar", ntbins, mint, maxt, 100, -0.4, 0.4);
532  TH2F *resArhist1 = new TH2F("residualAr_1", "residualAr_1", ntbins, mint, maxt, 100, -0.4, 0.4);
533  TH2F *resArhist2 = new TH2F("residualAr_-1", "residualAr_-1", ntbins, mint, maxt, 100, -0.4, 0.4);
534  TH2F *resArhist3 = new TH2F("residualAr_2", "residualAr_2", ntbins, mint, maxt, 100, -0.4, 0.4);
535  TH2F *resArhist4 = new TH2F("residualAr_-2", "residualAr_-2", ntbins, mint, maxt, 100, -0.4, 0.4);
536 
537  TH2F *tresArhist_trt = new TH2F("timeresidualAr_trt", "timeresidualAr_trt", 50, mintres, maxtres, nrbins, minr, maxr);
538  TH2F *tresArhist_bar = new TH2F("timeresidualAr_bar", "timeresidualAr_bar", 50, mintres, maxtres, nrbins, minr, maxr);
539  TH2F *tresArhist1 = new TH2F("timeresidualAr_1", "timeresidualAr_1", 50, mintres, maxtres, nrbins, minr, maxr);
540  TH2F *tresArhist2 = new TH2F("timeresidualAr_-1", "timeresidualAr_-1", 50, mintres, maxtres, nrbins, minr, maxr);
541  TH2F *tresArhist3 = new TH2F("timeresidualAr_2", "timeresidualAr_2", 50, mintres, maxtres, nrbins, minr, maxr);
542  TH2F *tresArhist4 = new TH2F("timeresidualAr_-2", "timeresidualAr_-2", 50, mintres, maxtres, nrbins, minr, maxr);
543  // Histograms to do error study: Barrel/Ecs:
544 
545  // Pt dependent:
546  // Pull All hits:
547  TH2F *pullAr_trt = new TH2F("pullAr_trt", "pullAr_TRT_allhits", 16, 0, 16, 200, -4, 4);
548  TH2F *pullAr_ba = new TH2F("pullAr_ba", "pullAr_BarrelA_allhits", 16, 0, 16, 200, -4, 4);
549  TH2F *pullAr_bc = new TH2F("pullAr_bc", "pullAr_BarrelC_allhits", 16, 0, 16, 200, -4, 4);
550  TH2F *pullAr_ea = new TH2F("pullAr_ea", "pullAr_EndcapA_allhits", 16, 0, 16, 200, -4, 4);
551  TH2F *pullAr_ec = new TH2F("pullAr_ec", "pullAr_EndcapC_allhits", 16, 0, 16, 200, -4, 4);
552 
553  // Residual All hits:
554  TH2F *residualAr_trt = new TH2F("residualAr_allhits", "residualAr_TRT_allhits", 16, 0, 16, 200, -2, 2);
555  TH2F *residualAr_ba = new TH2F("residualAr_ba", "residualAr_BarrelA_allhits", 16, 0, 16, 200, -2, 2);
556  TH2F *residualAr_bc = new TH2F("residualAr_bc", "residualAr_BarrelC_allhits", 16, 0, 16, 200, -2, 2);
557  TH2F *residualAr_ea = new TH2F("residualAr_ea", "residualAr_EndcapA_allhits", 16, 0, 16, 200, -2, 2);
558  TH2F *residualAr_ec = new TH2F("residualAr_ec", "residualAr_EndcapC_allhits", 16, 0, 16, 200, -2, 2);
559 
560  // Time Residual All hits:
561  TH2F *tresidualAr_trt = new TH2F("tresidualAr_trt", "tresidualAr_TRT_allhits", 16, 0, 16, 200, -20, 20);
562  TH2F *tresidualAr_ba = new TH2F("tresidualAr_ba", "tresidualAr_BarrelA_allhits", 16, 0, 16, 200, -20, 20);
563  TH2F *tresidualAr_bc = new TH2F("tresidualAr_bc", "tresidualAr_BarrelC_allhits", 16, 0, 16, 200, -20, 20);
564  TH2F *tresidualAr_ea = new TH2F("tresidualAr_ea", "tresidualAr_EndcapA_allhits", 16, 0, 16, 200, -20, 20);
565  TH2F *tresidualAr_ec = new TH2F("tresidualAr_ec", "tresidualAr_EndcapC_allhits", 16, 0, 16, 200, -20, 20);
566 
567  // Pull Precision hits:
568  TH2F *pullAr_trtP = new TH2F("pullAr_trtP", "pullAr_TRT_Phits", 16, 0, 16, 200, -4, 4);
569  TH2F *pullAr_baP = new TH2F("pullAr_baP", "pullAr_BarrelA_Phits", 16, 0, 16, 200, -4, 4);
570  TH2F *pullAr_bcP = new TH2F("pullAr_bcP", "pullAr_BarrelC_Phits", 16, 0, 16, 200, -4, 4);
571  TH2F *pullAr_eaP = new TH2F("pullAr_eaP", "pullAr_EndcapA_Phits", 16, 0, 16, 200, -4, 4);
572  TH2F *pullAr_ecP = new TH2F("pullAr_ecP", "pullAr_EndcapC_Phits", 16, 0, 16, 200, -4, 4);
573  // Residaul Precision hits:
574  TH2F *residualAr_trtP = new TH2F("residualAr_trtP", "residualAr_TRT_Phits", 16, 0, 16, 200, -2, 2);
575  TH2F *residualAr_baP = new TH2F("residualAr_baP", "residualAr_BarrelA_Phits", 16, 0, 16, 200, -2, 2);
576  TH2F *residualAr_bcP = new TH2F("residualAr_bcP", "residualAr_BarrelC_Phits", 16, 0, 16, 200, -2, 2);
577  TH2F *residualAr_eaP = new TH2F("residualAr_eaP", "residualAr_EndcapA_Phits", 16, 0, 16, 200, -2, 2);
578  TH2F *residualAr_ecP = new TH2F("residualAr_ecP", "residualAr_EndcapC_Phits", 16, 0, 16, 200, -2, 2);
579  // Residaul Precision hits:
580  TH2F *tresidualAr_trtP = new TH2F("tresidualAr_trtP", "residualAr_TRT_Phits", 16, 0, 16, 200, -20, 20);
581  TH2F *tresidualAr_baP = new TH2F("tresidualAr_baP", "residualAr_BarrelA_Phits", 16, 0, 16, 200, -20, 20);
582  TH2F *tresidualAr_bcP = new TH2F("tresidualAr_bcP", "residualAr_BarrelC_Phits", 16, 0, 16, 200, -20, 20);
583  TH2F *tresidualAr_eaP = new TH2F("tresidualAr_eaP", "residualAr_EndcapA_Phits", 16, 0, 16, 200, -20, 20);
584  TH2F *tresidualAr_ecP = new TH2F("tresidualAr_ecP", "residualAr_EndcapC_Phits", 16, 0, 16, 200, -20, 20);
585  // Track Errors :
586  TH2F *trackerrorsAr_trtP = new TH2F("trackerrorsAr_trt", "trackerrorsAr_vs_pt_trt", 16, 0, 16, 200, 0, 0.2);
587  TH2F *trackerrorsAr_baP = new TH2F("trackerrorsAr_ba", "trackerrorsAr_vs_pt_BarrelA", 16, 0, 16, 200, 0, .2);
588  TH2F *trackerrorsAr_bcP = new TH2F("trackerrorsAr_bc", "trackerrorsAr_vs_pt_BarrelC", 16, 0, 16, 200, 0, .2);
589  TH2F *trackerrorsAr_eaP = new TH2F("trackerrorsAr_ea", "trackerrorsAr_vs_pt_EndcapA", 16, 0, 16, 200, 0, .2);
590  TH2F *trackerrorsAr_ecP = new TH2F("trackerrorsAr_ec", "trackerrorsAr_vs_pt_EndcapC", 16, 0, 16, 200, 0, .2);
591 
592  // Time Bin Dependent:
593 
594  // TH2 to Store the Pull vs width:
595  TH2F *pullAr_vs_tb_trt = new TH2F("pullAr_vs_tb_trt", "pullAr_vs_timebin_trt", ntbins2, tmin, tmax, 200, -4, 4);
596  TH2F *pullAr_vs_tb_ba = new TH2F("pullAr_vs_tb_ba", "pullAr_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, -4, 4);
597  TH2F *pullAr_vs_tb_bc = new TH2F("pullAr_vs_tb_bc", "pullAr_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, -4, 4);
598  TH2F *pullAr_vs_tb_ea = new TH2F("pullAr_vs_tb_ea", "pullAr_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, -4, 4);
599  TH2F *pullAr_vs_tb_ec = new TH2F("pullAr_vs_tb_ec", "pullAr_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, -4, 4);
600 
601  // TH2 to Store the ErrorsUsed vs width:
602  TH2F *errorsAr_vs_tb_trt = new TH2F("errorsAr_vs_tb_trt", "errorsAr_vs_timebin_trt", ntbins2, tmin, tmax, 200, 0, 0.4);
603  TH2F *errorsAr_vs_tb_ba = new TH2F("errorsAr_vs_tb_ba", "errorsAr_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, 0, 0.4);
604  TH2F *errorsAr_vs_tb_bc = new TH2F("errorsAr_vs_tb_bc", "errorsAr_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, 0, 0.4);
605  TH2F *errorsAr_vs_tb_ea = new TH2F("errorsAr_vs_tb_ea", "errorsAr_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, 0, 0.4);
606  TH2F *errorsAr_vs_tb_ec = new TH2F("errorsAr_vs_tb_ec", "errorsAr_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, 0, 0.4);
607 
608  // TH2 to Store the ErrorsUsed vs width:
609  TH2F *residualAr_vs_tb_trt = new TH2F("residualAr_vs_tb_trt", "residualAr_vs_timebin_trt", ntbins2, tmin, tmax, 200, -2, .2);
610  TH2F *residualAr_vs_tb_ba = new TH2F("residualAr_vs_tb_ba", "residualAr_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, -2, .2);
611  TH2F *residualAr_vs_tb_bc = new TH2F("residualAr_vs_tb_bc", "residualAr_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, -2, .2);
612  TH2F *residualAr_vs_tb_ea = new TH2F("residualAr_vs_tb_ea", "residualAr_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, -2, .2);
613  TH2F *residualAr_vs_tb_ec = new TH2F("residualAr_vs_tb_ec", "residualAr_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, -2, .2);
614 
615  // TH2 to Store the Track Errors vs width:
616  TH2F *trackerrorsAr_vs_tb_trt = new TH2F("trackerrorsAr_vs_tb_trt", "trackerrorsAr_vs_timebin_trt", ntbins2, tmin, tmax, 200, 0, 0.2);
617  TH2F *trackerrorsAr_vs_tb_ba = new TH2F("trackerrorsAr_vs_tb_ba", "trackerrorsAr_vs_timebin_BarrelA", ntbins2, tmin, tmax, 200, 0, .2);
618  TH2F *trackerrorsAr_vs_tb_bc = new TH2F("trackerrorsAr_vs_tb_bc", "trackerrorsAr_vs_timebin_BarrelC", ntbins2, tmin, tmax, 200, 0, .2);
619  TH2F *trackerrorsAr_vs_tb_ea = new TH2F("trackerrorsAr_vs_tb_ea", "trackerrorsAr_vs_timebin_EndcapA", ntbins2, tmin, tmax, 200, 0, .2);
620  TH2F *trackerrorsAr_vs_tb_ec = new TH2F("trackerrorsAr_vs_tb_ec", "trackerrorsAr_vs_timebin_EndcapC", ntbins2, tmin, tmax, 200, 0, .2);
621 
622  // Histograms to store the ToT Corrections, TIME RESIDUAL:
623  TH2F *tresAr_vs_ToT_trt = new TH2F("tresAr_vs_ToT_trt", "tresAr_vs_ToT_trt", 24, -0.5, 23.5, 200, -20, 20);
624  TH2F *tresAr_vs_ToT_ba = new TH2F("tresAr_vs_ToT_ba", "tresAr_vs_ToT_ba", 24, -0.5, 23.5, 200, -20, 20);
625  TH2F *tresAr_vs_ToT_bc = new TH2F("tresAr_vs_ToT_bc", "tresAr_vs_ToT_bc", 24, -0.5, 23.5, 200, -20, 20);
626  TH2F *tresAr_vs_ToT_ea = new TH2F("tresAr_vs_ToT_ea", "tresAr_vs_ToT_ea", 24, -0.5, 23.5, 200, -20, 20);
627  TH2F *tresAr_vs_ToT_ec = new TH2F("tresAr_vs_ToT_ec", "tresAr_vs_ToT_ec", 24, -0.5, 23.5, 200, -20, 20);
628 
629  // Residual:
630  TH2F *resAr_vs_ToT_trt = new TH2F("resAr_vs_ToT_trt", "resAr_vs_ToT_trt", 24, -0.5, 23.5, 200, -2, 2);
631  TH2F *resAr_vs_ToT_ba = new TH2F("resAr_vs_ToT_ba", "resAr_vs_ToT_ba", 24, -0.5, 23.5, 200, -2, 2);
632  TH2F *resAr_vs_ToT_bc = new TH2F("resAr_vs_ToT_bc", "resAr_vs_ToT_bc", 24, -0.5, 23.5, 200, -2, 2);
633  TH2F *resAr_vs_ToT_ea = new TH2F("resAr_vs_ToT_ea", "resAr_vs_ToT_ea", 24, -0.5, 23.5, 200, -2, 2);
634  TH2F *resAr_vs_ToT_ec = new TH2F("resAr_vs_ToT_ec", "resAr_vs_ToT_ec", 24, -0.5, 23.5, 200, -2, 2);
635 
636  // Histograms to store the HT Corrections, TIME RESIDUAL:
637  TH2F *tresAr_vs_HT_trt = new TH2F("tresAr_vs_HT_trt", "tresAr_vs_HT_trt", 2, -0.5, 1.5, 200, -20, 20);
638  TH2F *tresAr_vs_HT_ba = new TH2F("tresAr_vs_HT_ba", "tresAr_vs_HT_ba", 2, -0.5, 1.5, 200, -20, 20);
639  TH2F *tresAr_vs_HT_bc = new TH2F("tresAr_vs_HT_bc", "tresAr_vs_HT_bc", 2, -0.5, 1.5, 200, -20, 20);
640  TH2F *tresAr_vs_HT_ea = new TH2F("tresAr_vs_HT_ea", "tresAr_vs_HT_ea", 2, -0.5, 1.5, 200, -20, 20);
641  TH2F *tresAr_vs_HT_ec = new TH2F("tresAr_vs_HT_ec", "tresAr_vs_HT_ec", 2, -0.5, 1.5, 200, -20, 20);
642 
643  // Residual:
644  TH2F *resAr_vs_HT_trt = new TH2F("resAr_vs_HT_trt", "resAr_vs_HT_trt", 2, -0.5, 1.5, 200, -2, 2);
645  TH2F *resAr_vs_HT_ba = new TH2F("resAr_vs_HT_ba", "resAr_vs_HT_ba", 2, -0.5, 1.5, 200, -2, 2);
646  TH2F *resAr_vs_HT_bc = new TH2F("resAr_vs_HT_bc", "resAr_vs_HT_bc", 2, -0.5, 1.5, 200, -2, 2);
647  TH2F *resAr_vs_HT_ea = new TH2F("resAr_vs_HT_ea", "resAr_vs_HT_ea", 2, -0.5, 1.5, 200, -2, 2);
648  TH2F *resAr_vs_HT_ec = new TH2F("resAr_vs_HT_ec", "resAr_vs_HT_ec", 2, -0.5, 1.5, 200, -2, 2);
649 
650  // Histograms to store the sin(theta)/p Corrections, TIME RESIDUAL:
651  TH2F *tresAr_vs_SinOverP_trt = new TH2F("tresAr_vs_SinOverP_trt", "tresAr_vs_SinOverP_trt", 24, 0., 1., 200, -20., 20.);
652  TH2F *tresAr_vs_SinOverP_ba = new TH2F("tresAr_vs_SinOverP_ba", "tresAr_vs_SinOverP_ba", 24, 0., 1., 200, -20., 20.);
653  TH2F *tresAr_vs_SinOverP_bc = new TH2F("tresAr_vs_SinOverP_bc", "tresAr_vs_SinOverP_bc", 24, 0., 1., 200, -20., 20.);
654  TH2F *tresAr_vs_SinOverP_ea = new TH2F("tresAr_vs_SinOverP_ea", "tresAr_vs_SinOverP_ea", 24, 0., 1., 200, -20., 20.);
655  TH2F *tresAr_vs_SinOverP_ec = new TH2F("tresAr_vs_SinOverP_ec", "tresAr_vs_SinOverP_ec", 24, 0., 1., 200, -20., 20.);
656 
657  // Residual:
658  TH2F *resAr_vs_SinOverP_trt = new TH2F("resAr_vs_SinOverP_trt", "resAr_vs_SinOverP_trt", 24, 0., 1., 200, -2., 2.);
659  TH2F *resAr_vs_SinOverP_ba = new TH2F("resAr_vs_SinOverP_ba", "resAr_vs_SinOverP_ba", 24, 0., 1., 200, -2., 2.);
660  TH2F *resAr_vs_SinOverP_bc = new TH2F("resAr_vs_SinOverP_bc", "resAr_vs_SinOverP_bc", 24, 0., 1., 200, -2., 2.);
661  TH2F *resAr_vs_SinOverP_ea = new TH2F("resAr_vs_SinOverP_ea", "resAr_vs_SinOverP_ea", 24, 0., 1., 200, -2., 2.);
662  TH2F *resAr_vs_SinOverP_ec = new TH2F("resAr_vs_SinOverP_ec", "resAr_vs_SinOverP_ec", 24, 0., 1., 200, -2., 2.);
663 
664  // Histograms to store the sin(theta)/p Corrections, TIME RESIDUAL:
665  TH2F *tresAr_vs_CosOverP_trt = new TH2F("tresAr_vs_CosOverP_trt", "tresAr_vs_CosOverP_trt", 24, 0., 1., 200, -20., 20.);
666  TH2F *tresAr_vs_CosOverP_ba = new TH2F("tresAr_vs_CosOverP_ba", "tresAr_vs_CosOverP_ba", 24, 0., 1., 200, -20., 20.);
667  TH2F *tresAr_vs_CosOverP_bc = new TH2F("tresAr_vs_CosOverP_bc", "tresAr_vs_CosOverP_bc", 24, 0., 1., 200, -20., 20.);
668  TH2F *tresAr_vs_CosOverP_ea = new TH2F("tresAr_vs_CosOverP_ea", "tresAr_vs_CosOverP_ea", 24, 0., 1., 200, -20., 20.);
669  TH2F *tresAr_vs_CosOverP_ec = new TH2F("tresAr_vs_CosOverP_ec", "tresAr_vs_CosOverP_ec", 24, 0., 1., 200, -20., 20.);
670 
671  // Residual:
672  TH2F *resAr_vs_CosOverP_trt = new TH2F("resAr_vs_CosOverP_trt", "resAr_vs_CosOverP_trt", 24, 0., 1., 200, -2., 2.);
673  TH2F *resAr_vs_CosOverP_ba = new TH2F("resAr_vs_CosOverP_ba", "resAr_vs_CosOverP_ba", 24, 0., 1., 200, -2., 2.);
674  TH2F *resAr_vs_CosOverP_bc = new TH2F("resAr_vs_CosOverP_bc", "resAr_vs_CosOverP_bc", 24, 0., 1., 200, -2., 2.);
675  TH2F *resAr_vs_CosOverP_ea = new TH2F("resAr_vs_CosOverP_ea", "resAr_vs_CosOverP_ea", 24, 0., 1., 200, -2., 2.);
676  TH2F *resAr_vs_CosOverP_ec = new TH2F("resAr_vs_CosOverP_ec", "resAr_vs_CosOverP_ec", 24, 0., 1., 200, -2., 2.);
677 
678  // for (map<string,calibpars>::iterator iot=pt0map.begin(); iot!=pt0map.end(); iot++) {
679  // cout << iot->second.t0 << " " << iot->second.dt0 << endl;
680  // }
681 
682  //*********************************************************************
683  // FILE LOOP
684  for (int ifiles = 0; ifiles < nfiles; ifiles++)
685  {
686  //*********************************************************************
687 
688  bool isntuple = false;
689  char filetype[5];
690  ifstream myFile(argv[ifiles + 2], ios::in | ios::binary);
691  if (myFile.is_open())
692  {
693  myFile.read((char *)filetype, 4);
694  filetype[4] = 0;
695  if (strcmp(filetype, "root") == 0)
696  isntuple = true;
697  // if (strcmp(filetype,"bina")==0) return 3;
698  myFile.close();
699  }
700  else
701  {
702  std::cerr << "WRONG INPUT FILE!\n";
703  return -1;
704  }
705 
706  //*********************************************************************
707  // SCANNING ROOT FILE
708  if (isntuple)
709  {
710  //*********************************************************************
711 
712  nhistsadd = 0;
713 
714  TFile *ntfile = new TFile(argv[ifiles + 2]);
715  TNtuple *hittuple = (TNtuple *)ntfile->Get("ntuple");
716 
717  hittuple->SetBranchAddress("run", &run);
718  hittuple->SetBranchAddress("evt", &evt);
719  hittuple->SetBranchAddress("trk", &trk);
720  hittuple->SetBranchAddress("det", &det);
721  hittuple->SetBranchAddress("lay", &lay);
722  hittuple->SetBranchAddress("mod", &mod);
723  hittuple->SetBranchAddress("brd", &brd);
724  hittuple->SetBranchAddress("chp", &chp);
725  hittuple->SetBranchAddress("sid", &fsid);
726  hittuple->SetBranchAddress("stl", &stl);
727  hittuple->SetBranchAddress("stw", &stw);
728  hittuple->SetBranchAddress("r", &r);
729  hittuple->SetBranchAddress("dr", &dr);
730  hittuple->SetBranchAddress("dr", &dr);
731  hittuple->SetBranchAddress("t", &t);
732  hittuple->SetBranchAddress("t0", &t0);
733  // hittuple->SetBranchAddress("rtrack",&rtrack);
734  // hittuple->SetBranchAddress("ttrack",&ttrack);
735  hittuple->SetBranchAddress("rtrackunbias", &rtrack);
736  hittuple->SetBranchAddress("drrtrackunbias", &drtrack);
737  hittuple->SetBranchAddress("ttrackunbias", &ttrack);
738  hittuple->SetBranchAddress("ephase", &ephase);
739 
740  if (hittuple->GetListOfBranches()->FindObject("theta"))
741  {
742  hittuple->SetBranchAddress("theta", &theta);
743  }
744  if (hittuple->GetListOfBranches()->FindObject("phi"))
745  {
746  hittuple->SetBranchAddress("phi", &phi);
747  }
748  if (hittuple->GetListOfBranches()->FindObject("d0"))
749  {
750  hittuple->SetBranchAddress("d0", &d0);
751  }
752  if (hittuple->GetListOfBranches()->FindObject("pt"))
753  {
754  hittuple->SetBranchAddress("pt", &pt);
755  }
756  if (hittuple->GetListOfBranches()->FindObject("ToT"))
757  {
758  hittuple->SetBranchAddress("ToT", &ToT);
759  }
760  else
761  ToT = 0;
762  if (hittuple->GetListOfBranches()->FindObject("HT"))
763  {
764  hittuple->SetBranchAddress("HT", &HT);
765  }
766  else
767  HT = 0;
768  if (hittuple->GetListOfBranches()->FindObject("qoverp"))
769  {
770  hittuple->SetBranchAddress("qoverp", &qoverp);
771  }
772  else
773  qoverp = 0;
774 
775  if (hittuple->GetListOfBranches()->FindObject("isArgonStraw"))
776  {
777  hittuple->SetBranchAddress("isArgonStraw", &isArgonStraw);
778  }
779  else
780  isArgonStraw = 0;
781 
782  int nevents;
783  int npt0 = 0;
784  float diffpt0 = 0;
785  nevents = hittuple->GetEntries();
786 
787  cout << "SCANNING ROOT FILE " << argv[ifiles + 2] << " (" << nevents << " HITS)" << endl;
788 
789  //*********************************************************************
790  // EVENT LOOP
791  for (int ievt = 0; ievt < nevents; ievt++)
792  {
793  // for (int ievt=25000000;ievt<nevents;ievt++){
794  // for (int ievt=0;ievt<2000100;ievt++){
795  // for (int ievt=0;ievt<1000;ievt++){
796  //*********************************************************************
797 
798  hittuple->GetEntry(ievt);
799 
800  if (dr < 1.0)
801  { // event selection
802  // if (true){ //event selection
803 
804  nhits++;
805 
806  string trkkey = string(Form("_%i_%i_%i", (int)run, (int)evt, (int)trk));
807 
808  string pt0key = string(Form("_%i_%i_%i_%i_%i", (int)det, (int)lay, (int)mod, (int)stl, (int)stw));
809  if (pt0map.find(pt0key) != pt0map.end())
810  {
811  diffpt0 += fabs(t0 - pt0map[string(Form("_%i_%i_%i_%i_%i", (int)det, (int)lay, (int)mod, (int)stl, (int)stw))].t0);
812  t0 = pt0map[string(Form("_%i_%i_%i_%i_%i", (int)det, (int)lay, (int)mod, (int)stl, (int)stw))].t0;
813  npt0++;
814  // cout << string(Form("_%i_%i_%i_%i_%i",(int)det,(int)lay,(int)mod,(int)stl,(int)stw)) << " " << t0 << " -> " << pt0map[string(Form("_%i_%i_%i_%i_%i",(int)det,(int)lay,(int)mod,(int)stl,(int)stw))].t0 << endl;
815  }
816 
817  if (trackmap.find(trkkey) == trackmap.end())
818  {
819  trackmap[trkkey].run = run;
820  trackmap[trkkey].event = evt;
821  trackmap[trkkey].track = trk;
822  trackmap[trkkey].epnew = (t + ephase) - t0 - ttrack;
823  trackmap[trkkey].epold = ephase;
824  trackmap[trkkey].nhits = 1.0;
825  trackmap[trkkey].t = t;
826  trackmap[trkkey].ttrack = ttrack;
827  trackmap[trkkey].t0 = t0;
828  trackmap[trkkey].theta = theta;
829  trackmap[trkkey].phi = phi;
830  trackmap[trkkey].d0 = d0;
831  trackmap[trkkey].pt = pt;
832  trackmap[trkkey].trackres = (r - rtrack) * (r - rtrack);
833  trackmap[trkkey].trackresMean = (r - rtrack);
834  }
835  else
836  {
837  trackmap[trkkey].epnew += (t + ephase) - t0 - ttrack;
838  trackmap[trkkey].t += t;
839  trackmap[trkkey].ttrack += ttrack;
840  trackmap[trkkey].t0 += t0;
841  trackmap[trkkey].nhits++;
842  trackmap[trkkey].trackres += (r - rtrack) * (r - rtrack);
843  trackmap[trkkey].trackresMean += (r - rtrack);
844  }
845  sid = (int)fsid;
846 
847  short tresbin = Simple1dHist(mintres, maxtres, ntresbins, t - ttrack - t0 + ephase);
848  short rresbin = Simple1dHist(minres, maxres, nresbins, r - rtrack);
849  short trbin = Simple2dHist(mint, maxt, ntbins, minr, maxr, nrbins, t - t0 + ephase, fabs(rtrack));
850 
851  if ((int)det == -2 && (int)lay == 0 && (int)mod == 0 && (int)brd == 1)
852  residual_ref->Fill(r - rtrack);
853  if ((int)det == 1 && (int)lay == 0 && (int)mod == 0 && (int)brd == 0 && (int)chp == 1)
854  timeresidual_ref->Fill(t - ttrack - t0 + ephase);
855  if ((int)det == -1 && (int)lay == 2)
856  rt_ref->Fill(t - t0 + ephase, fabs(rtrack));
857  if ((int)det == -1)
858  rt_ref2->Fill(t - t0 + ephase, fabs(rtrack));
859 
860  if (histmap.find(sid) == histmap.end())
861  {
862  nhistsadd++;
863  nhists++;
864  histmap[sid] = new CalHist();
865  }
866  if (tresbin >= 0)
867  {
868  nbinsadd += histmap[sid]->IncreaseBin(tresbin, 1);
869  ntres++;
870  }
871  if (rresbin >= 0)
872  {
873  nbinsadd += histmap[sid]->IncreaseBin(rresbin + 100, 1);
874  nres++;
875  }
876  if (trbin >= 0)
877  {
878  nbinsadd += histmap[sid]->IncreaseBin(trbin + 200, 1);
879  nrt++;
880  }
881 
882  if (histmap[sid]->maxvalue > maxvalue)
883  maxvalue = histmap[sid]->maxvalue;
884 
885  if ((nhits % 1000000 == 0) | (ievt == nevents - 1))
886  {
887  process_mem_usage(vm, rss);
888  // cppcheck-suppress invalidPrintfArgType_uint
889  printf("%8i HITS READ, %8i HISTOGRAMS (%8lu ADDED), %8i BINS ADDED, MAXVALUE: %3i, VM: %8.0f, RSS: %8.0f\n", nhits, nhists, histmap.size() - nhiststmp, nbinsadd, maxvalue, vm, rss);
890  nhiststmp = histmap.size();
891  // nhistsadd=0;
892  nbinsadd = 0;
893  }
894 
895  if (nhits % 20000000 == 0)
896  {
897  dump_hists(&histmap, ntbins, nrbins, ntres, argv[1], 0);
898  for (map<int, CalHist *>::iterator it = histmap.begin(); it != histmap.end(); ++it)
899  {
900  delete it->second;
901  }
902  histmap.clear();
903  dump_tracktuple(&trackmap);
904  trackmap.clear();
905  nhiststmp = 0;
906  maxvalue = 0;
907  }
908 
909  if (isArgonStraw == 0)
910  { // ONLY STORE THE XENON CIRCLES:
911  reshist_trt->Fill(t - t0, fabs(r) - fabs(rtrack));
912  if ((int)det == -2)
913  reshist1->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
914  if ((int)det == -1)
915  reshist2->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
916  if ((int)det == 1)
917  reshist3->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
918  if ((int)det == 2)
919  reshist4->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
920  if (abs((int)det) == 1)
921  reshist_bar->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
922 
923  treshist_trt->Fill(t - t0 - ttrack, fabs(rtrack));
924  if ((int)det == -2)
925  treshist1->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
926  if ((int)det == -1)
927  treshist2->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
928  if ((int)det == 1)
929  treshist3->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
930  if ((int)det == 2)
931  treshist4->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
932  if (abs((int)det) == 1)
933  treshist_bar->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
934 
935  float residual = r - rtrack;
936  // float timebin = int((t-t0 + ephase)/3.125 );
937  float time = t - t0 + ephase;
938  float pull = (r - rtrack) / TMath::Sqrt(dr * dr + drtrack * drtrack);
939  float tresidual = t - t0 - ttrack + ephase;
940 
941  ToT = ToT / 3.125;
942 
943  float sinoverp = 0.0;
944  float cosoverp = 0.0;
945  if (pt != 0.0)
946  {
947  sinoverp = 1000. * sin(theta) * sin(theta) / pt;
948  cosoverp = 1000. * cos(theta) * cos(theta) / pt;
949  }
950 
951  float ppt = pt / 1000.;
952  if (ppt > 16)
953  ppt = 15.5;
954 
955  tres_vs_ToT_trt->Fill(ToT, tresidual);
956  res_vs_ToT_trt->Fill(ToT, residual);
957  tres_vs_HT_trt->Fill(HT, tresidual);
958  res_vs_HT_trt->Fill(HT, residual);
959  tres_vs_SinOverP_trt->Fill(sinoverp, tresidual);
960  res_vs_SinOverP_trt->Fill(sinoverp, residual);
961  tres_vs_CosOverP_trt->Fill(cosoverp, tresidual);
962  res_vs_CosOverP_trt->Fill(cosoverp, residual);
963 
964  pull_trtP->Fill(ppt, pull);
965  residual_trtP->Fill(ppt, residual);
966  tresidual_trtP->Fill(ppt, tresidual);
967  trackerrors_trtP->Fill(ppt, drtrack);
968  if (ppt > ptcutforerrors)
969  pull_vs_tb_trt->Fill(time, pull);
970  if (ppt > ptcutforerrors)
971  errors_vs_tb_trt->Fill(time, dr);
972  if (ppt > ptcutforerrors)
973  trackerrors_vs_tb_trt->Fill(time, drtrack);
974  if (ppt > ptcutforerrors)
975  residual_vs_tb_trt->Fill(time, residual);
976 
977  if ((int)det == -2)
978  {
979  tres_vs_ToT_ea->Fill(ToT, tresidual);
980  res_vs_ToT_ea->Fill(ToT, residual);
981  tres_vs_HT_ea->Fill(HT, tresidual);
982  res_vs_HT_ea->Fill(HT, residual);
983  tres_vs_SinOverP_ea->Fill(sinoverp, tresidual);
984  res_vs_SinOverP_ea->Fill(sinoverp, residual);
985  tres_vs_CosOverP_ea->Fill(cosoverp, tresidual);
986  res_vs_CosOverP_ea->Fill(cosoverp, residual);
987 
988  pull_eaP->Fill(ppt, pull);
989  residual_eaP->Fill(ppt, residual);
990  tresidual_eaP->Fill(ppt, tresidual);
991  trackerrors_eaP->Fill(ppt, drtrack);
992  if (ppt > ptcutforerrors)
993  pull_vs_tb_ea->Fill(time, pull);
994  if (ppt > ptcutforerrors)
995  errors_vs_tb_ea->Fill(time, dr);
996  if (ppt > ptcutforerrors)
997  trackerrors_vs_tb_ea->Fill(time, drtrack);
998  if (ppt > ptcutforerrors)
999  residual_vs_tb_ea->Fill(time, residual);
1000  }
1001  if ((int)det == 2)
1002  {
1003  tres_vs_ToT_ec->Fill(ToT, tresidual);
1004  res_vs_ToT_ec->Fill(ToT, residual);
1005  tres_vs_HT_ec->Fill(HT, tresidual);
1006  res_vs_HT_ec->Fill(HT, residual);
1007  tres_vs_SinOverP_ec->Fill(sinoverp, tresidual);
1008  res_vs_SinOverP_ec->Fill(sinoverp, residual);
1009  tres_vs_CosOverP_ec->Fill(cosoverp, tresidual);
1010  res_vs_CosOverP_ec->Fill(cosoverp, residual);
1011 
1012  pull_ecP->Fill(ppt, pull);
1013  residual_ecP->Fill(ppt, residual);
1014  tresidual_ecP->Fill(ppt, tresidual);
1015  trackerrors_ecP->Fill(ppt, drtrack);
1016  if (ppt > ptcutforerrors)
1017  pull_vs_tb_ec->Fill(time, pull);
1018  if (ppt > ptcutforerrors)
1019  errors_vs_tb_ec->Fill(time, dr);
1020  if (ppt > ptcutforerrors)
1021  trackerrors_vs_tb_ec->Fill(time, drtrack);
1022  if (ppt > ptcutforerrors)
1023  residual_vs_tb_ec->Fill(time, residual);
1024  }
1025  if ((int)det == -1)
1026  {
1027  tres_vs_ToT_ba->Fill(ToT, tresidual);
1028  res_vs_ToT_ba->Fill(ToT, residual);
1029  tres_vs_HT_ba->Fill(HT, tresidual);
1030  res_vs_HT_ba->Fill(HT, residual);
1031  tres_vs_SinOverP_ba->Fill(sinoverp, tresidual);
1032  res_vs_SinOverP_ba->Fill(sinoverp, residual);
1033  tres_vs_CosOverP_ba->Fill(cosoverp, tresidual);
1034  res_vs_CosOverP_ba->Fill(cosoverp, residual);
1035 
1036  pull_baP->Fill(ppt, pull);
1037  residual_baP->Fill(ppt, residual);
1038  tresidual_baP->Fill(ppt, tresidual);
1039  trackerrors_baP->Fill(ppt, drtrack);
1040  if (ppt > ptcutforerrors)
1041  pull_vs_tb_ba->Fill(time, pull);
1042  if (ppt > ptcutforerrors)
1043  errors_vs_tb_ba->Fill(time, dr);
1044  if (ppt > ptcutforerrors)
1045  trackerrors_vs_tb_ba->Fill(time, drtrack);
1046  if (ppt > ptcutforerrors)
1047  residual_vs_tb_ba->Fill(time, residual);
1048  }
1049  if ((int)det == 1)
1050  {
1051  tres_vs_ToT_bc->Fill(ToT, tresidual);
1052  res_vs_ToT_bc->Fill(ToT, residual);
1053  tres_vs_HT_bc->Fill(HT, tresidual);
1054  res_vs_HT_bc->Fill(HT, residual);
1055  tres_vs_SinOverP_bc->Fill(sinoverp, tresidual);
1056  res_vs_SinOverP_bc->Fill(sinoverp, residual);
1057  tres_vs_CosOverP_bc->Fill(cosoverp, tresidual);
1058  res_vs_CosOverP_bc->Fill(cosoverp, residual);
1059 
1060  pull_bcP->Fill(ppt, pull);
1061  residual_bcP->Fill(ppt, residual);
1062  tresidual_bcP->Fill(ppt, tresidual);
1063  trackerrors_bcP->Fill(ppt, drtrack);
1064  if (ppt > ptcutforerrors)
1065  pull_vs_tb_bc->Fill(time, pull);
1066  if (ppt > ptcutforerrors)
1067  errors_vs_tb_bc->Fill(time, dr);
1068  if (ppt > ptcutforerrors)
1069  trackerrors_vs_tb_bc->Fill(time, drtrack);
1070  if (ppt > ptcutforerrors)
1071  residual_vs_tb_bc->Fill(time, residual);
1072  }
1073  }
1074  else
1075  { // DUMP THE ARGON PART:
1076 
1077  existAr = true;
1078 
1079  resArhist_trt->Fill(t - t0, fabs(r) - fabs(rtrack));
1080  if ((int)det == -2)
1081  resArhist1->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
1082  if ((int)det == -1)
1083  resArhist2->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
1084  if ((int)det == 1)
1085  resArhist3->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
1086  if ((int)det == 2)
1087  resArhist4->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
1088  if (abs((int)det) == 1)
1089  resArhist_bar->Fill(t - t0 + ephase, fabs(r) - fabs(rtrack));
1090 
1091  tresArhist_trt->Fill(t - t0 - ttrack, fabs(rtrack));
1092  if ((int)det == -2)
1093  tresArhist1->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
1094  if ((int)det == -1)
1095  tresArhist2->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
1096  if ((int)det == 1)
1097  tresArhist3->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
1098  if ((int)det == 2)
1099  tresArhist4->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
1100  if (abs((int)det) == 1)
1101  tresArhist_bar->Fill(t - t0 - ttrack + ephase, fabs(rtrack));
1102 
1103  float residual = r - rtrack;
1104  // float timebin = int((t-t0 + ephase)/3.125 );
1105  float time = t - t0 + ephase;
1106  float pull = (r - rtrack) / TMath::Sqrt(dr * dr + drtrack * drtrack);
1107  float tresidual = t - t0 - ttrack + ephase;
1108 
1109  ToT = ToT / 3.125;
1110  float sinoverp = 0.0;
1111  float cosoverp = 0.0;
1112  if (pt != 0.0)
1113  {
1114  sinoverp = 1000. * sin(theta) * sin(theta) / pt;
1115  cosoverp = 1000. * cos(theta) * cos(theta) / pt;
1116  }
1117  float ppt = pt / 1000.;
1118  if (ppt > 16)
1119  ppt = 15.5;
1120 
1121  tresAr_vs_ToT_trt->Fill(ToT, tresidual);
1122  resAr_vs_ToT_trt->Fill(ToT, residual);
1123  tresAr_vs_HT_trt->Fill(HT, tresidual);
1124  resAr_vs_HT_trt->Fill(HT, residual);
1125  tresAr_vs_SinOverP_trt->Fill(sinoverp, tresidual);
1126  resAr_vs_SinOverP_trt->Fill(sinoverp, residual);
1127  tresAr_vs_CosOverP_trt->Fill(cosoverp, tresidual);
1128  resAr_vs_CosOverP_trt->Fill(cosoverp, residual);
1129 
1130  pullAr_trtP->Fill(ppt, pull);
1131  residualAr_trtP->Fill(ppt, residual);
1132  tresidualAr_trtP->Fill(ppt, tresidual);
1133  trackerrorsAr_trtP->Fill(ppt, drtrack);
1134  if (ppt > ptcutforerrors)
1135  pullAr_vs_tb_trt->Fill(time, pull);
1136  if (ppt > ptcutforerrors)
1137  errors_vs_tb_trt->Fill(time, dr);
1138  if (ppt > ptcutforerrors)
1139  trackerrors_vs_tb_trt->Fill(time, drtrack);
1140  if (ppt > ptcutforerrors)
1141  residualAr_vs_tb_trt->Fill(time, residual);
1142 
1143  if ((int)det == 2)
1144  {
1145  tresAr_vs_ToT_ea->Fill(ToT, tresidual);
1146  resAr_vs_ToT_ea->Fill(ToT, residual);
1147  tresAr_vs_HT_ea->Fill(HT, tresidual);
1148  resAr_vs_HT_ea->Fill(HT, residual);
1149  tresAr_vs_SinOverP_ea->Fill(sinoverp, tresidual);
1150  resAr_vs_SinOverP_ea->Fill(sinoverp, residual);
1151  tresAr_vs_CosOverP_ea->Fill(cosoverp, tresidual);
1152  resAr_vs_CosOverP_ea->Fill(cosoverp, residual);
1153 
1154  pullAr_eaP->Fill(ppt, pull);
1155  residualAr_eaP->Fill(ppt, residual);
1156  tresidualAr_eaP->Fill(ppt, tresidual);
1157  trackerrorsAr_eaP->Fill(ppt, drtrack);
1158  if (ppt > ptcutforerrors)
1159  pullAr_vs_tb_ea->Fill(time, pull);
1160  if (ppt > ptcutforerrors)
1161  errorsAr_vs_tb_ea->Fill(time, dr);
1162  if (ppt > ptcutforerrors)
1163  trackerrorsAr_vs_tb_ea->Fill(time, drtrack);
1164  if (ppt > ptcutforerrors)
1165  residualAr_vs_tb_ea->Fill(time, residual);
1166  }
1167  else if ((int)det == -2)
1168  {
1169  tresAr_vs_ToT_ec->Fill(ToT, tresidual);
1170  resAr_vs_ToT_ec->Fill(ToT, residual);
1171  tresAr_vs_HT_ec->Fill(HT, tresidual);
1172  resAr_vs_HT_ec->Fill(HT, residual);
1173  tresAr_vs_SinOverP_ec->Fill(sinoverp, tresidual);
1174  resAr_vs_SinOverP_ec->Fill(sinoverp, residual);
1175  tresAr_vs_CosOverP_ec->Fill(cosoverp, tresidual);
1176  resAr_vs_CosOverP_ec->Fill(cosoverp, residual);
1177 
1178  pullAr_ecP->Fill(ppt, pull);
1179  residualAr_ecP->Fill(ppt, residual);
1180  tresidualAr_ecP->Fill(ppt, tresidual);
1181  trackerrorsAr_ecP->Fill(ppt, drtrack);
1182  if (ppt > ptcutforerrors)
1183  pullAr_vs_tb_ec->Fill(time, pull);
1184  if (ppt > ptcutforerrors)
1185  errorsAr_vs_tb_ec->Fill(time, dr);
1186  if (ppt > ptcutforerrors)
1187  trackerrorsAr_vs_tb_ec->Fill(time, drtrack);
1188  if (ppt > ptcutforerrors)
1189  residualAr_vs_tb_ec->Fill(time, residual);
1190  }
1191  else if ((int)det == 1)
1192  {
1193  tresAr_vs_ToT_ba->Fill(ToT, tresidual);
1194  resAr_vs_ToT_ba->Fill(ToT, residual);
1195  tresAr_vs_HT_ba->Fill(HT, tresidual);
1196  resAr_vs_HT_ba->Fill(HT, residual);
1197  tresAr_vs_SinOverP_ba->Fill(sinoverp, tresidual);
1198  resAr_vs_SinOverP_ba->Fill(sinoverp, residual);
1199  tresAr_vs_CosOverP_ba->Fill(cosoverp, tresidual);
1200  resAr_vs_CosOverP_ba->Fill(cosoverp, residual);
1201 
1202  pullAr_baP->Fill(ppt, pull);
1203  residualAr_baP->Fill(ppt, residual);
1204  tresidualAr_baP->Fill(ppt, tresidual);
1205  trackerrorsAr_baP->Fill(ppt, drtrack);
1206  if (ppt > ptcutforerrors)
1207  pullAr_vs_tb_ba->Fill(time, pull);
1208  if (ppt > ptcutforerrors)
1209  errorsAr_vs_tb_ba->Fill(time, dr);
1210  if (ppt > ptcutforerrors)
1211  trackerrorsAr_vs_tb_ba->Fill(time, drtrack);
1212  if (ppt > ptcutforerrors)
1213  residualAr_vs_tb_ba->Fill(time, residual);
1214  }
1215  else if ((int)det == -1)
1216  {
1217  tresAr_vs_ToT_bc->Fill(ToT, tresidual);
1218  resAr_vs_ToT_bc->Fill(ToT, residual);
1219  tresAr_vs_HT_bc->Fill(HT, tresidual);
1220  resAr_vs_HT_bc->Fill(HT, residual);
1221  tresAr_vs_SinOverP_bc->Fill(sinoverp, tresidual);
1222  resAr_vs_SinOverP_bc->Fill(sinoverp, residual);
1223  tresAr_vs_CosOverP_bc->Fill(cosoverp, tresidual);
1224  resAr_vs_CosOverP_bc->Fill(cosoverp, residual);
1225 
1226  pullAr_bcP->Fill(ppt, pull);
1227  residualAr_bcP->Fill(ppt, residual);
1228  tresidualAr_bcP->Fill(ppt, tresidual);
1229  trackerrorsAr_bcP->Fill(ppt, drtrack);
1230  if (ppt > ptcutforerrors)
1231  pullAr_vs_tb_bc->Fill(time, pull);
1232  if (ppt > ptcutforerrors)
1233  errorsAr_vs_tb_bc->Fill(time, dr);
1234  if (ppt > ptcutforerrors)
1235  trackerrorsAr_vs_tb_bc->Fill(time, drtrack);
1236  if (ppt > ptcutforerrors)
1237  residualAr_vs_tb_bc->Fill(time, residual);
1238  }
1239  } // Close the argon part
1240 
1241  } // ... if event selection (dr<1) -> Precision hits:
1242 
1243  float ppt = pt / 1000.;
1244  if (ppt > 16)
1245  ppt = 15.5;
1246  float residual = r - rtrack;
1247  float tresidual = t - t0 - ttrack + ephase;
1248  float pull = (r - rtrack) / TMath::Sqrt(dr * dr + drtrack * drtrack);
1249 
1250  if (isArgonStraw == 0)
1251  { // ONLY STORE THE XENON CIRCLES:
1252  pull_trt->Fill(ppt, pull);
1253  residual_trt->Fill(ppt, residual);
1254  tresidual_trt->Fill(ppt, residual);
1255  if ((int)det == -2)
1256  {
1257  pull_ea->Fill(ppt, pull);
1258  tresidual_ea->Fill(ppt, tresidual);
1259  }
1260  if ((int)det == 2)
1261  {
1262  pull_ec->Fill(ppt, pull);
1263  residual_ec->Fill(ppt, residual);
1264  tresidual_ec->Fill(ppt, tresidual);
1265  }
1266  if ((int)det == -1)
1267  {
1268  pull_ba->Fill(ppt, pull);
1269  residual_ba->Fill(ppt, residual);
1270  tresidual_ba->Fill(ppt, tresidual);
1271  }
1272  if ((int)det == 1)
1273  {
1274  pull_bc->Fill(ppt, pull);
1275  residual_bc->Fill(ppt, residual);
1276  tresidual_bc->Fill(ppt, tresidual);
1277  }
1278  }
1279  else
1280  {
1281  pullAr_trt->Fill(ppt, pull);
1282  residualAr_trt->Fill(ppt, residual);
1283  tresidualAr_trt->Fill(ppt, residual);
1284  if ((int)det == 2)
1285  {
1286  pullAr_ea->Fill(ppt, pull);
1287  tresidualAr_ea->Fill(ppt, tresidual);
1288  }
1289  if ((int)det == -2)
1290  {
1291  pullAr_ec->Fill(ppt, pull);
1292  residualAr_ec->Fill(ppt, residual);
1293  tresidualAr_ec->Fill(ppt, tresidual);
1294  }
1295  if ((int)det == 1)
1296  {
1297  pullAr_ba->Fill(ppt, pull);
1298  residualAr_ba->Fill(ppt, residual);
1299  tresidualAr_ba->Fill(ppt, tresidual);
1300  }
1301  if ((int)det == -1)
1302  {
1303  pullAr_bc->Fill(ppt, pull);
1304  residualAr_bc->Fill(ppt, residual);
1305  tresidualAr_bc->Fill(ppt, tresidual);
1306  }
1307  } // save all AR hits
1308 
1309  } // END OF EVENT LOOP
1310  if (npt0 !=0){
1311  printf("REPLACED %d T0S WITH PRECISION VALUES (MEAN DIFF=%f)\n", npt0, diffpt0 / float(npt0));
1312  } else {
1313  printf("ERROR!! npt0 is zero!");
1314  }
1315 
1316  if (ifiles == nfiles - 1)
1317  {
1318  // Since we access here in the last loop iteration, better to use RECREATE than UPDATE
1319  TFile *ttfile = new TFile("tracktuple.root", "RECREATE");
1320 
1321  TDirectory *trtdir = ttfile->mkdir("TRT_all");
1322  TDirectory *binhist = trtdir->mkdir("reshists");
1323  TDirectory *detdir1 = trtdir->mkdir("Detector_-2");
1324  TDirectory *binhist1 = detdir1->mkdir("reshists1"); // NB! changed reshist to reshist1 for safety
1325  TDirectory *detdir2 = trtdir->mkdir("Detector_-1");
1326  TDirectory *binhist2 = detdir2->mkdir("reshists2");
1327  TDirectory *detdir3 = trtdir->mkdir("Detector_1");
1328  TDirectory *binhist3 = detdir3->mkdir("reshists3");
1329  TDirectory *detdir4 = trtdir->mkdir("Detector_2");
1330  TDirectory *binhist4 = detdir4->mkdir("reshists4");
1331  TDirectory *detdir5 = trtdir->mkdir("WholeBarrel_1");
1332  TDirectory *binhist5 = detdir5->mkdir("reshists5");
1333 
1334  TDirectory *errordir = ttfile->mkdir("Errors");
1335  TDirectory *corrdir = ttfile->mkdir("Correction");
1336 
1337  int npointsX = reshist1->GetNbinsX();
1338  int npointsY = treshist1->GetNbinsY();
1339  TH1D **hslizesX = new TH1D *[npointsX];
1340  TH1D **hslizesY = new TH1D *[npointsY];
1341 
1342  TVectorD tbins(npointsX);
1343  TVectorD rbins(npointsY);
1344 
1345  string chname;
1346  for (int i = 0; i < npointsX; i++)
1347  {
1348 
1349  tbins(i) = reshist1->GetXaxis()->GetBinCenter(i + 1);
1350 
1351  binhist->cd();
1352  chname = string(Form("res_tbin%i_trt", i));
1353  hslizesX[i] = reshist_trt->ProjectionY(chname.data(), i + 1, i + 1);
1354  binhist1->cd();
1355  chname = string(Form("res_tbin%i_-2", i));
1356  hslizesX[i] = reshist1->ProjectionY(chname.data(), i + 1, i + 1);
1357  binhist2->cd();
1358  chname = string(Form("res_tbin%i_-1", i));
1359  hslizesX[i] = reshist2->ProjectionY(chname.data(), i + 1, i + 1);
1360  binhist3->cd();
1361  chname = string(Form("res_tbin%i_1", i));
1362  hslizesX[i] = reshist3->ProjectionY(chname.data(), i + 1, i + 1);
1363  binhist4->cd();
1364  chname = string(Form("res_tbin%i_2", i));
1365  hslizesX[i] = reshist4->ProjectionY(chname.data(), i + 1, i + 1);
1366  binhist5->cd();
1367  chname = string(Form("res_tbin%i_bar", i));
1368  hslizesX[i] = reshist_bar->ProjectionY(chname.data(), i + 1, i + 1);
1369  }
1370 
1371  for (int i = 0; i < npointsY; i++)
1372  {
1373 
1374  rbins(i) = treshist1->GetYaxis()->GetBinCenter(i + 1);
1375 
1376  binhist->cd();
1377  chname = string(Form("tres_rbin%i_trt", i));
1378  hslizesY[i] = treshist_trt->ProjectionX(chname.data(), i + 1, i + 1);
1379  binhist1->cd();
1380  chname = string(Form("tres_rbin%i_-2", i));
1381  hslizesY[i] = treshist1->ProjectionX(chname.data(), i + 1, i + 1);
1382  binhist2->cd();
1383  chname = string(Form("tres_rbin%i_-1", i));
1384  hslizesY[i] = treshist1->ProjectionX(chname.data(), i + 1, i + 1);
1385  binhist3->cd();
1386  chname = string(Form("tres_rbin%i_1", i));
1387  hslizesY[i] = treshist3->ProjectionX(chname.data(), i + 1, i + 1);
1388  binhist4->cd();
1389  chname = string(Form("tres_rbin%i_2", i));
1390  hslizesY[i] = treshist4->ProjectionX(chname.data(), i + 1, i + 1);
1391  binhist5->cd();
1392  chname = string(Form("tres_rbin%i_bar", i));
1393  hslizesY[i] = treshist_bar->ProjectionX(chname.data(), i + 1, i + 1);
1394  }
1395 
1396  ttfile->cd();
1397  tbins.Write("tbins");
1398  rbins.Write("rbins");
1399 
1400  trtdir->cd();
1401  residual_ref->Write();
1402  timeresidual_ref->Write();
1403  rt_ref->Write();
1404  rt_ref2->Write();
1405 
1406  binhist->cd();
1407  reshist_trt->Write();
1408  binhist5->cd();
1409  reshist_bar->Write();
1410  binhist1->cd();
1411  reshist1->Write();
1412  binhist2->cd();
1413  reshist2->Write();
1414  binhist3->cd();
1415  reshist3->Write();
1416  binhist4->cd();
1417  reshist4->Write();
1418  binhist->cd();
1419  treshist_trt->Write();
1420  binhist5->cd();
1421  treshist_bar->Write();
1422  binhist1->cd();
1423  treshist1->Write();
1424  binhist2->cd();
1425  treshist2->Write();
1426  binhist3->cd();
1427  treshist3->Write();
1428  binhist4->cd();
1429  treshist4->Write();
1430 
1431  // Save stuff for errors:
1432  errordir->cd();
1433 
1434  pull_trt->Write();
1435  pull_ba->Write();
1436  pull_bc->Write();
1437  pull_ea->Write();
1438  pull_ec->Write();
1439 
1440  residual_trt->Write();
1441  residual_ba->Write();
1442  residual_bc->Write();
1443  residual_ea->Write();
1444  residual_ec->Write();
1445 
1446  tresidual_trt->Write();
1447  tresidual_ba->Write();
1448  tresidual_bc->Write();
1449  tresidual_ea->Write();
1450  tresidual_ec->Write();
1451 
1452  pull_trtP->Write();
1453  pull_baP->Write();
1454  pull_bcP->Write();
1455  pull_eaP->Write();
1456  pull_ecP->Write();
1457 
1458  residual_trtP->Write();
1459  residual_baP->Write();
1460  residual_bcP->Write();
1461  residual_eaP->Write();
1462  residual_ecP->Write();
1463 
1464  tresidual_trtP->Write();
1465  tresidual_baP->Write();
1466  tresidual_bcP->Write();
1467  tresidual_eaP->Write();
1468  tresidual_ecP->Write();
1469 
1470  pull_vs_tb_trt->Write();
1471  pull_vs_tb_trt->Write();
1472  pull_vs_tb_ba->Write();
1473  pull_vs_tb_bc->Write();
1474  pull_vs_tb_ea->Write();
1475  pull_vs_tb_ec->Write();
1476 
1477  errors_vs_tb_trt->Write();
1478  errors_vs_tb_ba->Write();
1479  errors_vs_tb_bc->Write();
1480  errors_vs_tb_ea->Write();
1481  errors_vs_tb_ec->Write();
1482 
1483  residual_vs_tb_trt->Write();
1484  residual_vs_tb_ba->Write();
1485  residual_vs_tb_bc->Write();
1486  residual_vs_tb_ea->Write();
1487  residual_vs_tb_ec->Write();
1488 
1489  trackerrors_trtP->Write();
1490  trackerrors_baP->Write();
1491  trackerrors_bcP->Write();
1492  trackerrors_eaP->Write();
1493  trackerrors_ecP->Write();
1494 
1495  trackerrors_vs_tb_trt->Write();
1496  trackerrors_vs_tb_ba->Write();
1497  trackerrors_vs_tb_bc->Write();
1498  trackerrors_vs_tb_ea->Write();
1499  trackerrors_vs_tb_ec->Write();
1500 
1501  // Save HT correction and ToT
1502  corrdir->cd();
1503 
1504  tres_vs_ToT_trt->Write();
1505  tres_vs_ToT_ba->Write();
1506  tres_vs_ToT_bc->Write();
1507  tres_vs_ToT_ea->Write();
1508  tres_vs_ToT_ec->Write();
1509 
1510  res_vs_ToT_trt->Write();
1511  res_vs_ToT_ba->Write();
1512  res_vs_ToT_bc->Write();
1513  res_vs_ToT_ea->Write();
1514  res_vs_ToT_ec->Write();
1515 
1516  tres_vs_HT_trt->Write();
1517  tres_vs_HT_ba->Write();
1518  tres_vs_HT_bc->Write();
1519  tres_vs_HT_ea->Write();
1520  tres_vs_HT_ec->Write();
1521 
1522  res_vs_HT_trt->Write();
1523  res_vs_HT_ba->Write();
1524  res_vs_HT_bc->Write();
1525  res_vs_HT_ea->Write();
1526  res_vs_HT_ec->Write();
1527 
1528  tres_vs_SinOverP_trt->Write();
1529  tres_vs_SinOverP_ba->Write();
1530  tres_vs_SinOverP_bc->Write();
1531  tres_vs_SinOverP_ea->Write();
1532  tres_vs_SinOverP_ec->Write();
1533 
1534  res_vs_SinOverP_trt->Write();
1535  res_vs_SinOverP_ba->Write();
1536  res_vs_SinOverP_bc->Write();
1537  res_vs_SinOverP_ea->Write();
1538  res_vs_SinOverP_ec->Write();
1539 
1540  tres_vs_CosOverP_trt->Write();
1541  tres_vs_CosOverP_ba->Write();
1542  tres_vs_CosOverP_bc->Write();
1543  tres_vs_CosOverP_ea->Write();
1544  tres_vs_CosOverP_ec->Write();
1545 
1546  res_vs_CosOverP_trt->Write();
1547  res_vs_CosOverP_ba->Write();
1548  res_vs_CosOverP_bc->Write();
1549  res_vs_CosOverP_ea->Write();
1550  res_vs_CosOverP_ec->Write();
1551 
1552  // Save the ARGON Part:
1553 
1554  if (existAr)
1555  {
1556  TDirectory *trtArdir = ttfile->mkdir("TRT_Ar_all");
1557  TDirectory *binArhist = trtArdir->mkdir("reshists_Ar"); // NB! changed directory names from reshists
1558  TDirectory *detArdir1 = trtArdir->mkdir("Detector_Ar_-2");
1559  TDirectory *binArhist1 = detArdir1->mkdir("reshists_Ar1");
1560  TDirectory *detArdir2 = trtArdir->mkdir("Detector_Ar_-1");
1561  TDirectory *binArhist2 = detArdir2->mkdir("reshists_Ar2");
1562  TDirectory *detArdir3 = trtArdir->mkdir("Detector_Ar_1");
1563  TDirectory *binArhist3 = detArdir3->mkdir("reshists_Ar3");
1564  TDirectory *detArdir4 = trtArdir->mkdir("Detector_Ar_2");
1565  TDirectory *binArhist4 = detArdir4->mkdir("reshists_Ar4");
1566  TDirectory *detArdir5 = trtArdir->mkdir("WholeBarrel_Ar_1");
1567  TDirectory *binArhist5 = detArdir5->mkdir("reshists_Ar5");
1568 
1569  TDirectory *errordirAr = ttfile->mkdir("ErrorsAr");
1570  TDirectory *corrdirAr = ttfile->mkdir("CorrectionAr");
1571  trtArdir->cd();
1572 
1573  binArhist->cd();
1574  resArhist_trt->Write();
1575  binArhist5->cd();
1576  resArhist_bar->Write();
1577  binArhist1->cd();
1578  resArhist1->Write();
1579  binArhist2->cd();
1580  resArhist2->Write();
1581  binArhist3->cd();
1582  resArhist3->Write();
1583  binArhist4->cd();
1584  resArhist4->Write();
1585  binArhist->cd();
1586  tresArhist_trt->Write();
1587  binArhist5->cd();
1588  tresArhist_bar->Write();
1589  binArhist1->cd();
1590  tresArhist1->Write();
1591  binArhist2->cd();
1592  tresArhist2->Write();
1593  binArhist3->cd();
1594  tresArhist3->Write();
1595  binArhist4->cd();
1596  tresArhist4->Write();
1597 
1598  TH1D **hslizesArX = new TH1D *[npointsX];
1599  TH1D **hslizesArY = new TH1D *[npointsY];
1600  TVectorD tbinsAr(npointsX);
1601  TVectorD rbinsAr(npointsY);
1602  for (int i = 0; i < npointsX; i++)
1603  {
1604  tbinsAr(i) = resArhist1->GetXaxis()->GetBinCenter(i + 1);
1605  binArhist->cd();
1606  chname = string(Form("res_tbin%i_trt", i));
1607  hslizesArX[i] = resArhist_trt->ProjectionY(chname.data(), i + 1, i + 1);
1608  binArhist1->cd();
1609  chname = string(Form("res_tbin%i_-2", i));
1610  hslizesArX[i] = resArhist1->ProjectionY(chname.data(), i + 1, i + 1);
1611  binArhist2->cd();
1612  chname = string(Form("res_tbin%i_-1", i));
1613  hslizesArX[i] = resArhist2->ProjectionY(chname.data(), i + 1, i + 1);
1614  binArhist3->cd();
1615  chname = string(Form("res_tbin%i_1", i));
1616  hslizesArX[i] = resArhist3->ProjectionY(chname.data(), i + 1, i + 1);
1617  binArhist4->cd();
1618  chname = string(Form("res_tbin%i_2", i));
1619  hslizesArX[i] = resArhist4->ProjectionY(chname.data(), i + 1, i + 1);
1620  binArhist5->cd();
1621  chname = string(Form("res_tbin%i_bar", i));
1622  hslizesArX[i] = resArhist_bar->ProjectionY(chname.data(), i + 1, i + 1);
1623  }
1624 
1625  for (int i = 0; i < npointsY; i++)
1626  {
1627  rbinsAr(i) = tresArhist1->GetYaxis()->GetBinCenter(i + 1);
1628  binArhist->cd();
1629  chname = string(Form("tres_rbin%i_trt", i));
1630  hslizesArY[i] = tresArhist_trt->ProjectionX(chname.data(), i + 1, i + 1);
1631  binArhist1->cd();
1632  chname = string(Form("tres_rbin%i_-2", i));
1633  hslizesArY[i] = tresArhist1->ProjectionX(chname.data(), i + 1, i + 1);
1634  binArhist2->cd();
1635  chname = string(Form("tres_rbin%i_-1", i));
1636  hslizesArY[i] = tresArhist1->ProjectionX(chname.data(), i + 1, i + 1);
1637  binArhist3->cd();
1638  chname = string(Form("tres_rbin%i_1", i));
1639  hslizesArY[i] = tresArhist3->ProjectionX(chname.data(), i + 1, i + 1);
1640  binArhist4->cd();
1641  chname = string(Form("tres_rbin%i_2", i));
1642  hslizesArY[i] = tresArhist4->ProjectionX(chname.data(), i + 1, i + 1);
1643  binArhist5->cd();
1644  chname = string(Form("tres_rbin%i_bar", i));
1645  hslizesArY[i] = tresArhist_bar->ProjectionX(chname.data(), i + 1, i + 1);
1646  }
1647 
1648  // Save stuff for errors:
1649  errordirAr->cd();
1650 
1651  pullAr_trt->Write();
1652  pullAr_ba->Write();
1653  pullAr_bc->Write();
1654  pullAr_ea->Write();
1655  pullAr_ec->Write();
1656 
1657  residualAr_trt->Write();
1658  residualAr_ba->Write();
1659  residualAr_bc->Write();
1660  residualAr_ea->Write();
1661  residualAr_ec->Write();
1662 
1663  tresidualAr_trt->Write();
1664  tresidualAr_ba->Write();
1665  tresidualAr_bc->Write();
1666  tresidualAr_ea->Write();
1667  tresidualAr_ec->Write();
1668 
1669  pullAr_trtP->Write();
1670  pullAr_baP->Write();
1671  pullAr_bcP->Write();
1672  pullAr_eaP->Write();
1673  pullAr_ecP->Write();
1674 
1675  residualAr_trtP->Write();
1676  residualAr_baP->Write();
1677  residualAr_bcP->Write();
1678  residualAr_eaP->Write();
1679  residualAr_ecP->Write();
1680 
1681  tresidualAr_trtP->Write();
1682  tresidualAr_baP->Write();
1683  tresidualAr_bcP->Write();
1684  tresidualAr_eaP->Write();
1685  tresidualAr_ecP->Write();
1686 
1687  pullAr_vs_tb_trt->Write();
1688  pullAr_vs_tb_trt->Write();
1689  pullAr_vs_tb_ba->Write();
1690  pullAr_vs_tb_bc->Write();
1691  pullAr_vs_tb_ea->Write();
1692  pullAr_vs_tb_ec->Write();
1693 
1694  errorsAr_vs_tb_trt->Write();
1695  errorsAr_vs_tb_ba->Write();
1696  errorsAr_vs_tb_bc->Write();
1697  errorsAr_vs_tb_ea->Write();
1698  errorsAr_vs_tb_ec->Write();
1699 
1700  residualAr_vs_tb_trt->Write();
1701  residualAr_vs_tb_ba->Write();
1702  residualAr_vs_tb_bc->Write();
1703  residualAr_vs_tb_ea->Write();
1704  residualAr_vs_tb_ec->Write();
1705 
1706  trackerrorsAr_trtP->Write();
1707  trackerrorsAr_baP->Write();
1708  trackerrorsAr_bcP->Write();
1709  trackerrorsAr_eaP->Write();
1710  trackerrorsAr_ecP->Write();
1711 
1712  trackerrorsAr_vs_tb_trt->Write();
1713  trackerrorsAr_vs_tb_ba->Write();
1714  trackerrorsAr_vs_tb_bc->Write();
1715  trackerrorsAr_vs_tb_ea->Write();
1716  trackerrorsAr_vs_tb_ec->Write();
1717 
1718  // Save HT correction and ToT
1719  corrdirAr->cd();
1720 
1721  tresAr_vs_ToT_trt->Write();
1722  tresAr_vs_ToT_ba->Write();
1723  tresAr_vs_ToT_bc->Write();
1724  tresAr_vs_ToT_ea->Write();
1725  tresAr_vs_ToT_ec->Write();
1726 
1727  resAr_vs_ToT_trt->Write();
1728  resAr_vs_ToT_ba->Write();
1729  resAr_vs_ToT_bc->Write();
1730  resAr_vs_ToT_ea->Write();
1731  resAr_vs_ToT_ec->Write();
1732 
1733  tresAr_vs_HT_trt->Write();
1734  tresAr_vs_HT_ba->Write();
1735  tresAr_vs_HT_bc->Write();
1736  tresAr_vs_HT_ea->Write();
1737  tresAr_vs_HT_ec->Write();
1738 
1739  resAr_vs_HT_trt->Write();
1740  resAr_vs_HT_ba->Write();
1741  resAr_vs_HT_bc->Write();
1742  resAr_vs_HT_ea->Write();
1743  resAr_vs_HT_ec->Write();
1744 
1745  tresAr_vs_SinOverP_trt->Write();
1746  tresAr_vs_SinOverP_ba->Write();
1747  tresAr_vs_SinOverP_bc->Write();
1748  tresAr_vs_SinOverP_ea->Write();
1749  tresAr_vs_SinOverP_ec->Write();
1750 
1751  resAr_vs_SinOverP_trt->Write();
1752  resAr_vs_SinOverP_ba->Write();
1753  resAr_vs_SinOverP_bc->Write();
1754  resAr_vs_SinOverP_ea->Write();
1755  resAr_vs_SinOverP_ec->Write();
1756 
1757  tresAr_vs_CosOverP_trt->Write();
1758  tresAr_vs_CosOverP_ba->Write();
1759  tresAr_vs_CosOverP_bc->Write();
1760  tresAr_vs_CosOverP_ea->Write();
1761  tresAr_vs_CosOverP_ec->Write();
1762 
1763  resAr_vs_CosOverP_trt->Write();
1764  resAr_vs_CosOverP_ba->Write();
1765  resAr_vs_CosOverP_bc->Write();
1766  resAr_vs_CosOverP_ea->Write();
1767  resAr_vs_CosOverP_ec->Write();
1768  } // Close argon part
1769 
1770  ttfile->Write();
1771  ttfile->Close();
1772  }
1773 
1774  //*********************************************************************
1775  // SCANNING BINARY FILE
1776  }
1777  else
1778  {
1779  //*********************************************************************
1780 
1781  cout << "SCANNING BINARY HISTOGRAM FILE " << argv[ifiles + 2] << endl;
1782 
1783  nhistsadd = 0;
1784  nhists = 0;
1785 
1786  ifstream *ifile = new ifstream(argv[ifiles + 2], ios::in | ios::binary);
1787 
1788  // histogram loop
1789  while (true)
1790  {
1791 
1792  // reading histogram
1793  ifile->read((char *)&npop, sizeof(int));
1794  if (ifile->eof())
1795  break;
1796  int *chist = new int[(2 * npop)];
1797  if (npop > 0)
1798  ifile->read((char *)chist, sizeof(int) * 2 * npop);
1799  ifile->read((char *)&sid, sizeof(int));
1800 
1801  if (histmap.find(sid) == histmap.end())
1802  { // create histogram if seen for the first time
1803  // cppcheck-suppress stlFindInsert
1804  histmap[sid] = new CalHist();
1805  nhistsadd++;
1806  }
1807 
1808  for (int ipop = 0; ipop < 2 * npop; ipop = ipop + 2)
1809  {
1810  histmap[sid]->IncreaseBin((short)chist[ipop], (unsigned short)chist[ipop + 1]); // increase the bins
1811  if (chist[ipop] < 100)
1812  {
1813  ntres += chist[ipop + 1];
1814  } // increase hit counters
1815  else if (chist[ipop] >= 100 && chist[ipop] < 200)
1816  nres += chist[ipop + 1];
1817  else
1818  nrt += chist[ipop + 1];
1819  }
1820 
1821  nhists++;
1822 
1823  if (nhists % 10000 == 0)
1824  {
1825  process_mem_usage(vm, rss);
1826  printf("%i HISTOGRAMS READ! %i HISTOGRAMS ADDED! %i BINS ADDED! MAXVALUE: %i VM: %0f RSS: %0f\n", nhists, nhistsadd, nbinsadd, maxvalue, vm, rss);
1827  }
1828 
1829  std::destroy_at(chist);
1830 
1831  if (nhists % 1000000000 == 0)
1832  {
1833  process_mem_usage(vm, rss);
1834  printf("%i HISTOGRAMS READ! %i HISTOGRAMS ADDED! %i BINS ADDED! MAXVALUE: %i VM: %0f RSS: %0f\n", nhists, nhistsadd, nbinsadd, maxvalue, vm, rss);
1835  dump_hists(&histmap, ntbins, nrbins, ntres, argv[1], 0);
1836  for (map<int, CalHist *>::iterator it = histmap.begin(); it != histmap.end(); ++it)
1837  {
1838  delete it->second;
1839  }
1840  histmap.clear();
1841  }
1842  }
1843 
1844  delete ifile;
1845 
1846  cout << nhists << " HISTOGRAMS SACNNED" << endl;
1847  cout << nhistsadd << " HISTOGRAMS ADDED" << endl;
1848 
1849  } // end of if (root or binary histograms)
1850  } // end of file loop
1851 
1852  cout << endl;
1853  cout << "TOT HISTOGRAMS............. " << nhists << endl;
1854  if (nhits!=0){
1855  cout << "TOT HITS IN TIMERES HIST .. " << ntres << " (" << 100 * float(ntres) / float(nhits) << "%)" << endl;
1856  cout << "TOT HITS IN RRES HIST ..... " << nres << " (" << 100 * float(nres) / float(nhits) << "%)" << endl;
1857  cout << "TOT HITS IN RT HIST ....... " << nrt << " (" << 100 * float(nrt) / float(nhits) << "%)" << endl;
1858  } else {
1859  cout << "Number of hits was zero !!\n";
1860  }
1861  cout << endl;
1862 
1863  ofilestat << "TRESHITS " << ntres << endl;
1864  ofilestat.close();
1865  dump_hists(&histmap, ntbins, nrbins, ntres, argv[1], 0);
1866  dump_tracktuple(&trackmap);
1867 
1868  return 0;
1869 }
dump_tracktuple
int dump_tracktuple(map< string, trackdata > *trackmap)
Definition: TRTCalib_bhadd.cxx:277
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
beamspotman.r
def r
Definition: beamspotman.py:676
extractSporadic.nhists
nhists
Definition: extractSporadic.py:111
CompBHist::npop
int npop
Definition: TRTCalib_bhadd.cxx:156
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
CalHist
Definition: TRTCalib_bhadd.cxx:76
checkFileSG.line
line
Definition: checkFileSG.py:75
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CompBHist::Write
void Write(ofstream *)
Definition: TRTCalib_bhadd.cxx:201
Simple1dHist
int Simple1dHist(float min, float max, int nbins, float value)
Definition: TRTCalib_bhadd.cxx:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
TRTCalib_Extractor.det
det
Definition: TRTCalib_Extractor.py:36
AthenaPoolTestRead.flags
flags
Definition: AthenaPoolTestRead.py:8
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
plotmaker.hist
hist
Definition: plotmaker.py:148
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
CalHist::IncreaseBin
int IncreaseBin(short, unsigned short)
Definition: TRTCalib_bhadd.cxx:98
CalibDbCompareT0.dt0
dt0
Definition: CalibDbCompareT0.py:76
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
CompBHist::CompBHist
CompBHist(const CompBHist &)=delete
validation.ofile
ofile
Definition: validation.py:96
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
skel.it
it
Definition: skel.GENtoEVGEN.py:396
test_pyathena.pt
pt
Definition: test_pyathena.py:11
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
bin
Definition: BinsDiffFromStripMedian.h:43
athena.value
value
Definition: athena.py:124
python.selector.AtlRunQuerySelectorLhcOlc.priority
priority
Definition: AtlRunQuerySelectorLhcOlc.py:611
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
stime
std::string stime()
return the current data and time
Definition: computils.cxx:214
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
CompBHist::GetStat
int GetStat(int)
Definition: TRTCalib_bhadd.cxx:206
calibpars::dt0
float dt0
Definition: TRTCalib_bhadd.cxx:238
Simple2dHist
int Simple2dHist(float minx, float maxx, int nbinsx, float miny, float maxy, int nbinsy, float valuex, float valuey)
Definition: TRTCalib_bhadd.cxx:32
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
main
int main(int argc, char *argv[])
Definition: TRTCalib_bhadd.cxx:319
trackdata
Definition: TRTCalib_bhadd.cxx:230
calibpars
Definition: TRTCalib_bhadd.cxx:236
process_mem_usage
void process_mem_usage(double &vm_usage, double &resident_set)
Definition: TRTCalib_bhadd.cxx:41
CompBHist
Definition: TRTCalib_bhadd.cxx:143
CalHist::maxvalue
int maxvalue
Definition: TRTCalib_bhadd.cxx:84
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
readoldpars
map< string, calibpars > readoldpars()
Definition: TRTCalib_bhadd.cxx:241
CompBHist::Print
int Print()
Definition: TRTCalib_bhadd.cxx:191
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArCellNtuple.argv
argv
Definition: LArCellNtuple.py:152
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
file
TFile * file
Definition: tile_monitor.h:29
dump_hists
int dump_hists(map< int, CalHist * > *histmap, int ntbins, int nrbins, int, char *fname, int fileno)
Definition: TRTCalib_bhadd.cxx:292
CompBHist::~CompBHist
~CompBHist()
Definition: TRTCalib_bhadd.cxx:186
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:282
calibpars::t0
float t0
Definition: TRTCalib_bhadd.cxx:237
run
Definition: run.py:1
DQHistogramMergeRegExp.argc
argc
Definition: DQHistogramMergeRegExp.py:20
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
beamspotman.stat
stat
Definition: beamspotman.py:266
lumiFormat.array
array
Definition: lumiFormat.py:91
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
CalHist::GetArray
void GetArray(std::vector< int > &, int)
Definition: TRTCalib_bhadd.cxx:125
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
ReadCalibFromCool.comm
comm
Definition: ReadCalibFromCool.py:440
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
CompBHist::CompBHist
CompBHist(int, const std::vector< int > &, int, int)
Definition: TRTCalib_bhadd.cxx:159
CalHist::m_hist
map< short, unsigned short > m_hist
Definition: TRTCalib_bhadd.cxx:88
dqm_persistency::Print
void Print(const PParameter *param, TDirectory *topdir, Option_t *opt="")
Definition: dqm_persistency_impl.cxx:161
LArG4GenerateShowerLib.nevents
nevents
Definition: LArG4GenerateShowerLib.py:19
CompBHist::operator=
CompBHist & operator=(const CompBHist &)=delete
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
LArCellNtuple.ifile
string ifile
Definition: LArCellNtuple.py:133
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
trackdata::ttrack
float ttrack
Definition: TRTCalib_bhadd.cxx:232
CalHist::~CalHist
~CalHist()
Definition: TRTCalib_bhadd.cxx:96
readCCLHist.float
float
Definition: readCCLHist.py:83
extractSporadic.myFile
myFile
Definition: extractSporadic.py:87
CalHist::CalHist
CalHist()
Definition: TRTCalib_bhadd.cxx:91
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Wed Jan 8 2025 21:20:45 for ATLAS Offline Software by   doxygen 1.8.18