CbmRoot
CbmAnaConversionPhotons2.cxx
Go to the documentation of this file.
1 
11 #include "CbmAnaConversionPhotons2.h"
12 
13 #include "CbmDrawHist.h"
14 #include "CbmGlobalTrack.h"
15 #include "CbmL1PFFitter.h"
16 #include "CbmMCTrack.h"
17 #include "CbmRichPoint.h"
18 #include "CbmRichRing.h"
19 #include "CbmStsTrack.h"
20 #include "CbmTrackMatchNew.h"
21 #include "FairLogger.h"
22 #include "FairRootManager.h"
23 #include "L1Field.h"
24 //#include "CbmStsKFTrackFitter.h"
25 #include "CbmLitGlobalElectronId.h"
26 
27 #include <algorithm>
28 #include <map>
29 
30 #include "TCanvas.h"
31 
32 
33 #include "CbmAnaConversionCutSettings.h"
34 #include "CbmAnaConversionKinematicParams.h"
35 
36 
37 using namespace std;
38 
39 
40 CbmAnaConversionPhotons2::CbmAnaConversionPhotons2()
41  : fRichPoints(NULL)
42  , fRichRings(NULL)
43  , fRichRingMatches(NULL)
44  , fMcTracks(NULL)
45  , fStsTracks(NULL)
46  , fStsTrackMatches(NULL)
47  , fGlobalTracks(NULL)
48  , fPrimVertex(NULL)
49  , fKFVertex()
50  , fHistoList_photons()
51  , fHistoList_photons_withRICH()
52  , fHistoList_photons_withRICH_withChi()
53  , fHistoList_photons_withRICH_fromTarget()
54  , fRecoTracklist_gtIndex()
55  , fRecoTracklist_mcIndex()
56  , fRecoTracklist_momentum()
57  , fRecoTracklist_chi()
58  , fRecoTracklist_mctrack()
59  , fRecoTracklist_withRICH_gtIndex()
60  , fRecoTracklist_withRICH_mcIndex()
61  , fRecoTracklist_withRICH_momentum()
62  , fRecoTracklist_withRICH_chi()
63  , fRecoTracklist_withRICH_mctrack()
64  , fh2Electrons_angle_all(NULL)
65  , fh2Electrons_angle_combBack(NULL)
66  , fh2Electrons_angle_allSameG(NULL)
67  , fh2Electrons_angle_all_cuts(NULL)
68  , fh2Electrons_angle_combBack_cuts(NULL)
69  , fh2Electrons_angle_allSameG_cuts(NULL)
70  , fh2Electrons_angle_CUTcomparison(NULL)
71  , fh2Electrons_angle_CUTcomparison_chi(NULL)
72  , fh2Electrons_angle_CUTcomparison_withRICH(NULL)
73  , fh2Electrons_angle_CUTcomparison_withRICH_chi(NULL)
74  , fh2Electrons_angle_CUTcomparison_withRICH_withChi(NULL)
75  , fh2Electrons_invmass_all(NULL)
76  , fh2Electrons_invmass_combBack(NULL)
77  , fh2Electrons_invmass_allSameG(NULL)
78  , fh2Electrons_invmass_all_cut(NULL)
79  , fh2Electrons_invmass_combBack_cut(NULL)
80  , fh2Electrons_invmass_allSameG_cut(NULL)
81  , fh2Electrons_angleVSpt_all(NULL)
82  , fh2Electrons_angleVSpt_combBack(NULL)
83  , fh2Electrons_angleVSpt_allSameG(NULL)
84  , fh2Electrons_invmassVSpt_all(NULL)
85  , fh2Electrons_invmassVSpt_combBack(NULL)
86  , fh2Electrons_invmassVSpt_allSameG(NULL)
87  , fh2Electrons_angle_withRICH_all(NULL)
88  , fh2Electrons_angle_withRICH_combBack(NULL)
89  , fh2Electrons_angle_withRICH_allSameG(NULL)
90  , fh2Electrons_angleVSpt_withRICH_all(NULL)
91  , fh2Electrons_angleVSpt_withRICH_combBack(NULL)
92  , fh2Electrons_angleVSpt_withRICH_allSameG(NULL)
93  , fh2Electrons_invmass_withRICH_all(NULL)
94  , fh2Electrons_invmass_withRICH_combBack(NULL)
95  , fh2Electrons_invmass_withRICH_allSameG(NULL)
96  , fh2Electrons_invmassVSpt_withRICH_all(NULL)
97  , fh2Electrons_invmassVSpt_withRICH_combBack(NULL)
98  , fh2Electrons_invmassVSpt_withRICH_allSameG(NULL)
99  , fh2Electrons_angle_withRICH_withChi_all(NULL)
100  , fh2Electrons_angle_withRICH_withChi_combBack(NULL)
101  , fh2Electrons_angle_withRICH_withChi_allSameG(NULL)
102  , fh2Electrons_angleVSpt_withRICH_withChi_all(NULL)
103  , fh2Electrons_angleVSpt_withRICH_withChi_combBack(NULL)
104  , fh2Electrons_angleVSpt_withRICH_withChi_allSameG(NULL)
105  , fh2Electrons_invmass_withRICH_withChi_all(NULL)
106  , fh2Electrons_invmass_withRICH_withChi_combBack(NULL)
107  , fh2Electrons_invmass_withRICH_withChi_allSameG(NULL)
108  , fh2Electrons_invmassVSpt_withRICH_withChi_all(NULL)
109  , fh2Electrons_invmassVSpt_withRICH_withChi_combBack(NULL)
110  , fh2Electrons_invmassVSpt_withRICH_withChi_allSameG(NULL)
111  , fh2Electrons_angle_withRICH_fromTarget_all(NULL)
112  , fh2Electrons_angle_withRICH_fromTarget_combBack(NULL)
113  , fh2Electrons_angle_withRICH_fromTarget_allSameG(NULL)
114  , fh2Electrons_angleVSpt_withRICH_fromTarget_all(NULL)
115  , fh2Electrons_angleVSpt_withRICH_fromTarget_combBack(NULL)
116  , fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG(NULL)
117  , fh2Electrons_invmass_withRICH_fromTarget_all(NULL)
118  , fh2Electrons_invmass_withRICH_fromTarget_combBack(NULL)
119  , fh2Electrons_invmass_withRICH_fromTarget_allSameG(NULL)
120  , fh2Electrons_invmassVSpt_withRICH_fromTarget_all(NULL)
121  , fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack(NULL)
122  , fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG(NULL)
123  , fVector_combinations()
124  , fh2Electrons_fullrecoCheck(NULL)
125  , timer()
126  , fTime(0.) {}
127 
128 CbmAnaConversionPhotons2::~CbmAnaConversionPhotons2() {}
129 
130 
131 void CbmAnaConversionPhotons2::Init() {
132  FairRootManager* ioman = FairRootManager::Instance();
133  if (NULL == ioman) {
134  Fatal("CbmAnaConversion::Init", "RootManager not instantised!");
135  }
136 
137  fRichPoints = (TClonesArray*) ioman->GetObject("RichPoint");
138  if (NULL == fRichPoints) {
139  Fatal("CbmAnaConversion::Init", "No RichPoint array!");
140  }
141 
142  fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
143  if (NULL == fMcTracks) {
144  Fatal("CbmAnaConversion::Init", "No MCTrack array!");
145  }
146 
147  fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
148  if (NULL == fStsTracks) {
149  Fatal("CbmAnaConversion::Init", "No StsTrack array!");
150  }
151 
152  fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
153  if (NULL == fStsTrackMatches) {
154  Fatal("CbmAnaConversion::Init", "No StsTrackMatch array!");
155  }
156 
157  fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
158  if (NULL == fGlobalTracks) {
159  Fatal("CbmAnaConversion::Init", "No GlobalTrack array!");
160  }
161 
162  // Get pointer to PrimaryVertex object from IOManager if it exists
163  // The old name for the object is "PrimaryVertex" the new one
164  // "PrimaryVertex." Check first for the new name
165  fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex."));
166  if (nullptr == fPrimVertex) {
167  fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex"));
168  }
169  if (nullptr == fPrimVertex) { LOG(fatal) << "No PrimaryVertex array!"; }
170 
171  fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
172  if (NULL == fRichRings) {
173  Fatal("CbmAnaConversion::Init", "No RichRing array!");
174  }
175 
176  fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
177  if (NULL == fRichRingMatches) {
178  Fatal("CbmAnaConversion::Init", "No RichRingMatch array!");
179  }
180 
181 
182  InitHistos();
183 }
184 
185 
186 void CbmAnaConversionPhotons2::InitHistos() {
187  fHistoList_photons.clear();
188  fHistoList_photons_withRICH.clear();
189  fHistoList_photons_withRICH_withChi.clear();
190  fHistoList_photons_withRICH_fromTarget.clear();
191 
192 
193  // opening angles for all photon-energies (RECO)
194  fh2Electrons_angle_all =
195  new TH1D("fh2Electrons_angle_all",
196  "fh2Electrons_angle_all; opening angle [deg]; #",
197  2001,
198  -0.05,
199  200.05);
200  fh2Electrons_angle_combBack =
201  new TH1D("fh2Electrons_angle_combBack",
202  "fh2Electrons_angle_combBack; opening angle [deg]; #",
203  2001,
204  -0.05,
205  200.05);
206  fh2Electrons_angle_allSameG =
207  new TH1D("fh2Electrons_angle_allSameG",
208  "fh2Electrons_angle_allSameG; opening angle [deg]; #",
209  1001,
210  -0.05,
211  100.05);
212  fHistoList_photons.push_back(fh2Electrons_angle_all);
213  fHistoList_photons.push_back(fh2Electrons_angle_combBack);
214  fHistoList_photons.push_back(fh2Electrons_angle_allSameG);
215 
216 
217  // histogram for comparison of different opening angle cuts and their influence on signal and background amounts
218  fh2Electrons_angle_CUTcomparison =
219  new TH1I("fh2Electrons_angle_CUTcomparison",
220  "fh2Electrons_angle_CUTcomparison; ; #",
221  14,
222  0.,
223  14.);
224  fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison);
225  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(1, "true, no cut");
226  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(2, "false, no cut");
227  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(3, "true, cut1");
228  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(4, "false, cut1");
229  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(5, "true, cut2");
230  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(6, "false, cut2");
231  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(7, "true, cut3");
232  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(8, "false, cut3");
233  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(9, "true, cut4");
234  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(10, "false, cut4");
235  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(11, "true, cut5");
236  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(12, "false, cut5");
237  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(13, "true, cut6");
238  fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(14, "false, cut6");
239 
240 
241  fh2Electrons_angle_CUTcomparison_chi =
242  new TH1I("fh2Electrons_angle_CUTcomparison_chi",
243  "fh2Electrons_angle_CUTcomparison_chi; ; #",
244  10,
245  0.,
246  10.);
247  fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_chi);
248  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(1,
249  "true, no cut");
250  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(
251  2, "false, no cut");
252  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(3,
253  "true, cut1");
254  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(4,
255  "false, cut1");
256  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(5,
257  "true, cut2");
258  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(6,
259  "false, cut2");
260  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(7,
261  "true, cut3");
262  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(8,
263  "false, cut3");
264  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(9,
265  "true, cut4");
266  fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(10,
267  "false, cut4");
268 
269 
270  fh2Electrons_angle_CUTcomparison_withRICH =
271  new TH1I("fh2Electrons_angle_CUTcomparison_withRICH",
272  "fh2Electrons_angle_CUTcomparison_withRICH; ; #",
273  14,
274  0.,
275  14.);
276  fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_withRICH);
277  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
278  1, "true, no cut");
279  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
280  2, "false, no cut");
281  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
282  3, "true, cut1");
283  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
284  4, "false, cut1");
285  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
286  5, "true, cut2");
287  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
288  6, "false, cut2");
289  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
290  7, "true, cut3");
291  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
292  8, "false, cut3");
293  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
294  9, "true, cut4");
295  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
296  10, "false, cut4");
297  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
298  11, "true, cut5");
299  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
300  12, "false, cut5");
301  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
302  13, "true, cut6");
303  fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(
304  14, "false, cut6");
305 
306 
307  fh2Electrons_angle_CUTcomparison_withRICH_chi =
308  new TH1I("fh2Electrons_angle_CUTcomparison_withRICH_chi",
309  "fh2Electrons_angle_CUTcomparison_withRICH_chi; ; #",
310  10,
311  0.,
312  10.);
313  fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_withRICH_chi);
314  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
315  1, "true, no cut");
316  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
317  2, "false, no cut");
318  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
319  3, "true, cut1");
320  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
321  4, "false, cut1");
322  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
323  5, "true, cut2");
324  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
325  6, "false, cut2");
326  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
327  7, "true, cut3");
328  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
329  8, "false, cut3");
330  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
331  9, "true, cut4");
332  fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(
333  10, "false, cut4");
334 
335 
336  fh2Electrons_angle_CUTcomparison_withRICH_withChi =
337  new TH1I("fh2Electrons_angle_CUTcomparison_withRICH_withChi",
338  "fh2Electrons_angle_CUTcomparison_withRICH_withChi; ; #",
339  14,
340  0.,
341  14.);
342  fHistoList_photons.push_back(
343  fh2Electrons_angle_CUTcomparison_withRICH_withChi);
344  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
345  1, "true, no cut");
346  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
347  2, "false, no cut");
348  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
349  3, "true, cut1");
350  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
351  4, "false, cut1");
352  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
353  5, "true, cut2");
354  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
355  6, "false, cut2");
356  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
357  7, "true, cut3");
358  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
359  8, "false, cut3");
360  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
361  9, "true, cut4");
362  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
363  10, "false, cut4");
364  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
365  11, "true, cut5");
366  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
367  12, "false, cut5");
368  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
369  13, "true, cut6");
370  fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(
371  14, "false, cut6");
372 
373 
374  // opening angles for all photon-energies (RECO) with application of opening angle cuts
375  fh2Electrons_angle_all_cuts =
376  new TH1D("fh2Electrons_angle_all_cuts",
377  "fh2Electrons_angle_all_cuts; opening angle [deg]; #",
378  101,
379  -0.05,
380  10.05);
381  fh2Electrons_angle_combBack_cuts =
382  new TH1D("fh2Electrons_angle_combBack_cuts",
383  "fh2Electrons_angle_combBack_cuts; opening angle [deg]; #",
384  101,
385  -0.05,
386  10.05);
387  fh2Electrons_angle_allSameG_cuts =
388  new TH1D("fh2Electrons_angle_allSameG_cuts",
389  "fh2Electrons_angle_allSameG_cuts; opening angle [deg]; #",
390  101,
391  -0.05,
392  10.05);
393  fHistoList_photons.push_back(fh2Electrons_angle_all_cuts);
394  fHistoList_photons.push_back(fh2Electrons_angle_combBack_cuts);
395  fHistoList_photons.push_back(fh2Electrons_angle_allSameG_cuts);
396 
397 
398  fh2Electrons_invmass_all =
399  new TH1D("fh2Electrons_invmass_all",
400  "fh2Electrons_invmass_all; invmass [GeV/c^2]; #",
401  5000,
402  0.,
403  5.);
404  fh2Electrons_invmass_combBack =
405  new TH1D("fh2Electrons_invmass_combBack",
406  "fh2Electrons_invmass_combBack; invmass [GeV/c^2]; #",
407  5000,
408  0.,
409  5.);
410  fh2Electrons_invmass_allSameG =
411  new TH1D("fh2Electrons_invmass_allSameG",
412  "fh2Electrons_invmass_allSameG; invmass [GeV/c^2]; #",
413  5000,
414  0.,
415  5);
416  fHistoList_photons.push_back(fh2Electrons_invmass_all);
417  fHistoList_photons.push_back(fh2Electrons_invmass_combBack);
418  fHistoList_photons.push_back(fh2Electrons_invmass_allSameG);
419 
420  fh2Electrons_invmass_all_cut =
421  new TH1D("fh2Electrons_invmass_all_cut",
422  "fh2Electrons_invmass_all_cut; invmass [GeV/c^2]; #",
423  5000,
424  0.,
425  5.);
426  fh2Electrons_invmass_combBack_cut =
427  new TH1D("fh2Electrons_invmass_combBack_cut",
428  "fh2Electrons_invmass_combBack_cut; invmass [GeV/c^2]; #",
429  5000,
430  0.,
431  5.);
432  fh2Electrons_invmass_allSameG_cut =
433  new TH1D("fh2Electrons_invmass_allSameG_cut",
434  "fh2Electrons_invmass_allSameG_cut; invmass [GeV/c^2]; #",
435  5000,
436  0.,
437  5);
438  fHistoList_photons.push_back(fh2Electrons_invmass_all_cut);
439  fHistoList_photons.push_back(fh2Electrons_invmass_combBack_cut);
440  fHistoList_photons.push_back(fh2Electrons_invmass_allSameG_cut);
441 
442 
443  // opening angle vs pt (reco)
444  fh2Electrons_angleVSpt_all =
445  new TH2D("fh2Electrons_angleVSpt_all",
446  "fh2Electrons_angleVSpt_all;pt [GeV/c];opening angle [deg]",
447  500,
448  0.,
449  5.,
450  400,
451  0.,
452  20.);
453  fh2Electrons_angleVSpt_combBack =
454  new TH2D("fh2Electrons_angleVSpt_combBack",
455  "fh2Electrons_angleVSpt_combBack;pt [GeV/c];opening angle [deg]",
456  500,
457  0.,
458  5.,
459  400,
460  0.,
461  20.);
462  fh2Electrons_angleVSpt_allSameG =
463  new TH2D("fh2Electrons_angleVSpt_allSameG",
464  "fh2Electrons_angleVSpt_allSameG;pt [GeV/c];opening angle [deg]",
465  500,
466  0.,
467  5.,
468  400,
469  0.,
470  20.);
471  fHistoList_photons.push_back(fh2Electrons_angleVSpt_all);
472  fHistoList_photons.push_back(fh2Electrons_angleVSpt_combBack);
473  fHistoList_photons.push_back(fh2Electrons_angleVSpt_allSameG);
474 
475 
476  // invariant mass vs pt (reco)
477  fh2Electrons_invmassVSpt_all =
478  new TH2D("fh2Electrons_invmassVSpt_all",
479  "fh2Electrons_invmassVSpt_all;pt [GeV/c];invmass [GeV]",
480  500,
481  0.,
482  5.,
483  5000,
484  0.,
485  5.);
486  fh2Electrons_invmassVSpt_combBack =
487  new TH2D("fh2Electrons_invmassVSpt_combBack",
488  "fh2Electrons_invmassVSpt_combBack;pt [GeV/c];invmass [GeV]",
489  500,
490  0.,
491  5.,
492  5000,
493  0.,
494  5.);
495  fh2Electrons_invmassVSpt_allSameG =
496  new TH2D("fh2Electrons_invmassVSpt_allSameG",
497  "fh2Electrons_invmassVSpt_allSameG;pt [GeV/c];invmass [GeV]",
498  500,
499  0.,
500  5.,
501  5000,
502  0.,
503  5.);
504  fHistoList_photons.push_back(fh2Electrons_invmassVSpt_all);
505  fHistoList_photons.push_back(fh2Electrons_invmassVSpt_combBack);
506  fHistoList_photons.push_back(fh2Electrons_invmassVSpt_allSameG);
507 
508 
509  // ##############################################################################
510  // ##############################################################################
511  // ##############################################################################
512 
513 
514  // opening angles for all photon-energies (RECO) with RICH
515  fh2Electrons_angle_withRICH_all =
516  new TH1D("fh2Electrons_angle_withRICH_all",
517  "fh2Electrons_angle_withRICH_all; opening angle [deg]; #",
518  2001,
519  -0.05,
520  200.05);
521  fh2Electrons_angle_withRICH_combBack =
522  new TH1D("fh2Electrons_angle_withRICH_combBack",
523  "fh2Electrons_angle_withRICH_combBack; opening angle [deg]; #",
524  2001,
525  -0.05,
526  200.05);
527  fh2Electrons_angle_withRICH_allSameG =
528  new TH1D("fh2Electrons_angle_withRICH_allSameG",
529  "fh2Electrons_angle_withRICH_allSameG; opening angle [deg]; #",
530  1001,
531  -0.05,
532  100.05);
533  fHistoList_photons_withRICH.push_back(fh2Electrons_angle_withRICH_all);
534  fHistoList_photons_withRICH.push_back(fh2Electrons_angle_withRICH_combBack);
535  fHistoList_photons_withRICH.push_back(fh2Electrons_angle_withRICH_allSameG);
536 
537  // opening angle vs pt (reco), with RICH
538  fh2Electrons_angleVSpt_withRICH_all = new TH2D(
539  "fh2Electrons_angleVSpt_withRICH_all",
540  "fh2Electrons_angleVSpt_withRICH_all;pt [GeV/c];opening angle [deg]",
541  500,
542  0.,
543  5.,
544  400,
545  0.,
546  20.);
547  fh2Electrons_angleVSpt_withRICH_combBack = new TH2D(
548  "fh2Electrons_angleVSpt_withRICH_combBack",
549  "fh2Electrons_angleVSpt_withRICH_combBack;pt [GeV/c];opening angle [deg]",
550  500,
551  0.,
552  5.,
553  400,
554  0.,
555  20.);
556  fh2Electrons_angleVSpt_withRICH_allSameG = new TH2D(
557  "fh2Electrons_angleVSpt_withRICH_allSameG",
558  "fh2Electrons_angleVSpt_withRICH_allSameG;pt [GeV/c];opening angle [deg]",
559  500,
560  0.,
561  5.,
562  400,
563  0.,
564  20.);
565  fHistoList_photons_withRICH.push_back(fh2Electrons_angleVSpt_withRICH_all);
566  fHistoList_photons_withRICH.push_back(
567  fh2Electrons_angleVSpt_withRICH_combBack);
568  fHistoList_photons_withRICH.push_back(
569  fh2Electrons_angleVSpt_withRICH_allSameG);
570 
571  // invmass for all photon-energies (RECO) with RICH
572  fh2Electrons_invmass_withRICH_all =
573  new TH1D("fh2Electrons_invmass_withRICH_all",
574  "fh2Electrons_invmass_withRICH_all; invmass [GeV/c^2]; #",
575  5000,
576  0.,
577  5.);
578  fh2Electrons_invmass_withRICH_combBack =
579  new TH1D("fh2Electrons_invmass_withRICH_combBack",
580  "fh2Electrons_invmass_withRICH_combBack; invmass [GeV/c^2]; #",
581  5000,
582  0.,
583  5.);
584  fh2Electrons_invmass_withRICH_allSameG =
585  new TH1D("fh2Electrons_invmass_withRICH_allSameG",
586  "fh2Electrons_invmass_withRICH_allSameG; invmass [GeV/c^2]; #",
587  5000,
588  0.,
589  5.);
590  fHistoList_photons_withRICH.push_back(fh2Electrons_invmass_withRICH_all);
591  fHistoList_photons_withRICH.push_back(fh2Electrons_invmass_withRICH_combBack);
592  fHistoList_photons_withRICH.push_back(fh2Electrons_invmass_withRICH_allSameG);
593 
594  // invmass vs pt (reco), with RICH
595  fh2Electrons_invmassVSpt_withRICH_all =
596  new TH2D("fh2Electrons_invmassVSpt_withRICH_all",
597  "fh2Electrons_invmassVSpt_withRICH_all;pt [GeV/c];invmass [GeV]",
598  500,
599  0.,
600  5.,
601  5000,
602  0.,
603  5.);
604  fh2Electrons_invmassVSpt_withRICH_combBack = new TH2D(
605  "fh2Electrons_invmassVSpt_withRICH_combBack",
606  "fh2Electrons_invmassVSpt_withRICH_combBack;pt [GeV/c];invmass [GeV]",
607  500,
608  0.,
609  5.,
610  5000,
611  0.,
612  5.);
613  fh2Electrons_invmassVSpt_withRICH_allSameG = new TH2D(
614  "fh2Electrons_invmassVSpt_withRICH_allSameG",
615  "fh2Electrons_invmassVSpt_withRICH_allSameG;pt [GeV/c];invmass [GeV]",
616  500,
617  0.,
618  5.,
619  5000,
620  0.,
621  5.);
622  fHistoList_photons_withRICH.push_back(fh2Electrons_invmassVSpt_withRICH_all);
623  fHistoList_photons_withRICH.push_back(
624  fh2Electrons_invmassVSpt_withRICH_combBack);
625  fHistoList_photons_withRICH.push_back(
626  fh2Electrons_invmassVSpt_withRICH_allSameG);
627 
628 
629  fh2Electrons_fullrecoCheck = new TH1I(
630  "fh2Electrons_fullrecoCheck", "fh2Electrons_fullrecoCheck;; #", 5, 0., 5.);
631  fHistoList_photons.push_back(fh2Electrons_fullrecoCheck);
632 
633 
634  // ##############################################################################
635  // ##############################################################################
636  // ##############################################################################
637 
638 
639  // opening angles for all photon-energies (RECO) with RICH, with standard chi-cut of refitted momentum
640  fh2Electrons_angle_withRICH_withChi_all =
641  new TH1D("fh2Electrons_angle_withRICH_withChi_all",
642  "fh2Electrons_angle_withRICH_withChi_all; opening angle [deg]; #",
643  2001,
644  -0.05,
645  200.05);
646  fh2Electrons_angle_withRICH_withChi_combBack = new TH1D(
647  "fh2Electrons_angle_withRICH_withChi_combBack",
648  "fh2Electrons_angle_withRICH_withChi_combBack; opening angle [deg]; #",
649  2001,
650  -0.05,
651  200.05);
652  fh2Electrons_angle_withRICH_withChi_allSameG = new TH1D(
653  "fh2Electrons_angle_withRICH_withChi_allSameG",
654  "fh2Electrons_angle_withRICH_withChi_allSameG; opening angle [deg]; #",
655  1001,
656  -0.05,
657  100.05);
658  fHistoList_photons_withRICH_withChi.push_back(
659  fh2Electrons_angle_withRICH_withChi_all);
660  fHistoList_photons_withRICH_withChi.push_back(
661  fh2Electrons_angle_withRICH_withChi_combBack);
662  fHistoList_photons_withRICH_withChi.push_back(
663  fh2Electrons_angle_withRICH_withChi_allSameG);
664 
665  // opening angle vs pt (reco), with RICH
666  fh2Electrons_angleVSpt_withRICH_withChi_all =
667  new TH2D("fh2Electrons_angleVSpt_withRICH_withChi_all",
668  "fh2Electrons_angleVSpt_withRICH_withChi_all;pt [GeV/c];opening "
669  "angle [deg]",
670  500,
671  0.,
672  5.,
673  400,
674  0.,
675  20.);
676  fh2Electrons_angleVSpt_withRICH_withChi_combBack =
677  new TH2D("fh2Electrons_angleVSpt_withRICH_withChi_combBack",
678  "fh2Electrons_angleVSpt_withRICH_withChi_combBack;pt "
679  "[GeV/c];opening angle [deg]",
680  500,
681  0.,
682  5.,
683  400,
684  0.,
685  20.);
686  fh2Electrons_angleVSpt_withRICH_withChi_allSameG =
687  new TH2D("fh2Electrons_angleVSpt_withRICH_withChi_allSameG",
688  "fh2Electrons_angleVSpt_withRICH_withChi_allSameG;pt "
689  "[GeV/c];opening angle [deg]",
690  500,
691  0.,
692  5.,
693  400,
694  0.,
695  20.);
696  fHistoList_photons_withRICH_withChi.push_back(
697  fh2Electrons_angleVSpt_withRICH_withChi_all);
698  fHistoList_photons_withRICH_withChi.push_back(
699  fh2Electrons_angleVSpt_withRICH_withChi_combBack);
700  fHistoList_photons_withRICH_withChi.push_back(
701  fh2Electrons_angleVSpt_withRICH_withChi_allSameG);
702 
703  // invmass for all photon-energies (RECO) with RICH
704  fh2Electrons_invmass_withRICH_withChi_all =
705  new TH1D("fh2Electrons_invmass_withRICH_withChi_all",
706  "fh2Electrons_invmass_withRICH_withChi_all; invmass [GeV/c^2]; #",
707  5000,
708  0.,
709  5.);
710  fh2Electrons_invmass_withRICH_withChi_combBack = new TH1D(
711  "fh2Electrons_invmass_withRICH_withChi_combBack",
712  "fh2Electrons_invmass_withRICH_withChi_combBack; invmass [GeV/c^2]; #",
713  5000,
714  0.,
715  5.);
716  fh2Electrons_invmass_withRICH_withChi_allSameG = new TH1D(
717  "fh2Electrons_invmass_withRICH_withChi_allSameG",
718  "fh2Electrons_invmass_withRICH_withChi_allSameG; invmass [GeV/c^2]; #",
719  5000,
720  0.,
721  5.);
722  fHistoList_photons_withRICH_withChi.push_back(
723  fh2Electrons_invmass_withRICH_withChi_all);
724  fHistoList_photons_withRICH_withChi.push_back(
725  fh2Electrons_invmass_withRICH_withChi_combBack);
726  fHistoList_photons_withRICH_withChi.push_back(
727  fh2Electrons_invmass_withRICH_withChi_allSameG);
728 
729  // invmass vs pt (reco), with RICH
730  fh2Electrons_invmassVSpt_withRICH_withChi_all = new TH2D(
731  "fh2Electrons_invmassVSpt_withRICH_withChi_all",
732  "fh2Electrons_invmassVSpt_withRICH_withChi_all;pt [GeV/c];invmass [GeV]",
733  500,
734  0.,
735  5.,
736  5000,
737  0.,
738  5.);
739  fh2Electrons_invmassVSpt_withRICH_withChi_combBack =
740  new TH2D("fh2Electrons_invmassVSpt_withRICH_withChi_combBack",
741  "fh2Electrons_invmassVSpt_withRICH_withChi_combBack;pt "
742  "[GeV/c];invmass [GeV]",
743  500,
744  0.,
745  5.,
746  5000,
747  0.,
748  5.);
749  fh2Electrons_invmassVSpt_withRICH_withChi_allSameG =
750  new TH2D("fh2Electrons_invmassVSpt_withRICH_withChi_allSameG",
751  "fh2Electrons_invmassVSpt_withRICH_withChi_allSameG;pt "
752  "[GeV/c];invmass [GeV]",
753  500,
754  0.,
755  5.,
756  5000,
757  0.,
758  5.);
759  fHistoList_photons_withRICH_withChi.push_back(
760  fh2Electrons_invmassVSpt_withRICH_withChi_all);
761  fHistoList_photons_withRICH_withChi.push_back(
762  fh2Electrons_invmassVSpt_withRICH_withChi_combBack);
763  fHistoList_photons_withRICH_withChi.push_back(
764  fh2Electrons_invmassVSpt_withRICH_withChi_allSameG);
765 
766 
767  // ##############################################################################
768  // ##############################################################################
769  // ##############################################################################
770 
771 
772  // opening angles for all photon-energies (RECO) with RICH, from target (z>1, selection from MC-true)
773  fh2Electrons_angle_withRICH_fromTarget_all = new TH1D(
774  "fh2Electrons_angle_withRICH_fromTarget_all",
775  "fh2Electrons_angle_withRICH_fromTarget_all; opening angle [deg]; #",
776  2001,
777  -0.05,
778  200.05);
779  fh2Electrons_angle_withRICH_fromTarget_combBack = new TH1D(
780  "fh2Electrons_angle_withRICH_fromTarget_combBack",
781  "fh2Electrons_angle_withRICH_fromTarget_combBack; opening angle [deg]; #",
782  2001,
783  -0.05,
784  200.05);
785  fh2Electrons_angle_withRICH_fromTarget_allSameG = new TH1D(
786  "fh2Electrons_angle_withRICH_fromTarget_allSameG",
787  "fh2Electrons_angle_withRICH_fromTarget_allSameG; opening angle [deg]; #",
788  1001,
789  -0.05,
790  100.05);
791  fHistoList_photons_withRICH_fromTarget.push_back(
792  fh2Electrons_angle_withRICH_fromTarget_all);
793  fHistoList_photons_withRICH_fromTarget.push_back(
794  fh2Electrons_angle_withRICH_fromTarget_combBack);
795  fHistoList_photons_withRICH_fromTarget.push_back(
796  fh2Electrons_angle_withRICH_fromTarget_allSameG);
797 
798  // opening angle vs pt (reco), with RICH
799  fh2Electrons_angleVSpt_withRICH_fromTarget_all =
800  new TH2D("fh2Electrons_angleVSpt_withRICH_fromTarget_all",
801  "fh2Electrons_angleVSpt_withRICH_fromTarget_all;pt "
802  "[GeV/c];opening angle [deg]",
803  500,
804  0.,
805  5.,
806  400,
807  0.,
808  20.);
809  fh2Electrons_angleVSpt_withRICH_fromTarget_combBack =
810  new TH2D("fh2Electrons_angleVSpt_withRICH_fromTarget_combBack",
811  "fh2Electrons_angleVSpt_withRICH_fromTarget_combBack;pt "
812  "[GeV/c];opening angle [deg]",
813  500,
814  0.,
815  5.,
816  400,
817  0.,
818  20.);
819  fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG =
820  new TH2D("fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG",
821  "fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG;pt "
822  "[GeV/c];opening angle [deg]",
823  500,
824  0.,
825  5.,
826  400,
827  0.,
828  20.);
829  fHistoList_photons_withRICH_fromTarget.push_back(
830  fh2Electrons_angleVSpt_withRICH_fromTarget_all);
831  fHistoList_photons_withRICH_fromTarget.push_back(
832  fh2Electrons_angleVSpt_withRICH_fromTarget_combBack);
833  fHistoList_photons_withRICH_fromTarget.push_back(
834  fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG);
835 
836  // invmass for all photon-energies (RECO) with RICH
837  fh2Electrons_invmass_withRICH_fromTarget_all = new TH1D(
838  "fh2Electrons_invmass_withRICH_fromTarget_all",
839  "fh2Electrons_invmass_withRICH_fromTarget_all; invmass [GeV/c^2]; #",
840  5000,
841  0.,
842  5.);
843  fh2Electrons_invmass_withRICH_fromTarget_combBack = new TH1D(
844  "fh2Electrons_invmass_withRICH_fromTarget_combBack",
845  "fh2Electrons_invmass_withRICH_fromTarget_combBack; invmass [GeV/c^2]; #",
846  5000,
847  0.,
848  5.);
849  fh2Electrons_invmass_withRICH_fromTarget_allSameG = new TH1D(
850  "fh2Electrons_invmass_withRICH_fromTarget_allSameG",
851  "fh2Electrons_invmass_withRICH_fromTarget_allSameG; invmass [GeV/c^2]; #",
852  5000,
853  0.,
854  5.);
855  fHistoList_photons_withRICH_fromTarget.push_back(
856  fh2Electrons_invmass_withRICH_fromTarget_all);
857  fHistoList_photons_withRICH_fromTarget.push_back(
858  fh2Electrons_invmass_withRICH_fromTarget_combBack);
859  fHistoList_photons_withRICH_fromTarget.push_back(
860  fh2Electrons_invmass_withRICH_fromTarget_allSameG);
861 
862  // invmass vs pt (reco), with RICH
863  fh2Electrons_invmassVSpt_withRICH_fromTarget_all = new TH2D(
864  "fh2Electrons_invmassVSpt_withRICH_fromTarget_all",
865  "fh2Electrons_invmassVSpt_withRICH_fromTarget_all;pt [GeV/c];invmass [GeV]",
866  500,
867  0.,
868  5.,
869  5000,
870  0.,
871  5.);
872  fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack =
873  new TH2D("fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack",
874  "fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack;pt "
875  "[GeV/c];invmass [GeV]",
876  500,
877  0.,
878  5.,
879  5000,
880  0.,
881  5.);
882  fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG =
883  new TH2D("fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG",
884  "fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG;pt "
885  "[GeV/c];invmass [GeV]",
886  500,
887  0.,
888  5.,
889  5000,
890  0.,
891  5.);
892  fHistoList_photons_withRICH_fromTarget.push_back(
893  fh2Electrons_invmassVSpt_withRICH_fromTarget_all);
894  fHistoList_photons_withRICH_fromTarget.push_back(
895  fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack);
896  fHistoList_photons_withRICH_fromTarget.push_back(
897  fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG);
898 }
899 
900 
901 void CbmAnaConversionPhotons2::Finish() {
902  //gDirectory->cd("analysis-conversion");
903  gDirectory->mkdir("Photons2");
904  gDirectory->cd("Photons2");
905 
906  gDirectory->mkdir("With RICH");
907  gDirectory->cd("With RICH");
908 
909  for (UInt_t i = 0; i < fHistoList_photons_withRICH.size(); i++) {
910  fHistoList_photons_withRICH[i]->Write();
911  }
912  gDirectory->cd("..");
913 
914  gDirectory->mkdir("With RICH, with Chi");
915  gDirectory->cd("With RICH, with Chi");
916 
917  for (UInt_t i = 0; i < fHistoList_photons_withRICH_withChi.size(); i++) {
918  fHistoList_photons_withRICH_withChi[i]->Write();
919  }
920  gDirectory->cd("..");
921 
922  gDirectory->mkdir("With RICH, from target");
923  gDirectory->cd("With RICH, from target");
924 
925  for (UInt_t i = 0; i < fHistoList_photons_withRICH_fromTarget.size(); i++) {
926  fHistoList_photons_withRICH_fromTarget[i]->Write();
927  }
928  gDirectory->cd("..");
929 
930  for (UInt_t i = 0; i < fHistoList_photons.size(); i++) {
931  fHistoList_photons[i]->Write();
932  }
933  gDirectory->cd("..");
934 }
935 
936 
937 void CbmAnaConversionPhotons2::Exec() {
938  if (fPrimVertex != NULL) {
939  fKFVertex = CbmKFVertex(*fPrimVertex);
940  } else {
941  Fatal("CbmAnaConversionPhotons2::Exec", "No PrimaryVertex array!");
942  }
943 
944 
945  fRecoTracklist_gtIndex.clear();
946  fRecoTracklist_mcIndex.clear();
947  fRecoTracklist_momentum.clear();
948  fRecoTracklist_chi.clear();
949  fRecoTracklist_mctrack.clear();
950 
951  fRecoTracklist_withRICH_gtIndex.clear();
952  fRecoTracklist_withRICH_mcIndex.clear();
953  fRecoTracklist_withRICH_momentum.clear();
954  fRecoTracklist_withRICH_chi.clear();
955  fRecoTracklist_withRICH_mctrack.clear();
956 
957  fVector_combinations.clear();
958 
959 
960  // everything related to reconstructed data
961  Int_t nofGlobalTracks = fGlobalTracks->GetEntriesFast();
962  for (int iG = 0; iG < nofGlobalTracks; iG++) {
963  CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iG);
964  if (NULL == gTrack) continue;
965  int stsInd = gTrack->GetStsTrackIndex();
966  int richInd = gTrack->GetRichRingIndex();
967  if (stsInd < 0) continue;
968 
969  CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsInd);
970  if (stsTrack == NULL) continue;
971 
972  CbmTrackMatchNew* stsMatch =
973  (CbmTrackMatchNew*) fStsTrackMatches->At(stsInd);
974  if (stsMatch == NULL) continue;
975  if (stsMatch->GetNofLinks() <= 0) continue;
976  int stsMcTrackId = stsMatch->GetMatchedLink().GetIndex();
977  if (stsMcTrackId < 0) continue;
978  CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId);
979  if (mcTrack1 == NULL) continue;
980 
981 
982  int pdg = TMath::Abs(mcTrack1->GetPdgCode());
983 
984 
985  // calculate refitted momenta at primary vertex
986  TVector3 refittedMomentum;
987  CbmL1PFFitter fPFFitter;
988  vector<CbmStsTrack> stsTracks;
989  stsTracks.resize(1);
990  stsTracks[0] = *stsTrack;
991  vector<L1FieldRegion> vField;
992  vector<float> chiPrim;
993  fPFFitter.GetChiToVertex(stsTracks, vField, chiPrim, fKFVertex, 3e6);
994  //cand.chi2sts = stsTracks[0].GetChiSq() / stsTracks[0].GetNDF();
995  //cand.chi2Prim = chiPrim[0];
996  const FairTrackParam* vtxTrack = stsTracks[0].GetParamFirst();
997  vtxTrack->Momentum(refittedMomentum);
998  float result_chi = chiPrim[0];
999 
1000 
1001  // Doing refit of momenta with electron assumption
1002  CbmL1PFFitter fPFFitter_electron;
1003  vector<CbmStsTrack> stsTracks_electron;
1004  stsTracks_electron.resize(1);
1005  stsTracks_electron[0] = *stsTrack;
1006  vector<L1FieldRegion> vField_electron;
1007  vector<float> chiPrim_electron;
1008  vector<int> pidHypo_electron;
1009  pidHypo_electron.push_back(11);
1010  fPFFitter_electron.Fit(stsTracks_electron, pidHypo_electron);
1011  fPFFitter_electron.GetChiToVertex(
1012  stsTracks_electron, vField_electron, chiPrim_electron, fKFVertex, 3e6);
1013 
1014  TVector3 refittedMomentum_electron;
1015  const FairTrackParam* vtxTrack_electron =
1016  stsTracks_electron[0].GetParamFirst();
1017  vtxTrack_electron->Momentum(refittedMomentum_electron);
1018  float result_chi_electron = chiPrim_electron[0];
1019 
1020  refittedMomentum = refittedMomentum_electron;
1021  result_chi = result_chi_electron;
1022 
1023 
1024  if (pdg == 11) {
1025  fRecoTracklist_gtIndex.push_back(iG);
1026  fRecoTracklist_mcIndex.push_back(stsMcTrackId);
1027  fRecoTracklist_momentum.push_back(refittedMomentum);
1028  fRecoTracklist_chi.push_back(result_chi);
1029  fRecoTracklist_mctrack.push_back(mcTrack1);
1030  }
1031 
1032 
1033  if (richInd < 0) continue;
1034  CbmTrackMatchNew* richMatch =
1035  (CbmTrackMatchNew*) fRichRingMatches->At(richInd);
1036  if (richMatch == NULL) continue;
1037  int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
1038  if (richMcTrackId < 0) continue;
1039  CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
1040  if (mcTrack2 == NULL) continue;
1041 
1042 
1043  if (pdg == 11) {
1044  fRecoTracklist_withRICH_gtIndex.push_back(iG);
1045  fRecoTracklist_withRICH_mcIndex.push_back(stsMcTrackId);
1046  fRecoTracklist_withRICH_momentum.push_back(refittedMomentum);
1047  fRecoTracklist_withRICH_chi.push_back(result_chi);
1048  fRecoTracklist_withRICH_mctrack.push_back(mcTrack1);
1049  }
1050  }
1051 
1052  AnalyseElectronsReco();
1053  AnalyseElectronsRecoWithRICH();
1054 }
1055 
1056 
1057 void CbmAnaConversionPhotons2::AnalyseElectronsReco() {
1058  int electronnumber = fRecoTracklist_gtIndex.size();
1059 
1060  cout << "CbmAnaConversionPhotons: array size in AnalyseElectronsReco(): "
1061  << electronnumber << endl;
1062  for (int i = 0; i < electronnumber - 1; i++) {
1063  for (int j = i + 1; j < electronnumber; j++) {
1064  if (fRecoTracklist_mctrack[i]->GetPdgCode()
1065  + fRecoTracklist_mctrack[j]->GetPdgCode()
1066  != 0)
1067  continue; // only 1 electron and 1 positron allowed
1068 
1069 
1070  CbmAnaConversionKinematicParams paramSet =
1071  CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(
1072  fRecoTracklist_momentum[i], fRecoTracklist_momentum[j]);
1073  Double_t OpeningAngleCut =
1074  CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt);
1075 
1076 
1077  int motherID_i = fRecoTracklist_mctrack[i]->GetMotherId();
1078  int motherID_j = fRecoTracklist_mctrack[j]->GetMotherId();
1079 
1080 
1081  // first all possible combinations are considered
1082 
1083  fh2Electrons_angle_all->Fill(paramSet.fAngle);
1084  fh2Electrons_angleVSpt_all->Fill(paramSet.fPt, paramSet.fAngle);
1085  fh2Electrons_invmass_all->Fill(paramSet.fMinv);
1086  fh2Electrons_invmassVSpt_all->Fill(paramSet.fPt, paramSet.fMinv);
1087 
1088  if (paramSet.fAngle < OpeningAngleCut) {
1089  fh2Electrons_invmass_all_cut->Fill(paramSet.fMinv);
1090  fh2Electrons_angle_all_cuts->Fill(paramSet.fAngle);
1091  }
1092 
1093 
1094  // then all false combinations are analysed, after that "continue" of loop, i.e. break
1095  if (motherID_i != motherID_j) {
1096  fh2Electrons_angle_combBack->Fill(paramSet.fAngle);
1097  fh2Electrons_angleVSpt_combBack->Fill(paramSet.fPt, paramSet.fAngle);
1098  fh2Electrons_invmass_combBack->Fill(paramSet.fMinv);
1099  fh2Electrons_invmassVSpt_combBack->Fill(paramSet.fPt, paramSet.fMinv);
1100 
1101  if (paramSet.fAngle < OpeningAngleCut) {
1102  fh2Electrons_invmass_combBack_cut->Fill(paramSet.fMinv);
1103  fh2Electrons_angle_combBack_cuts->Fill(paramSet.fAngle);
1104  }
1105 
1106  // study of different opening angle cuts
1107  fh2Electrons_angle_CUTcomparison->Fill(1); // no cuts applied
1108  if (paramSet.fAngle
1109  < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1110  fh2Electrons_angle_CUTcomparison->Fill(3);
1111  if (paramSet.fAngle
1112  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(
1113  paramSet.fPt))
1114  fh2Electrons_angle_CUTcomparison->Fill(5);
1115  if (paramSet.fAngle
1116  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(
1117  paramSet.fPt))
1118  fh2Electrons_angle_CUTcomparison->Fill(7);
1119  if (paramSet.fAngle
1120  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(
1121  paramSet.fPt))
1122  fh2Electrons_angle_CUTcomparison->Fill(9);
1123  if (paramSet.fAngle
1124  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(
1125  paramSet.fPt))
1126  fh2Electrons_angle_CUTcomparison->Fill(11);
1127  if (paramSet.fAngle
1128  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(
1129  paramSet.fPt))
1130  fh2Electrons_angle_CUTcomparison->Fill(13);
1131 
1132 
1133  fh2Electrons_angle_CUTcomparison_chi->Fill(1); // no cuts applied
1134  Double_t pt_e1 = fRecoTracklist_momentum[i].Perp();
1135  Double_t pt_e2 = fRecoTracklist_momentum[j].Perp();
1136  if (fRecoTracklist_chi[i]
1137  < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1138  && fRecoTracklist_chi[j]
1139  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
1140  fh2Electrons_angle_CUTcomparison_chi->Fill(3);
1141  }
1142  if (fRecoTracklist_chi[i]
1143  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
1144  && fRecoTracklist_chi[j]
1145  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
1146  fh2Electrons_angle_CUTcomparison_chi->Fill(5);
1147  }
1148  if (fRecoTracklist_chi[i]
1149  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
1150  && fRecoTracklist_chi[j]
1151  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
1152  fh2Electrons_angle_CUTcomparison_chi->Fill(7);
1153  }
1154  if (fRecoTracklist_chi[i]
1155  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
1156  && fRecoTracklist_chi[j]
1157  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
1158  fh2Electrons_angle_CUTcomparison_chi->Fill(9);
1159  }
1160 
1161  continue;
1162  }
1163 
1164 
1165  // everything, that is not a false combination, will be further analysed
1166 
1167  fh2Electrons_angle_allSameG->Fill(paramSet.fAngle);
1168  fh2Electrons_angleVSpt_allSameG->Fill(paramSet.fPt, paramSet.fAngle);
1169  fh2Electrons_invmass_allSameG->Fill(paramSet.fMinv);
1170  fh2Electrons_invmassVSpt_allSameG->Fill(paramSet.fPt, paramSet.fMinv);
1171 
1172  if (paramSet.fAngle < OpeningAngleCut) {
1173  fh2Electrons_invmass_allSameG_cut->Fill(paramSet.fMinv);
1174  fh2Electrons_angle_allSameG_cuts->Fill(paramSet.fAngle);
1175  }
1176 
1177 
1178  // study of different opening angle cuts
1179  fh2Electrons_angle_CUTcomparison->Fill(0); // no cuts applied
1180  if (paramSet.fAngle
1181  < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1182  fh2Electrons_angle_CUTcomparison->Fill(2);
1183  if (paramSet.fAngle
1184  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
1185  fh2Electrons_angle_CUTcomparison->Fill(4);
1186  if (paramSet.fAngle
1187  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
1188  fh2Electrons_angle_CUTcomparison->Fill(6);
1189  if (paramSet.fAngle
1190  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
1191  fh2Electrons_angle_CUTcomparison->Fill(8);
1192  if (paramSet.fAngle
1193  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
1194  fh2Electrons_angle_CUTcomparison->Fill(10);
1195  if (paramSet.fAngle
1196  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
1197  fh2Electrons_angle_CUTcomparison->Fill(12);
1198 
1199 
1200  fh2Electrons_angle_CUTcomparison_chi->Fill(0); // no cuts applied
1201  Double_t pt_e1 = fRecoTracklist_momentum[i].Perp();
1202  Double_t pt_e2 = fRecoTracklist_momentum[j].Perp();
1203  if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1204  && fRecoTracklist_chi[j]
1205  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
1206  fh2Electrons_angle_CUTcomparison_chi->Fill(2);
1207  }
1208  if (fRecoTracklist_chi[i]
1209  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
1210  && fRecoTracklist_chi[j]
1211  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
1212  fh2Electrons_angle_CUTcomparison_chi->Fill(4);
1213  }
1214  if (fRecoTracklist_chi[i]
1215  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
1216  && fRecoTracklist_chi[j]
1217  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
1218  fh2Electrons_angle_CUTcomparison_chi->Fill(6);
1219  }
1220  if (fRecoTracklist_chi[i]
1221  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
1222  && fRecoTracklist_chi[j]
1223  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
1224  fh2Electrons_angle_CUTcomparison_chi->Fill(8);
1225  }
1226  }
1227  }
1228 }
1229 
1230 
1231 void CbmAnaConversionPhotons2::AnalyseElectronsRecoWithRICH() {
1232  int electronnumber = fRecoTracklist_withRICH_gtIndex.size();
1233 
1234  cout << "CbmAnaConversionPhotons: array size in AnalyseElectronsReco(): "
1235  << electronnumber << endl;
1236  for (int i = 0; i < electronnumber - 1; i++) {
1237  for (int j = i + 1; j < electronnumber; j++) {
1238  if (fRecoTracklist_withRICH_mctrack[i]->GetPdgCode()
1239  + fRecoTracklist_withRICH_mctrack[j]->GetPdgCode()
1240  != 0)
1241  continue; // only 1 electron and 1 positron allowed
1242 
1243 
1244  CbmAnaConversionKinematicParams paramSet =
1245  CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(
1246  fRecoTracklist_withRICH_momentum[i],
1247  fRecoTracklist_withRICH_momentum[j]);
1248 
1249 
1250  fh2Electrons_angle_withRICH_all->Fill(paramSet.fAngle);
1251  fh2Electrons_invmass_withRICH_all->Fill(paramSet.fMinv);
1252  fh2Electrons_angleVSpt_withRICH_all->Fill(paramSet.fPt, paramSet.fAngle);
1253  fh2Electrons_invmassVSpt_withRICH_all->Fill(paramSet.fPt, paramSet.fMinv);
1254 
1255  Double_t pt_e1 = fRecoTracklist_withRICH_momentum[i].Perp();
1256  Double_t pt_e2 = fRecoTracklist_withRICH_momentum[j].Perp();
1257 
1258  if (fRecoTracklist_withRICH_chi[i]
1259  < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1260  && fRecoTracklist_withRICH_chi[j]
1261  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
1262  fh2Electrons_angle_withRICH_withChi_all->Fill(paramSet.fAngle);
1263  fh2Electrons_invmass_withRICH_withChi_all->Fill(paramSet.fMinv);
1264  fh2Electrons_angleVSpt_withRICH_withChi_all->Fill(paramSet.fPt,
1265  paramSet.fAngle);
1266  fh2Electrons_invmassVSpt_withRICH_withChi_all->Fill(paramSet.fPt,
1267  paramSet.fMinv);
1268  }
1269 
1270 
1271  TVector3 startvertex1;
1272  fRecoTracklist_withRICH_mctrack[i]->GetStartVertex(startvertex1);
1273  TVector3 startvertex2;
1274  fRecoTracklist_withRICH_mctrack[j]->GetStartVertex(startvertex2);
1275 
1276 
1277  if (startvertex1.Z() < 1 && startvertex2.Z() < 1) {
1278  fh2Electrons_angle_withRICH_fromTarget_all->Fill(paramSet.fAngle);
1279  fh2Electrons_invmass_withRICH_fromTarget_all->Fill(paramSet.fMinv);
1280  fh2Electrons_angleVSpt_withRICH_fromTarget_all->Fill(paramSet.fPt,
1281  paramSet.fAngle);
1282  fh2Electrons_invmassVSpt_withRICH_fromTarget_all->Fill(paramSet.fPt,
1283  paramSet.fMinv);
1284  }
1285 
1286  int motherID_i = fRecoTracklist_withRICH_mctrack[i]->GetMotherId();
1287  int motherID_j = fRecoTracklist_withRICH_mctrack[j]->GetMotherId();
1288 
1289 
1290  Bool_t electron_rich1 =
1291  CbmLitGlobalElectronId::GetInstance().IsRichElectron(
1292  fRecoTracklist_withRICH_gtIndex[i],
1293  fRecoTracklist_withRICH_momentum[i].Mag());
1294  Bool_t electron_rich2 =
1295  CbmLitGlobalElectronId::GetInstance().IsRichElectron(
1296  fRecoTracklist_withRICH_gtIndex[j],
1297  fRecoTracklist_withRICH_momentum[j].Mag());
1298 
1299 
1300  // then all false combinations are analysed, after that "continue" of loop, i.e. break
1301  if (motherID_i != motherID_j) {
1302  fh2Electrons_angle_withRICH_combBack->Fill(paramSet.fAngle);
1303  fh2Electrons_invmass_withRICH_combBack->Fill(paramSet.fMinv);
1304  fh2Electrons_angleVSpt_withRICH_combBack->Fill(paramSet.fPt,
1305  paramSet.fAngle);
1306  fh2Electrons_invmassVSpt_withRICH_combBack->Fill(paramSet.fPt,
1307  paramSet.fMinv);
1308 
1309 
1310  // study of different opening angle cuts
1311  fh2Electrons_angle_CUTcomparison_withRICH->Fill(1); // no cuts applied
1312  if (paramSet.fAngle
1313  < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1314  fh2Electrons_angle_CUTcomparison_withRICH->Fill(3);
1315  if (paramSet.fAngle
1316  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(
1317  paramSet.fPt))
1318  fh2Electrons_angle_CUTcomparison_withRICH->Fill(5);
1319  if (paramSet.fAngle
1320  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(
1321  paramSet.fPt))
1322  fh2Electrons_angle_CUTcomparison_withRICH->Fill(7);
1323  if (paramSet.fAngle
1324  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(
1325  paramSet.fPt))
1326  fh2Electrons_angle_CUTcomparison_withRICH->Fill(9);
1327  if (paramSet.fAngle
1328  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(
1329  paramSet.fPt))
1330  fh2Electrons_angle_CUTcomparison_withRICH->Fill(11);
1331  if (paramSet.fAngle
1332  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(
1333  paramSet.fPt))
1334  fh2Electrons_angle_CUTcomparison_withRICH->Fill(13);
1335 
1336 
1337  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(
1338  1); // no cuts applied
1339  //Double_t pt_e1 = fRecoTracklist_withRICH_momentum[i].Perp();
1340  //Double_t pt_e2 = fRecoTracklist_withRICH_momentum[j].Perp();
1341  if (fRecoTracklist_withRICH_chi[i]
1342  < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1343  && fRecoTracklist_withRICH_chi[j]
1344  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
1345  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(7);
1346 
1347  fh2Electrons_angle_withRICH_withChi_combBack->Fill(paramSet.fAngle);
1348  fh2Electrons_invmass_withRICH_withChi_combBack->Fill(paramSet.fMinv);
1349  fh2Electrons_angleVSpt_withRICH_withChi_combBack->Fill(
1350  paramSet.fPt, paramSet.fAngle);
1351  fh2Electrons_invmassVSpt_withRICH_withChi_combBack->Fill(
1352  paramSet.fPt, paramSet.fMinv);
1353 
1354  // study of different opening angle cuts
1355  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(
1356  1); // no cuts applied
1357  if (paramSet.fAngle
1358  < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1359  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(3);
1360  if (paramSet.fAngle
1361  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(
1362  paramSet.fPt))
1363  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(5);
1364  if (paramSet.fAngle
1365  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(
1366  paramSet.fPt))
1367  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(7);
1368  if (paramSet.fAngle
1369  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(
1370  paramSet.fPt))
1371  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(9);
1372  if (paramSet.fAngle
1373  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(
1374  paramSet.fPt))
1375  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(11);
1376  if (paramSet.fAngle
1377  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(
1378  paramSet.fPt))
1379  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(13);
1380  }
1381  if (fRecoTracklist_withRICH_chi[i]
1382  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
1383  && fRecoTracklist_withRICH_chi[j]
1384  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
1385  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(3);
1386  }
1387  if (fRecoTracklist_withRICH_chi[i]
1388  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
1389  && fRecoTracklist_withRICH_chi[j]
1390  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
1391  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(5);
1392  }
1393  if (fRecoTracklist_withRICH_chi[i]
1394  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
1395  && fRecoTracklist_withRICH_chi[j]
1396  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
1397  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(9);
1398  }
1399 
1400 
1401  if (startvertex1.Z() < 1 && startvertex2.Z() < 1) {
1402  fh2Electrons_angle_withRICH_fromTarget_combBack->Fill(
1403  paramSet.fAngle);
1404  fh2Electrons_invmass_withRICH_fromTarget_combBack->Fill(
1405  paramSet.fMinv);
1406  fh2Electrons_angleVSpt_withRICH_fromTarget_combBack->Fill(
1407  paramSet.fPt, paramSet.fAngle);
1408  fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack->Fill(
1409  paramSet.fPt, paramSet.fMinv);
1410  }
1411 
1412 
1413  Bool_t WithinChiCut =
1414  (fRecoTracklist_withRICH_chi[i]
1415  < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1416  && fRecoTracklist_withRICH_chi[j]
1417  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2));
1418  Bool_t WithinAngleCut =
1419  (paramSet.fAngle
1420  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(
1421  paramSet.fPt));
1422  Bool_t WithinMassCut = (paramSet.fMinv < 0.03);
1423  Bool_t WithElectronId = (electron_rich1 && electron_rich2);
1424 
1425  if (WithinChiCut && WithinAngleCut && WithinMassCut && WithElectronId) {
1426  vector<int> pair; // = {a, b};
1427  pair.push_back(i);
1428  pair.push_back(j);
1429  fVector_combinations.push_back(pair);
1430  }
1431 
1432  continue;
1433  }
1434 
1435 
1436  fh2Electrons_angle_withRICH_allSameG->Fill(paramSet.fAngle);
1437  fh2Electrons_invmass_withRICH_allSameG->Fill(paramSet.fMinv);
1438  fh2Electrons_angleVSpt_withRICH_allSameG->Fill(paramSet.fPt,
1439  paramSet.fAngle);
1440  fh2Electrons_invmassVSpt_withRICH_allSameG->Fill(paramSet.fPt,
1441  paramSet.fMinv);
1442 
1443  // study of different opening angle cuts
1444  fh2Electrons_angle_CUTcomparison_withRICH->Fill(0); // no cuts applied
1445  if (paramSet.fAngle
1446  < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1447  fh2Electrons_angle_CUTcomparison_withRICH->Fill(2);
1448  if (paramSet.fAngle
1449  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
1450  fh2Electrons_angle_CUTcomparison_withRICH->Fill(4);
1451  if (paramSet.fAngle
1452  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
1453  fh2Electrons_angle_CUTcomparison_withRICH->Fill(6);
1454  if (paramSet.fAngle
1455  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
1456  fh2Electrons_angle_CUTcomparison_withRICH->Fill(8);
1457  if (paramSet.fAngle
1458  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
1459  fh2Electrons_angle_CUTcomparison_withRICH->Fill(10);
1460  if (paramSet.fAngle
1461  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
1462  fh2Electrons_angle_CUTcomparison_withRICH->Fill(12);
1463 
1464 
1465  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(
1466  0); // no cuts applied
1467  //Double_t pt_e1 = fRecoTracklist_withRICH_momentum[i].Perp();
1468  //Double_t pt_e2 = fRecoTracklist_withRICH_momentum[j].Perp();
1469  if (fRecoTracklist_withRICH_chi[i]
1470  < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1471  && fRecoTracklist_withRICH_chi[j]
1472  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
1473  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(6);
1474 
1475  fh2Electrons_angle_withRICH_withChi_allSameG->Fill(paramSet.fAngle);
1476  fh2Electrons_invmass_withRICH_withChi_allSameG->Fill(paramSet.fMinv);
1477  fh2Electrons_angleVSpt_withRICH_withChi_allSameG->Fill(paramSet.fPt,
1478  paramSet.fAngle);
1479  fh2Electrons_invmassVSpt_withRICH_withChi_allSameG->Fill(
1480  paramSet.fPt, paramSet.fMinv);
1481 
1482  // study of different opening angle cuts
1483  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(
1484  0); // no cuts applied
1485  if (paramSet.fAngle
1486  < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1487  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(2);
1488  if (paramSet.fAngle
1489  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(
1490  paramSet.fPt))
1491  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(4);
1492  if (paramSet.fAngle
1493  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(
1494  paramSet.fPt))
1495  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(6);
1496  if (paramSet.fAngle
1497  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(
1498  paramSet.fPt))
1499  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(8);
1500  if (paramSet.fAngle
1501  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(
1502  paramSet.fPt))
1503  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(10);
1504  if (paramSet.fAngle
1505  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(
1506  paramSet.fPt))
1507  fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(12);
1508  }
1509  if (fRecoTracklist_withRICH_chi[i]
1510  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
1511  && fRecoTracklist_withRICH_chi[j]
1512  < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
1513  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(2);
1514  }
1515  if (fRecoTracklist_withRICH_chi[i]
1516  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
1517  && fRecoTracklist_withRICH_chi[j]
1518  < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
1519  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(4);
1520  }
1521  if (fRecoTracklist_withRICH_chi[i]
1522  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
1523  && fRecoTracklist_withRICH_chi[j]
1524  < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
1525  fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(8);
1526  }
1527 
1528 
1529  if (startvertex1.Z() < 1 && startvertex2.Z() < 1) {
1530  fh2Electrons_angle_withRICH_fromTarget_allSameG->Fill(paramSet.fAngle);
1531  fh2Electrons_invmass_withRICH_fromTarget_allSameG->Fill(paramSet.fMinv);
1532  fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG->Fill(
1533  paramSet.fPt, paramSet.fAngle);
1534  fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG->Fill(
1535  paramSet.fPt, paramSet.fMinv);
1536  }
1537 
1538 
1539  Bool_t WithinChiCut =
1540  (fRecoTracklist_withRICH_chi[i]
1541  < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1542  && fRecoTracklist_withRICH_chi[j]
1543  < CbmAnaConversionCutSettings::CalcChiCut(pt_e2));
1544  Bool_t WithinAngleCut =
1545  (paramSet.fAngle
1546  < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt));
1547  Bool_t WithinMassCut = (paramSet.fMinv < 0.03);
1548  Bool_t WithElectronId = (electron_rich1 && electron_rich2);
1549 
1550  if (WithinChiCut && WithinAngleCut && WithinMassCut && WithElectronId) {
1551  vector<int> pair; // = {a, b};
1552  pair.push_back(i);
1553  pair.push_back(j);
1554  fVector_combinations.push_back(pair);
1555  }
1556  }
1557  }
1558  EstimateFullRecoResults();
1559 }
1560 
1561 
1562 void CbmAnaConversionPhotons2::EstimateFullRecoResults() // with RICH
1563 {
1564  Int_t nof = fVector_combinations.size();
1565  if (nof < 2) return;
1566 
1567  for (int i = 0; i < nof - 1; i++) {
1568  for (int j = i + 1; j < nof; j++) {
1569  Int_t electron11 = fVector_combinations[i][0];
1570  Int_t electron12 = fVector_combinations[i][1];
1571  Int_t electron21 = fVector_combinations[j][0];
1572  Int_t electron22 = fVector_combinations[j][1];
1573 
1574  Int_t motherID_11 =
1575  fRecoTracklist_withRICH_mctrack[electron11]->GetMotherId();
1576  Int_t motherID_12 =
1577  fRecoTracklist_withRICH_mctrack[electron12]->GetMotherId();
1578  Int_t motherID_21 =
1579  fRecoTracklist_withRICH_mctrack[electron21]->GetMotherId();
1580  Int_t motherID_22 =
1581  fRecoTracklist_withRICH_mctrack[electron22]->GetMotherId();
1582 
1583  CbmMCTrack* mothertrack_11 = (CbmMCTrack*) fMcTracks->At(motherID_11);
1584  CbmMCTrack* mothertrack_12 = (CbmMCTrack*) fMcTracks->At(motherID_12);
1585  CbmMCTrack* mothertrack_21 = (CbmMCTrack*) fMcTracks->At(motherID_21);
1586  CbmMCTrack* mothertrack_22 = (CbmMCTrack*) fMcTracks->At(motherID_22);
1587 
1588  Int_t grandmotherID_11 = mothertrack_11->GetMotherId();
1589  Int_t grandmotherID_12 = mothertrack_12->GetMotherId();
1590  Int_t grandmotherID_21 = mothertrack_21->GetMotherId();
1591  Int_t grandmotherID_22 = mothertrack_22->GetMotherId();
1592 
1593  if (grandmotherID_11 == grandmotherID_12
1594  && grandmotherID_11 == grandmotherID_21
1595  && grandmotherID_11 == grandmotherID_22) {
1596  fh2Electrons_fullrecoCheck->Fill(1);
1597  } else {
1598  fh2Electrons_fullrecoCheck->Fill(2);
1599  }
1600  }
1601  }
1602 }
CbmRichPoint.h
CbmMCTrack::GetMotherId
Int_t GetMotherId() const
Definition: CbmMCTrack.h:71
CbmAnaConversionPhotons2::~CbmAnaConversionPhotons2
virtual ~CbmAnaConversionPhotons2()
Definition: CbmAnaConversionPhotons2.cxx:128
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition: CbmMatch.h:37
CbmAnaConversionKinematicParams::fPt
Double_t fPt
Definition: CbmAnaConversionKinematicParams.h:19
CbmAnaConversionPhotons2::fMcTracks
TClonesArray * fMcTracks
Definition: CbmAnaConversionPhotons2.h:48
CbmAnaConversionPhotons2.h
CbmAnaConversionPhotons2::fRichPoints
TClonesArray * fRichPoints
Definition: CbmAnaConversionPhotons2.h:45
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_combBack
TH2D * fh2Electrons_angleVSpt_combBack
Definition: CbmAnaConversionPhotons2.h:108
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_fromTarget_all
TH2D * fh2Electrons_invmassVSpt_withRICH_fromTarget_all
Definition: CbmAnaConversionPhotons2.h:166
CbmAnaConversionPhotons2::fh2Electrons_invmass_allSameG_cut
TH1D * fh2Electrons_invmass_allSameG_cut
Definition: CbmAnaConversionPhotons2.h:104
CbmAnaConversionPhotons2::fRichRingMatches
TClonesArray * fRichRingMatches
Definition: CbmAnaConversionPhotons2.h:47
CbmAnaConversionPhotons2::fh2Electrons_angle_allSameG
TH1D * fh2Electrons_angle_allSameG
Definition: CbmAnaConversionPhotons2.h:80
CbmMatch::GetNofLinks
Int_t GetNofLinks() const
Definition: CbmMatch.h:38
CbmAnaConversionPhotons2::fh2Electrons_angle_CUTcomparison_withRICH_chi
TH1I * fh2Electrons_angle_CUTcomparison_withRICH_chi
Definition: CbmAnaConversionPhotons2.h:92
CbmAnaConversionCutSettings::CalcOpeningAngleCut
static Double_t CalcOpeningAngleCut(Double_t pt)
Definition: CbmAnaConversionCutSettings.h:21
L1Field.h
CbmAnaConversionPhotons2::fRecoTracklist_chi
std::vector< Double_t > fRecoTracklist_chi
Definition: CbmAnaConversionPhotons2.h:67
CbmL1PFFitter
Definition: CbmL1PFFitter.h:31
CbmL1PFFitter::Fit
void Fit(std::vector< CbmStsTrack > &Tracks, std::vector< int > &pidHypo)
Definition: CbmL1PFFitter.cxx:81
CbmAnaConversionPhotons2::fPrimVertex
CbmVertex * fPrimVertex
Definition: CbmAnaConversionPhotons2.h:52
CbmAnaConversionPhotons2::fHistoList_photons_withRICH_withChi
std::vector< TH1 * > fHistoList_photons_withRICH_withChi
Definition: CbmAnaConversionPhotons2.h:60
CbmGlobalTrack::GetRichRingIndex
Int_t GetRichRingIndex() const
Definition: CbmGlobalTrack.h:41
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_allSameG
TH2D * fh2Electrons_angleVSpt_withRICH_allSameG
Definition: CbmAnaConversionPhotons2.h:126
CbmAnaConversionPhotons2::EstimateFullRecoResults
void EstimateFullRecoResults()
Definition: CbmAnaConversionPhotons2.cxx:1562
CbmMCTrack::GetPdgCode
Int_t GetPdgCode() const
Definition: CbmMCTrack.h:70
CbmAnaConversionKinematicParams::fAngle
Double_t fAngle
Definition: CbmAnaConversionKinematicParams.h:22
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmAnaConversionPhotons2::InitHistos
void InitHistos()
Definition: CbmAnaConversionPhotons2.cxx:186
CbmAnaConversionPhotons2::Finish
void Finish()
Definition: CbmAnaConversionPhotons2.cxx:901
CbmAnaConversionPhotons2::fStsTrackMatches
TClonesArray * fStsTrackMatches
Definition: CbmAnaConversionPhotons2.h:50
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_chi
std::vector< Double_t > fRecoTracklist_withRICH_chi
Definition: CbmAnaConversionPhotons2.h:73
CbmAnaConversionKinematicParams.h
CbmAnaConversionPhotons2::fh2Electrons_angle_CUTcomparison_withRICH_withChi
TH1I * fh2Electrons_angle_CUTcomparison_withRICH_withChi
Definition: CbmAnaConversionPhotons2.h:93
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_withChi_allSameG
TH2D * fh2Electrons_invmassVSpt_withRICH_withChi_allSameG
Definition: CbmAnaConversionPhotons2.h:153
CbmAnaConversionPhotons2::fh2Electrons_fullrecoCheck
TH1I * fh2Electrons_fullrecoCheck
Definition: CbmAnaConversionPhotons2.h:173
CbmAnaConversionPhotons2::fh2Electrons_angle_CUTcomparison_chi
TH1I * fh2Electrons_angle_CUTcomparison_chi
Definition: CbmAnaConversionPhotons2.h:89
CbmAnaConversionPhotons2::fh2Electrons_angle_combBack
TH1D * fh2Electrons_angle_combBack
Definition: CbmAnaConversionPhotons2.h:79
CbmGlobalTrack.h
CbmAnaConversionPhotons2::AnalyseElectronsRecoWithRICH
void AnalyseElectronsRecoWithRICH()
Definition: CbmAnaConversionPhotons2.cxx:1231
CbmAnaConversionPhotons2::fh2Electrons_invmass_combBack
TH1D * fh2Electrons_invmass_combBack
Definition: CbmAnaConversionPhotons2.h:98
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_all
TH2D * fh2Electrons_invmassVSpt_all
Definition: CbmAnaConversionPhotons2.h:112
CbmAnaConversionPhotons2::fGlobalTracks
TClonesArray * fGlobalTracks
Definition: CbmAnaConversionPhotons2.h:51
CbmRichRing.h
CbmAnaConversionPhotons2::AnalyseElectronsReco
void AnalyseElectronsReco()
Definition: CbmAnaConversionPhotons2.cxx:1057
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_all
TH2D * fh2Electrons_angleVSpt_withRICH_all
Definition: CbmAnaConversionPhotons2.h:124
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_all
TH1D * fh2Electrons_invmass_withRICH_all
Definition: CbmAnaConversionPhotons2.h:130
CbmAnaConversionPhotons2::fHistoList_photons_withRICH
std::vector< TH1 * > fHistoList_photons_withRICH
Definition: CbmAnaConversionPhotons2.h:58
CbmDrawHist.h
Helper functions for drawing 1D and 2D histograms and graphs.
CbmAnaConversionPhotons2::fRecoTracklist_momentum
std::vector< TVector3 > fRecoTracklist_momentum
Definition: CbmAnaConversionPhotons2.h:66
CbmAnaConversionPhotons2::fRecoTracklist_gtIndex
std::vector< Int_t > fRecoTracklist_gtIndex
Definition: CbmAnaConversionPhotons2.h:64
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_withChi_all
TH2D * fh2Electrons_angleVSpt_withRICH_withChi_all
Definition: CbmAnaConversionPhotons2.h:145
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_fromTarget_all
TH1D * fh2Electrons_angle_withRICH_fromTarget_all
Definition: CbmAnaConversionPhotons2.h:157
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG
TH2D * fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG
Definition: CbmAnaConversionPhotons2.h:168
CbmLitGlobalElectronId::IsRichElectron
Bool_t IsRichElectron(Int_t globalTrackIndex, Double_t momentum)
Identify electron in RICH detector.
Definition: CbmLitGlobalElectronId.cxx:52
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2
static Double_t CalcOpeningAngleCutAlt2(Double_t)
Definition: CbmAnaConversionCutSettings.h:36
CbmAnaConversionCutSettings.h
CbmAnaConversionPhotons2::fRecoTracklist_mcIndex
std::vector< Int_t > fRecoTracklist_mcIndex
Definition: CbmAnaConversionPhotons2.h:65
CbmAnaConversionPhotons2::fh2Electrons_invmass_all
TH1D * fh2Electrons_invmass_all
Definition: CbmAnaConversionPhotons2.h:97
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_momentum
std::vector< TVector3 > fRecoTracklist_withRICH_momentum
Definition: CbmAnaConversionPhotons2.h:72
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_combBack
TH2D * fh2Electrons_angleVSpt_withRICH_combBack
Definition: CbmAnaConversionPhotons2.h:125
CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco
static CbmAnaConversionKinematicParams KinematicParams_2particles_Reco(const TVector3 electron1, const TVector3 electron2)
Definition: CbmAnaConversionKinematicParams.h:128
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1
static Double_t CalcOpeningAngleCutAlt1(Double_t pt)
Definition: CbmAnaConversionCutSettings.h:29
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_withChi_allSameG
TH1D * fh2Electrons_angle_withRICH_withChi_allSameG
Definition: CbmAnaConversionPhotons2.h:144
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_withChi_all
TH1D * fh2Electrons_invmass_withRICH_withChi_all
Definition: CbmAnaConversionPhotons2.h:148
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_allSameG
TH2D * fh2Electrons_invmassVSpt_withRICH_allSameG
Definition: CbmAnaConversionPhotons2.h:138
CbmStsTrack.h
Data class for STS tracks.
CbmGlobalTrack::GetStsTrackIndex
Int_t GetStsTrackIndex() const
Definition: CbmGlobalTrack.h:38
CbmAnaConversionPhotons2::fh2Electrons_angle_combBack_cuts
TH1D * fh2Electrons_angle_combBack_cuts
Definition: CbmAnaConversionPhotons2.h:84
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_fromTarget_combBack
TH1D * fh2Electrons_angle_withRICH_fromTarget_combBack
Definition: CbmAnaConversionPhotons2.h:158
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_allSameG
TH1D * fh2Electrons_angle_withRICH_allSameG
Definition: CbmAnaConversionPhotons2.h:120
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_combBack
TH1D * fh2Electrons_angle_withRICH_combBack
Definition: CbmAnaConversionPhotons2.h:119
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_fromTarget_all
TH1D * fh2Electrons_invmass_withRICH_fromTarget_all
Definition: CbmAnaConversionPhotons2.h:163
CbmL1PFFitter::GetChiToVertex
void GetChiToVertex(std::vector< CbmStsTrack > &Tracks, std::vector< L1FieldRegion > &field, std::vector< float > &chiToVtx, CbmKFVertex &primVtx, float chiPrim=-1)
Definition: CbmL1PFFitter.cxx:403
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_fromTarget_allSameG
TH1D * fh2Electrons_angle_withRICH_fromTarget_allSameG
Definition: CbmAnaConversionPhotons2.h:159
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5
static Double_t CalcOpeningAngleCutAlt5(Double_t pt)
Definition: CbmAnaConversionCutSettings.h:58
CbmAnaConversionKinematicParams::fMinv
Double_t fMinv
Definition: CbmAnaConversionKinematicParams.h:21
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_allSameG
TH2D * fh2Electrons_invmassVSpt_allSameG
Definition: CbmAnaConversionPhotons2.h:114
CbmAnaConversionCutSettings::CalcChiCut
static Double_t CalcChiCut(Double_t pt)
Definition: CbmAnaConversionCutSettings.h:69
CbmTrackMatchNew.h
CbmVertex
Definition: CbmVertex.h:26
CbmAnaConversionPhotons2::fRichRings
TClonesArray * fRichRings
Definition: CbmAnaConversionPhotons2.h:46
CbmL1PFFitter.h
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_withChi_allSameG
TH2D * fh2Electrons_angleVSpt_withRICH_withChi_allSameG
Definition: CbmAnaConversionPhotons2.h:147
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_all
TH1D * fh2Electrons_angle_withRICH_all
Definition: CbmAnaConversionPhotons2.h:118
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_all
TH2D * fh2Electrons_angleVSpt_all
Definition: CbmAnaConversionPhotons2.h:107
CbmAnaConversionPhotons2::fh2Electrons_angle_CUTcomparison
TH1I * fh2Electrons_angle_CUTcomparison
Definition: CbmAnaConversionPhotons2.h:88
CbmAnaConversionPhotons2::fh2Electrons_angle_all
TH1D * fh2Electrons_angle_all
Definition: CbmAnaConversionPhotons2.h:78
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_mctrack
std::vector< CbmMCTrack * > fRecoTracklist_withRICH_mctrack
Definition: CbmAnaConversionPhotons2.h:74
CbmAnaConversionPhotons2::fRecoTracklist_mctrack
std::vector< CbmMCTrack * > fRecoTracklist_mctrack
Definition: CbmAnaConversionPhotons2.h:68
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_gtIndex
std::vector< Int_t > fRecoTracklist_withRICH_gtIndex
Definition: CbmAnaConversionPhotons2.h:70
CbmAnaConversionCutSettings::CalcChiCutAlt2
static Double_t CalcChiCutAlt2(Double_t pt)
Definition: CbmAnaConversionCutSettings.h:84
CbmAnaConversionPhotons2::fh2Electrons_angle_allSameG_cuts
TH1D * fh2Electrons_angle_allSameG_cuts
Definition: CbmAnaConversionPhotons2.h:85
CbmAnaConversionPhotons2::CbmAnaConversionPhotons2
CbmAnaConversionPhotons2()
Definition: CbmAnaConversionPhotons2.cxx:40
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_withChi_allSameG
TH1D * fh2Electrons_invmass_withRICH_withChi_allSameG
Definition: CbmAnaConversionPhotons2.h:150
CbmAnaConversionKinematicParams
Definition: CbmAnaConversionKinematicParams.h:16
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_allSameG
TH2D * fh2Electrons_angleVSpt_allSameG
Definition: CbmAnaConversionPhotons2.h:109
CbmAnaConversionPhotons2::fh2Electrons_angle_CUTcomparison_withRICH
TH1I * fh2Electrons_angle_CUTcomparison_withRICH
Definition: CbmAnaConversionPhotons2.h:91
CbmAnaConversionPhotons2::fHistoList_photons
std::vector< TH1 * > fHistoList_photons
Definition: CbmAnaConversionPhotons2.h:56
CbmAnaConversionPhotons2::Exec
void Exec()
Definition: CbmAnaConversionPhotons2.cxx:937
CbmGlobalTrack
Definition: CbmGlobalTrack.h:26
CbmAnaConversionPhotons2::Init
void Init()
Definition: CbmAnaConversionPhotons2.cxx:131
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_withChi_all
TH2D * fh2Electrons_invmassVSpt_withRICH_withChi_all
Definition: CbmAnaConversionPhotons2.h:151
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_combBack
TH2D * fh2Electrons_invmassVSpt_withRICH_combBack
Definition: CbmAnaConversionPhotons2.h:137
CbmAnaConversionPhotons2::fHistoList_photons_withRICH_fromTarget
std::vector< TH1 * > fHistoList_photons_withRICH_fromTarget
Definition: CbmAnaConversionPhotons2.h:62
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_withChi_all
TH1D * fh2Electrons_angle_withRICH_withChi_all
Definition: CbmAnaConversionPhotons2.h:142
CbmMCTrack.h
CbmAnaConversionPhotons2::fh2Electrons_invmass_allSameG
TH1D * fh2Electrons_invmass_allSameG
Definition: CbmAnaConversionPhotons2.h:99
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_all
TH2D * fh2Electrons_invmassVSpt_withRICH_all
Definition: CbmAnaConversionPhotons2.h:136
CbmMCTrack
Definition: CbmMCTrack.h:34
CbmAnaConversionPhotons2::fh2Electrons_invmass_combBack_cut
TH1D * fh2Electrons_invmass_combBack_cut
Definition: CbmAnaConversionPhotons2.h:103
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_allSameG
TH1D * fh2Electrons_invmass_withRICH_allSameG
Definition: CbmAnaConversionPhotons2.h:132
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG
TH2D * fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG
Definition: CbmAnaConversionPhotons2.h:162
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_withChi_combBack
TH2D * fh2Electrons_angleVSpt_withRICH_withChi_combBack
Definition: CbmAnaConversionPhotons2.h:146
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3
static Double_t CalcOpeningAngleCutAlt3(Double_t)
Definition: CbmAnaConversionCutSettings.h:43
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_fromTarget_combBack
TH1D * fh2Electrons_invmass_withRICH_fromTarget_combBack
Definition: CbmAnaConversionPhotons2.h:164
CbmAnaConversionPhotons2::fStsTracks
TClonesArray * fStsTracks
Definition: CbmAnaConversionPhotons2.h:49
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_combBack
TH1D * fh2Electrons_invmass_withRICH_combBack
Definition: CbmAnaConversionPhotons2.h:131
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4
static Double_t CalcOpeningAngleCutAlt4(Double_t pt)
Definition: CbmAnaConversionCutSettings.h:50
CbmAnaConversionPhotons2::fh2Electrons_angle_withRICH_withChi_combBack
TH1D * fh2Electrons_angle_withRICH_withChi_combBack
Definition: CbmAnaConversionPhotons2.h:143
CbmTrackMatchNew
Definition: CbmTrackMatchNew.h:19
CbmAnaConversionPhotons2::fh2Electrons_invmass_all_cut
TH1D * fh2Electrons_invmass_all_cut
Definition: CbmAnaConversionPhotons2.h:102
CbmLitGlobalElectronId.h
CbmAnaConversionPhotons2::fKFVertex
CbmKFVertex fKFVertex
Definition: CbmAnaConversionPhotons2.h:53
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_withChi_combBack
TH1D * fh2Electrons_invmass_withRICH_withChi_combBack
Definition: CbmAnaConversionPhotons2.h:149
CbmAnaConversionCutSettings::CalcChiCutAlt3
static Double_t CalcChiCutAlt3(Double_t)
Definition: CbmAnaConversionCutSettings.h:92
CbmStsTrack
Definition: CbmStsTrack.h:37
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_fromTarget_combBack
TH2D * fh2Electrons_angleVSpt_withRICH_fromTarget_combBack
Definition: CbmAnaConversionPhotons2.h:161
CbmLitGlobalElectronId::GetInstance
static CbmLitGlobalElectronId & GetInstance()
Definition: CbmLitGlobalElectronId.h:32
CbmAnaConversionPhotons2::fh2Electrons_invmass_withRICH_fromTarget_allSameG
TH1D * fh2Electrons_invmass_withRICH_fromTarget_allSameG
Definition: CbmAnaConversionPhotons2.h:165
CbmAnaConversionPhotons2::fh2Electrons_angleVSpt_withRICH_fromTarget_all
TH2D * fh2Electrons_angleVSpt_withRICH_fromTarget_all
Definition: CbmAnaConversionPhotons2.h:160
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_withChi_combBack
TH2D * fh2Electrons_invmassVSpt_withRICH_withChi_combBack
Definition: CbmAnaConversionPhotons2.h:152
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_mcIndex
std::vector< Int_t > fRecoTracklist_withRICH_mcIndex
Definition: CbmAnaConversionPhotons2.h:71
CbmAnaConversionPhotons2::fVector_combinations
std::vector< std::vector< int > > fVector_combinations
Definition: CbmAnaConversionPhotons2.h:172
CbmAnaConversionPhotons2::fh2Electrons_angle_all_cuts
TH1D * fh2Electrons_angle_all_cuts
Definition: CbmAnaConversionPhotons2.h:83
CbmKFVertex
Definition: CbmKFVertex.h:6
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_combBack
TH2D * fh2Electrons_invmassVSpt_combBack
Definition: CbmAnaConversionPhotons2.h:113
CbmAnaConversionPhotons2::fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack
TH2D * fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack
Definition: CbmAnaConversionPhotons2.h:167
CbmAnaConversionCutSettings::CalcChiCutAlt1
static Double_t CalcChiCutAlt1(Double_t)
Definition: CbmAnaConversionCutSettings.h:77