FairRoot/PandaRoot
Functions
plotMomRes.C File Reference

Go to the source code of this file.

Functions

int MakeResolutionPlot (TProfile *histo)
 
int plotTrackCands ()
 
gROOT SetStyle ("Plain")
 
TCut nocut ("nt.nHitsForHoughSpaceLine>=0")
 
TCut minhitsforline ("nt.nHitsForHoughSpaceLine>1")
 
TCut minhitsforparabola ("nt.nHitsForHoughSpaceParabola>2")
 
TCut largerthetaxy ("nt.mc_theta_xz>0.")
 
TCut smallhitshift ("nt.hitshiftinx<20.")
 
nt Draw ("nt.mc_pz:nt.pzFromInvpz>>(100,0,5,300,0,15)", minhitsforline &&minhitsforparabola,"")
 

Function Documentation

nt Draw ( "nt.mc_pz:nt.pzFromInvpz>>(100,0,5,300,0,15)"  ,
minhitsforline &&  minhitsforparabola,
""   
)
TCut largerthetaxy ( "nt.  mc_theta_xz,
0."   
)
int MakeResolutionPlot ( TProfile *  histo)

Definition at line 6 of file plotMomRes.C.

References CAMath::Sqrt(), and TString.

7 {
8  // I wrote this to get the error bars from a TProfile plot with name histo and put it into a new plot,
9  // but this is not really what I need, maybe it is useful another time
10  gStyle->SetOptStat(0);
11  TString histotitle = "Relative resolution for ";
12  histotitle += histo->GetTitle();
13  TH1F *hCoordinateSystem = new TH1F(histotitle, histotitle, 10, 0.5, 5);
14  hCoordinateSystem->GetYaxis()->SetTitle("relative p_{z} resolution");
15  hCoordinateSystem->GetXaxis()->SetTitle("p_{z} from MC Truth [GeV/c]");
16 
17 
18  TGraphErrors *resolution = new TGraphErrors();
19  resolution->SetMarkerColor(2);
20  resolution->SetMarkerStyle(29);
21  resolution->SetMarkerSize(1.4);
22  resolution->SetLineColor(2);
23 
24 
25 
26  // produce resolution plots from TProfile histo
27  const Int_t nBins = histo->GetNbinsX();
28  // std::cout << "nBins = " << nBins << std::endl;
29  // vector<Double_t> mom;
30  // vector<Double_t> stdDev;
31 
32  for (Int_t iBin =1; iBin <= nBins; ++iBin)
33  {
34  // mom.push_back(histo->GetBinCenter(iBin));
35  // stdDev.push_back(histo->GetBinError(iBin)/histo->GetBinCenter(iBin));
36  resolution->SetPoint(iBin, histo->GetBinCenter(iBin), histo->GetBinError(iBin)/histo->GetBinCenter(iBin));
37  resolution->SetPointError(iBin, histo->GetBinWidth(iBin)/2.,histo->GetBinError(iBin)/TMath::Sqrt(histo->GetBinEntries(iBin)));
38 
39  }
40 
41  hCoordinateSystem->Draw();
42  resolution->Draw("L,SAME");
43  return 0;
44 
45 }
CAMath::Sqrt
static T Sqrt(const T &x)
Definition: PndCAMath.h:37
TCut minhitsforline ( "nt.  nHitsForHoughSpaceLine,
1"   
)
TCut minhitsforparabola ( "nt.  nHitsForHoughSpaceParabola,
2"   
)
TCut nocut ( "nt.nHitsForHoughSpaceLine>=0"  )
int plotTrackCands ( )

Definition at line 55 of file plotMomRes.C.

References cos(), Double_t, fabs(), high, inFile, low, nEvents, rootlogon(), sigma, tree, and TString.

56 {
57  gROOT->LoadMacro("$VMCWORKDIR/gconfig/rootlogon.C");
58  rootlogon();
59 
60 
61  gROOT->SetStyle("Plain");
62  gStyle->SetOptStat(10); // entries only
63  gStyle->SetOptFit(1);
64  // gStyle->SetOptStat(11); // name and entries
65  // gStyle->SetOptStat(1111110); // with integral
66 
67 
68  const Int_t nBins = 90; // 90 very detailed
69 
70 
71  // ******************************************************************
72  // Get the tree nt which was produced with mctrack.C before
73  TString inTreeFile = "out_test.root";
74  TFile *inFile = TFile::Open(inTreeFile,"READ");
75  TTree *tree=(TTree *) inFile->Get("nt") ;
76 
77 
78  Int_t nEvents = nt->GetEntriesFast();
79  // some counting variables
80  Int_t skipcount = 0, moreThanTwentyPercentCount = 0, goodEvents = 0;
81  Double_t totalDeviation = 0.;
82 
83 
84  // ******************************************************************
85  // just some histo titles
86  TString histotitle = "p_{z} for ";
87  histotitle += nEvents;
88  histotitle += " #mu^{-} with 0.5 GeV/c < p < 5 GeV/c ";
89  TString histotitleinvpz = histotitle + "(from 1/p_{z} HS)";
90  TString histotitleinvpzWithB = histotitle + "(from 1/p_{z} HS with mean B field)";
91  TString histotitlepz = histotitle + "(from p_{z} HS)";
92  TString histotitlepzWithB = histotitle + "(from p_{z} HS with mean B field)";
93 
94 
95 
96  // ******************************************************************
97  // histograms for pz (several methods can be compared)
98  TProfile *hpzFromInvpz = new TProfile("pzFrominvpz",histotitleinvpz, nBins, 0.5, 5, 0, 8, "s");
99  // TH2F *hpzFromInvpz = new TH2F("pzFrominvpz",histotitleinvpz, nBins, 0.5, 5, 80, 0, 8);
100  hpzFromInvpz->GetYaxis()->SetTitle("reconstructed p_{z} [GeV/c]");
101  hpzFromInvpz->GetXaxis()->SetTitle("p_{z} from MC Truth [GeV/c]");
102 
103  TProfile* hpzFromInvpzWithBfield = new TProfile("pzFrominvpzWithB", histotitleinvpzWithB, nBins, 0.5, 5, 0, 8, "s");
104  hpzFromInvpzWithBfield->GetYaxis()->SetTitle("reconstructed p_{z} [GeV/c]");
105  hpzFromInvpzWithBfield->GetXaxis()->SetTitle("p_{z} from MC Truth [GeV/c]");
106 
107  TProfile* hpzFrompz = new TProfile("pzFrompz", histotitlepz, nBins, 0.5, 5, 0, 8, "s");
108  hpzFrompz->GetYaxis()->SetTitle("reconstructed p_{z} [GeV/c]");
109  hpzFrompz->GetXaxis()->SetTitle("p_{z} from MC Truth [GeV/c]");
110 
111  TProfile* hpzFrompzWithBfield = new TProfile("pzFrompzWithB", histotitlepzWithB, nBins, 0.5, 5, 0, 8, "s");
112  hpzFrompzWithBfield->GetYaxis()->SetTitle("reconstructed p_{z} [GeV/c]");
113  hpzFrompzWithBfield->GetXaxis()->SetTitle("p_{z} from MC Truth [GeV/c]");
114 
115 
116  // ******************************************************************
117  // histogram to visualize what the line Hough transform resulted with
118  TH1F* hhitshiftinx = new TH1F("hitshiftinx", "hitshiftinx for single track #mu^{-} p = 3 GeV/c", 200, -50, 50);
119  hhitshiftinx->GetXaxis()->SetTitle("hitshiftinx [cm]");
120  hhitshiftinx->GetYaxis()->SetTitle("Counts");
121 
122 
123 
124 
125  // ******************************************************************
126 
127 
128  // TH1F *hresolution15invpz = new TH1F("Relative resolution for muons with 1.0 < p_{z} < 1.5 GeV/c", "Relative resolution for muons with 1.0 < p_{z} < 1.5 GeV/c", bins, -1.0, 1.0);
129  // hresolution15invpz->GetYaxis()->SetTitle("counts");
130  // hresolution15invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
131  //
132  // TH1F *hresolution2invpz = new TH1F("Relative resolution for muons with 1.5 < p_{z} < 2.0 GeV/c", "Relative resolution for muons with 1.5 < p_{z} < 2.0 GeV/c", bins, -1.0, 1.0);
133  // hresolution2invpz->GetYaxis()->SetTitle("counts");
134  // hresolution2invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
135  //
136  // TH1F *hresolution25invpz = new TH1F("Relative resolution for muons with 2.0 < p_{z} < 2.5 GeV/c", "Relative resolution for muons with 2.0 < p_{z} < 2.5 GeV/c", bins, -1.0, 1.0);
137  // hresolution25invpz->GetYaxis()->SetTitle("counts");
138  // hresolution25invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
139  //
140  // TH1F *hresolution3invpz = new TH1F("Relative resolution for muons with 2.5 < p_{z} < 3.0 GeV/c", "Relative resolution for muons with 2.5 < p_{z} < 3.0 GeV/c", bins, -1.0, 1.0);
141  // hresolution3invpz->GetYaxis()->SetTitle("counts");
142  // hresolution3invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
143  //
144  // TH1F *hresolution35invpz = new TH1F("Relative resolution for muons with 3.0 < p_{z} < 3.5 GeV/c", "Relative resolution for muons with 3.0 < p_{z} < 3.5 GeV/c", bins, -1.0, 1.0);
145  // hresolution35invpz->GetYaxis()->SetTitle("counts");
146  // hresolution35invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
147  //
148  // TH1F *hresolution4invpz = new TH1F("Relative resolution for muons with 3.5 < p_{z} < 4.0 GeV/c", "Relative resolution for muons with 3.5 < p_{z} < 4.0 GeV/c", bins, -1.0, 1.0);
149  // hresolution4invpz->GetYaxis()->SetTitle("counts");
150  // hresolution4invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
151  //
152  // TH1F *hresolution45invpz = new TH1F("Relative resolution for muons with 4.0 < p_{z} < 4.5 GeV/c", "Relative resolution for muons with 4.0 < p_{z} < 4.5 GeV/c", bins, -1.0, 1.0);
153  // hresolution45invpz->GetYaxis()->SetTitle("counts");
154  // hresolution45invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
155  //
156  // TH1F *hresolution5invpz = new TH1F("Relative resolution for muons with 4.5 < p_{z} < 5.0 GeV/c", "Relative resolution for muons with 4.5 < p_{z} < 5.0 GeV/c", bins, -1.0, 1.0);
157  // hresolution5invpz->GetYaxis()->SetTitle("counts");
158  // hresolution5invpz->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
159 
160 
161 
162 
163  // ******************************************************************
164  // Variables and their mapping in the tree
165  Float_t mc_px = 0., mc_py = 0., mc_pz = 0., mc_theta = 0., mc_theta_xz = 0., mc_phi = 0.;
166  Int_t mc_pid = 0;
167  Float_t nHitsForHoughSpaceLine = 0, nHitsForHoughSpaceParabola = 0;
168  Float_t pzFromInvpz = 0., pzFrompz = 0., pzFromInvpzWithBField = 0., pzFrompzWithBField = 0., hitshiftinx =0.;
169  Float_t thetaPeakLine = 0., thetaPeakParabolaFrominvpz = 0., thetaPeakParabolaFrompz = 0.;
170  Float_t mc_theta = 0., mc_theta_xz = 0.;
171 
172  nt->SetBranchAddress("mc_pz", &mc_pz);
173  nt->SetBranchAddress("mc_theta", &mc_theta);
174  nt->SetBranchAddress("mc_theta_xz", &mc_theta_xz);
175  nt->SetBranchAddress("pzFromInvpz", &pzFromInvpz);
176  nt->SetBranchAddress("pzFromInvpzWithBField", &pzFromInvpzWithBField);
177  nt->SetBranchAddress("pzFrompz", &pzFrompz);
178  nt->SetBranchAddress("pzFrompzWithBField", &pzFrompzWithBField);
179  nt->SetBranchAddress("hitshiftinx", &hitshiftinx);
180  nt->SetBranchAddress("nHitsForHoughSpaceLine",&nHitsForHoughSpaceLine);
181  nt->SetBranchAddress("nHitsForHoughSpaceParabola",&nHitsForHoughSpaceParabola);
182  nt->SetBranchAddress("thetaPeakLine", &thetaPeakLine);
183  nt->SetBranchAddress("thetaPeakParabolaFrompz", &thetaPeakParabolaFrompz);
184  nt->SetBranchAddress("thetaPeakParabolaFrominvpz", &thetaPeakParabolaFrominvpz);
185 
186 
187  const Int_t maxMomResPics = 90; // adjust this, 90 is correct for momSpacingForResPlot = 0.05
188  const Int_t picsPerCanvas = 12; // keep this the same
189  const Int_t maxCanvas = maxMomResPics/picsPerCanvas+1;
190  // for momentum resolution plot
191  Int_t ResolutionX = 800, ResolutionY = 600; // for plotting
192  TCanvas *cresinvpz[maxCanvas];
193  Double_t xVal[maxMomResPics];
194  Double_t yVal[maxMomResPics];
195  Double_t xErr[maxMomResPics];
196  Double_t yErr[maxMomResPics];
197 
198  // histograms for resolution studies
199  const Int_t bins = 200;
200  TH1F *hresolution1invpz[maxMomResPics];
201  TF1 *func1[maxMomResPics]; // used for fitting histogram above
202 
203 
204 
205 
206 
207  for (Int_t iMomRes=0; iMomRes<maxMomResPics; ++iMomRes)
208  {
209  const Double_t momSpacingForResPlot = 0.05;
210  Double_t low = 0.5+momSpacingForResPlot*iMomRes;
211  Double_t high = low + momSpacingForResPlot;
212  // reset histogram
213  hresolution1invpz[iMomRes] = new TH1F("Relative resolution for muons with low*iMomRes < p_{z} < high GeV/c", "Relative resolution for muons with low*iMomRes < p_{z} < high GeV/c", bins, -1.0, 1.0);
214  hresolution1invpz[iMomRes]->GetYaxis()->SetTitle("counts");
215  hresolution1invpz[iMomRes]->GetXaxis()->SetTitle("(reconstructed p_{z} - p_{z} from MC Truth)/ p_{z} from MC Truth");
216 
217  Int_t iCanvas = iMomRes/picsPerCanvas;
218  if (0==iMomRes%picsPerCanvas){
219  cresinvpz[iCanvas]=new TCanvas("cresinvpz"+iCanvas,"cresinvpz",ResolutionX,ResolutionY);
220  cresinvpz[iCanvas]->Divide(4,3);
221  }
222 
223  // ******************************************************************
224  // event loop starts here
225  for (Int_t iEvent=0; iEvent< nEvents; ++iEvent)
226  {
227  nt->GetEntry(iEvent);
228  if (0 == iEvent%1000) { cout << "processing event " << iEvent << "\n"; }
229 
230  if (2 >= nHitsForHoughSpaceLine) { continue; }
231  if (4 >= nHitsForHoughSpaceParabola) { continue; }
232 
233 
234 
235  // correct according to angle (try from line or from parabola)
236  pzFromInvpz = pzFromInvpz*cos(thetaPeakParabolaFrominvpz/180.*3.14159265);
237 
238  // The Following values apply to theta from parabola invpz no B field plot, angle "correction" with pzFromInvpz = pzFromInvpz*cos(thetaPeakParabolaFrominvpz/180.*3.14159265); // momentum resolution is improved, but not much
239  const Double_t p0invpz = -0.160255;
240  const Double_t p1invpz = 1.11037;
241  pzFromInvpz = (pzFromInvpz-p0invpz)/p1invpz;
242 
243 
244 
245 
246 
247 
248 
249 
250 
251 
252 
253 
254  if (maxMomResPics==iMomRes+1){
255  // make 2d plots
256  hpzFromInvpz->Fill(mc_pz,pzFromInvpz);
257  hpzFromInvpzWithBfield->Fill(mc_pz,pzFromInvpzWithBField);
258  hpzFrompz->Fill(mc_pz,pzFrompz);
259  hpzFrompzWithBfield->Fill(mc_pz,pzFrompzWithBField);
260  hhitshiftinx->Fill(hitshiftinx);
261  }
262 
263  // ******************************************************************
264  // calculate relative deviation for pz
265  Double_t relativeDeviation_pz = (pzFromInvpz-mc_pz)/mc_pz;
266 
267  if (maxMomResPics==iMomRes+1){
268  // count how many events deviate at least 20% (This number is not represented in the sigma from the Gauss fits)
269  if (0.2 <= relativeDeviation_pz)
270  {
271  ++moreThanTwentyPercentCount;
272  std::cout << "Event " << iEvent << " MC p_z = " << mc_pz << " FTS p_z = " << pzFromInvpz << " is off by " << relativeDeviation_pz*100 << " per cent." << std::endl;
273  }
274  totalDeviation += fabs(relativeDeviation_pz);
275  goodEvents += 1; // all events that pass the continue criteria are counted as good (this number is needed to calculate the average deviation after the event loop)
276  }
277 
278 
279 
280  // here comes the plotting stuff of the momentum resolution
281 
282 
283  if ((low < mc_pz) && (mc_pz <= high))
284  {
285 
286  // if ((20. > hitshiftinx)&&(10. < hitshiftinx)) {continue;} // try to figure out why I see a double Gaussian
287  hresolution1invpz[iMomRes]->Fill(relativeDeviation_pz);
288  }
289 
290  } // end of event loop
291  // ******************************************************************
292 
293 
294 
295 
296 
297 
298 
299  // ******************************************************************
300  // plotting begins here
301 
302 
303 
304  cresinvpz[iCanvas]->cd(iMomRes-iCanvas*picsPerCanvas+1);
305  func1[iMomRes] = new TF1("func1","gaus",-0.4,0.4);
306  TF1 *funcptr = func1[iMomRes];
307  int maxbin = hresolution1invpz[iMomRes]->GetMaximumBin();
308  funcptr->SetParameters(hresolution1invpz[iMomRes]->GetBinContent(maxbin), hresolution1invpz[iMomRes]->GetBinCenter(maxbin), 0.1);
309  // TF1 *func1[iMomRes] = new TF1("func1","gaus+gaus(3)",-0.4,0.4);
310  // func1[iMomRes]->SetParameters(hresolution1invpz[iMomRes]->GetBinContent(maxbin), hresolution1invpz[iMomRes]->GetBinCenter(maxbin), 0.05, hresolution1invpz[iMomRes]->GetMaximum(),0.,0.1);
311  // TFitResultPtr fitresult = hresolution1invpz[iMomRes]->Fit(func1[iMomRes],"RS","",-0.4,0.4);
312  hresolution1invpz[iMomRes]->Fit(funcptr,"R","",-0.4,0.4);
313  hresolution1invpz[iMomRes]->Draw("ep");
314 
315 
316  Double_t sigma = funcptr->GetParameter(2);
317  Double_t sigmaErr = funcptr->GetParError(2);
318 
319 
320  xVal[iMomRes]=(low+high)/2.0;
321  yVal[iMomRes]=sigma;
322  xErr[iMomRes]=momSpacingForResPlot/2.0;
323  yErr[iMomRes]=sigmaErr;
324 
325  cout << "sigma = " << sigma << endl;
326  cout << "sigmaerror = " << sigmaErr << endl;
327 
328 
329  cout << "End of momentum loop " << iMomRes << " with events from "<< low << " to " << high << " GeV/c"<< endl;
330 
331  } // end of loop for momentum resolution plot
332 
333 
334 
335 
336 
337  TCanvas *cMomRes = new TCanvas("c1","A Simple Graph with error bars",800,600);
338  cMomRes->SetGrid();
339  TGraphErrors *momResPlot = new TGraphErrors(maxMomResPics,xVal,yVal,xErr,yErr);
340  momResPlot->SetTitle("Momentum Resolution");
341  momResPlot->SetMarkerColor(4);
342  momResPlot->SetMarkerStyle(21);
343  momResPlot->Draw("AP");
344 // momResPlot->GetYaxis()->SetTitle("std. dev. of (p_{z,rec} - p_{z, MC})/ p_{z, MC}");
345  momResPlot->GetYaxis()->SetTitle("relative p_{z} resolution");
346  momResPlot->SetMinimum(0.0);
347  momResPlot->SetMaximum(0.09);
348  momResPlot->GetXaxis()->SetTitle("p_{z, MC} [GeV/c]");
349 
350 
351 
352 
353  Int_t ResolutionX = 400, ResolutionY = 1200; // for plotting
354 
355  TCanvas *cinvpz = new TCanvas("cpzMCvsHoughFromInvpz", "cpzMCvsHoughFromInvpz", ResolutionX, ResolutionY);
356  TF1 *p1fit = new TF1("P1","pol1",0.5,4.95);
357  hpzFromInvpz->Fit(p1fit,"RS");
358  hpzFromInvpz->Draw();
359 
360  //
361  // TCanvas *cinvpzWithBfield = new TCanvas("cpzMCvsHoughFromInvpzWithBfield", "cpzMCvsHoughFromInvpzWithBfield", ResolutionX, ResolutionY);
362  // hpzFromInvpzWithBfield->Fit(p1fit,"R");
363  // hpzFromInvpzWithBfield->Draw();
364  //
365  // TCanvas *cpz = new TCanvas("cpzMCvsHoughFrompz", "cpzMCvsHoughFrompz", ResolutionX, ResolutionY);
366  // hpzFrompz->Fit(p1fit,"R");
367  // hpzFrompz->Draw();
368  //
369  // TCanvas *cpzWithBfield = new TCanvas("cpzMCvsHoughFrompzWithBfield", "cpzMCvsHoughFrompzWithBfield", ResolutionX, ResolutionY);
370  // hpzFrompzWithBfield->Fit(p1fit,"R");
371  // hpzFrompzWithBfield->Draw();
372 
373  Int_t ResolutionX = 800, ResolutionY = 600; // for plotting
374 
375  TCanvas *chitshiftinx= new TCanvas("chitshiftinx", "chitshiftinx", ResolutionX, ResolutionY);
376  hhitshiftinx->Draw();
377 
378 
379 
380 
381 
382 
383  std::cout << moreThanTwentyPercentCount << " from " << goodEvents << " events deviate more than 20 per cent from MC truth value! Mean absolute relative deviation for pz is " << totalDeviation/goodEvents*100 << " per cent." << std::endl;
384 
385 
386  // That is probably not what I want
387 
388  //
389  // TCanvas *crespzFromInvpz= new TCanvas("crespzFromInvpz", "crespzFromInvpz", ResolutionX, ResolutionY);
390  // MakeResolutionPlot(hpzFromInvpz);
391  //
392  // TCanvas *crespzFromInvpz= new TCanvas("cpzFromInvpzWithBfield", "cpzFromInvpzWithBfield", ResolutionX, ResolutionY);
393  // MakeResolutionPlot(hpzFromInvpzWithBfield);
394  //
395  // TCanvas *crespzFromInvpz= new TCanvas("cpzFrompz", "cpzFrompz", ResolutionX, ResolutionY);
396  // MakeResolutionPlot(hpzFrompz);
397  //
398  // TCanvas *crespzFromInvpz= new TCanvas("cpzFrompzWithBfield", "cpzFrompzWithBfield", ResolutionX, ResolutionY);
399  // MakeResolutionPlot(hpzFrompzWithBfield);
400 
401 
402  // // Covariance Matrix of fit
403  //
404  // for (int i=0; i<6; ++i){
405  // for (int j=0; j<6; ++j){
406  // cout << fitresult->CovMatrix(i,j) << " ";
407  // }
408  // cout << "\n";
409  // }
410 
411  return 0;
412 
413 
414 }
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
low
int low
Definition: anaMvdDigi.C:51
tree
TTree * tree
Definition: plot_dirc.C:12
sigma
Double_t sigma[nsteps]
Definition: dedx_bands.C:65
inFile
TString inFile
Definition: hit_dirc.C:8
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
nEvents
Int_t nEvents
Definition: hit_dirc.C:11
rootlogon
rootlogon()
Definition: outdated/mpiTools/macros/emc/rootlogon.C:1
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
high
double high
Definition: full_core_ntp.C:35
gROOT SetStyle ( "Plain"  )
TCut smallhitshift ( )
Generated on Sun Aug 18 2019 03:02:34 for FairRoot/PandaRoot by   doxygen 1.8.8