CbmRoot
Loading...
Searching...
No Matches
CbmAnaConversionPhotons2.cxx
Go to the documentation of this file.
1/* Copyright (C) 2015-2019 Fakultaet fuer Mathematik und Naturwissenschaften, Bergische Universitaet Wuppertal, Wuppertal
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Sascha Reinecke [committer], Florian Uhlig, Andrey Lebedev */
4
15#include "CbmAnaConversionPhotons2.h"
16
17#include "CbmDrawHist.h"
18#include "CbmGlobalTrack.h"
19#include "CbmL1PFFitter.h"
20#include "CbmMCTrack.h"
21#include "CbmRichPoint.h"
22#include "CbmRichRing.h"
23#include "CbmStsTrack.h"
24#include "CbmTrackMatchNew.h"
25
26#include "FairRootManager.h"
27#include <Logger.h>
28
29#include "CbmAnaConversionCutSettings.h"
30#include "CbmAnaConversionKinematicParams.h"
31#include "CbmLitGlobalElectronId.h"
32
33#include "TCanvas.h"
34
35#include <algorithm>
36#include <map>
37
38
39using namespace std;
40
41
42CbmAnaConversionPhotons2::CbmAnaConversionPhotons2()
43 : fRichPoints(NULL)
44 , fRichRings(NULL)
45 , fRichRingMatches(NULL)
46 , fMcTracks(NULL)
47 , fStsTracks(NULL)
48 , fStsTrackMatches(NULL)
49 , fGlobalTracks(NULL)
50 , fPrimVertex(NULL)
51 , fKFVertex()
52 , fHistoList_photons()
53 , fHistoList_photons_withRICH()
54 , fHistoList_photons_withRICH_withChi()
55 , fHistoList_photons_withRICH_fromTarget()
56 , fRecoTracklist_gtIndex()
57 , fRecoTracklist_mcIndex()
58 , fRecoTracklist_momentum()
59 , fRecoTracklist_chi()
60 , fRecoTracklist_mctrack()
61 , fRecoTracklist_withRICH_gtIndex()
62 , fRecoTracklist_withRICH_mcIndex()
63 , fRecoTracklist_withRICH_momentum()
64 , fRecoTracklist_withRICH_chi()
65 , fRecoTracklist_withRICH_mctrack()
66 , fh2Electrons_angle_all(NULL)
67 , fh2Electrons_angle_combBack(NULL)
68 , fh2Electrons_angle_allSameG(NULL)
69 , fh2Electrons_angle_all_cuts(NULL)
70 , fh2Electrons_angle_combBack_cuts(NULL)
71 , fh2Electrons_angle_allSameG_cuts(NULL)
72 , fh2Electrons_angle_CUTcomparison(NULL)
73 , fh2Electrons_angle_CUTcomparison_chi(NULL)
74 , fh2Electrons_angle_CUTcomparison_withRICH(NULL)
75 , fh2Electrons_angle_CUTcomparison_withRICH_chi(NULL)
76 , fh2Electrons_angle_CUTcomparison_withRICH_withChi(NULL)
77 , fh2Electrons_invmass_all(NULL)
78 , fh2Electrons_invmass_combBack(NULL)
79 , fh2Electrons_invmass_allSameG(NULL)
80 , fh2Electrons_invmass_all_cut(NULL)
81 , fh2Electrons_invmass_combBack_cut(NULL)
82 , fh2Electrons_invmass_allSameG_cut(NULL)
83 , fh2Electrons_angleVSpt_all(NULL)
84 , fh2Electrons_angleVSpt_combBack(NULL)
85 , fh2Electrons_angleVSpt_allSameG(NULL)
86 , fh2Electrons_invmassVSpt_all(NULL)
87 , fh2Electrons_invmassVSpt_combBack(NULL)
88 , fh2Electrons_invmassVSpt_allSameG(NULL)
89 , fh2Electrons_angle_withRICH_all(NULL)
90 , fh2Electrons_angle_withRICH_combBack(NULL)
91 , fh2Electrons_angle_withRICH_allSameG(NULL)
92 , fh2Electrons_angleVSpt_withRICH_all(NULL)
93 , fh2Electrons_angleVSpt_withRICH_combBack(NULL)
94 , fh2Electrons_angleVSpt_withRICH_allSameG(NULL)
95 , fh2Electrons_invmass_withRICH_all(NULL)
96 , fh2Electrons_invmass_withRICH_combBack(NULL)
97 , fh2Electrons_invmass_withRICH_allSameG(NULL)
98 , fh2Electrons_invmassVSpt_withRICH_all(NULL)
99 , fh2Electrons_invmassVSpt_withRICH_combBack(NULL)
100 , fh2Electrons_invmassVSpt_withRICH_allSameG(NULL)
101 , fh2Electrons_angle_withRICH_withChi_all(NULL)
102 , fh2Electrons_angle_withRICH_withChi_combBack(NULL)
103 , fh2Electrons_angle_withRICH_withChi_allSameG(NULL)
104 , fh2Electrons_angleVSpt_withRICH_withChi_all(NULL)
105 , fh2Electrons_angleVSpt_withRICH_withChi_combBack(NULL)
106 , fh2Electrons_angleVSpt_withRICH_withChi_allSameG(NULL)
107 , fh2Electrons_invmass_withRICH_withChi_all(NULL)
108 , fh2Electrons_invmass_withRICH_withChi_combBack(NULL)
109 , fh2Electrons_invmass_withRICH_withChi_allSameG(NULL)
110 , fh2Electrons_invmassVSpt_withRICH_withChi_all(NULL)
111 , fh2Electrons_invmassVSpt_withRICH_withChi_combBack(NULL)
112 , fh2Electrons_invmassVSpt_withRICH_withChi_allSameG(NULL)
113 , fh2Electrons_angle_withRICH_fromTarget_all(NULL)
114 , fh2Electrons_angle_withRICH_fromTarget_combBack(NULL)
115 , fh2Electrons_angle_withRICH_fromTarget_allSameG(NULL)
116 , fh2Electrons_angleVSpt_withRICH_fromTarget_all(NULL)
117 , fh2Electrons_angleVSpt_withRICH_fromTarget_combBack(NULL)
118 , fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG(NULL)
119 , fh2Electrons_invmass_withRICH_fromTarget_all(NULL)
120 , fh2Electrons_invmass_withRICH_fromTarget_combBack(NULL)
121 , fh2Electrons_invmass_withRICH_fromTarget_allSameG(NULL)
122 , fh2Electrons_invmassVSpt_withRICH_fromTarget_all(NULL)
123 , fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack(NULL)
124 , fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG(NULL)
125 , fVector_combinations()
126 , fh2Electrons_fullrecoCheck(NULL)
127 , timer()
128 , fTime(0.)
129{
130}
131
132CbmAnaConversionPhotons2::~CbmAnaConversionPhotons2() {}
133
134
135void CbmAnaConversionPhotons2::Init()
136{
137 FairRootManager* ioman = FairRootManager::Instance();
138 if (NULL == ioman) { Fatal("CbmAnaConversion::Init", "RootManager not instantised!"); }
139
140 fRichPoints = (TClonesArray*) ioman->GetObject("RichPoint");
141 if (NULL == fRichPoints) { Fatal("CbmAnaConversion::Init", "No RichPoint array!"); }
142
143 fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
144 if (NULL == fMcTracks) { Fatal("CbmAnaConversion::Init", "No MCTrack array!"); }
145
146 fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
147 if (NULL == fStsTracks) { Fatal("CbmAnaConversion::Init", "No StsTrack array!"); }
148
149 fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
150 if (NULL == fStsTrackMatches) { Fatal("CbmAnaConversion::Init", "No StsTrackMatch array!"); }
151
152 fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
153 if (NULL == fGlobalTracks) { Fatal("CbmAnaConversion::Init", "No GlobalTrack array!"); }
154
155 // Get pointer to PrimaryVertex object from IOManager if it exists
156 // The old name for the object is "PrimaryVertex" the new one
157 // "PrimaryVertex." Check first for the new name
158 fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex."));
159 if (nullptr == fPrimVertex) { fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex")); }
160 if (nullptr == fPrimVertex) { LOG(fatal) << "No PrimaryVertex array!"; }
161
162 fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
163 if (NULL == fRichRings) { Fatal("CbmAnaConversion::Init", "No RichRing array!"); }
164
165 fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
166 if (NULL == fRichRingMatches) { Fatal("CbmAnaConversion::Init", "No RichRingMatch array!"); }
167
168
169 InitHistos();
170}
171
172
173void CbmAnaConversionPhotons2::InitHistos()
174{
175 fHistoList_photons.clear();
176 fHistoList_photons_withRICH.clear();
177 fHistoList_photons_withRICH_withChi.clear();
178 fHistoList_photons_withRICH_fromTarget.clear();
179
180
181 // opening angles for all photon-energies (RECO)
182 fh2Electrons_angle_all =
183 new TH1D("fh2Electrons_angle_all", "fh2Electrons_angle_all; opening angle [deg]; #", 2001, -0.05, 200.05);
184 fh2Electrons_angle_combBack =
185 new TH1D("fh2Electrons_angle_combBack", "fh2Electrons_angle_combBack; opening angle [deg]; #", 2001, -0.05, 200.05);
186 fh2Electrons_angle_allSameG =
187 new TH1D("fh2Electrons_angle_allSameG", "fh2Electrons_angle_allSameG; opening angle [deg]; #", 1001, -0.05, 100.05);
188 fHistoList_photons.push_back(fh2Electrons_angle_all);
189 fHistoList_photons.push_back(fh2Electrons_angle_combBack);
190 fHistoList_photons.push_back(fh2Electrons_angle_allSameG);
191
192
193 // histogram for comparison of different opening angle cuts and their influence on signal and background amounts
194 fh2Electrons_angle_CUTcomparison =
195 new TH1I("fh2Electrons_angle_CUTcomparison", "fh2Electrons_angle_CUTcomparison; ; #", 14, 0., 14.);
196 fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison);
197 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(1, "true, no cut");
198 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(2, "false, no cut");
199 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(3, "true, cut1");
200 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(4, "false, cut1");
201 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(5, "true, cut2");
202 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(6, "false, cut2");
203 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(7, "true, cut3");
204 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(8, "false, cut3");
205 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(9, "true, cut4");
206 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(10, "false, cut4");
207 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(11, "true, cut5");
208 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(12, "false, cut5");
209 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(13, "true, cut6");
210 fh2Electrons_angle_CUTcomparison->GetXaxis()->SetBinLabel(14, "false, cut6");
211
212
213 fh2Electrons_angle_CUTcomparison_chi =
214 new TH1I("fh2Electrons_angle_CUTcomparison_chi", "fh2Electrons_angle_CUTcomparison_chi; ; #", 10, 0., 10.);
215 fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_chi);
216 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(1, "true, no cut");
217 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(2, "false, no cut");
218 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(3, "true, cut1");
219 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(4, "false, cut1");
220 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(5, "true, cut2");
221 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(6, "false, cut2");
222 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(7, "true, cut3");
223 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(8, "false, cut3");
224 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(9, "true, cut4");
225 fh2Electrons_angle_CUTcomparison_chi->GetXaxis()->SetBinLabel(10, "false, cut4");
226
227
228 fh2Electrons_angle_CUTcomparison_withRICH = new TH1I("fh2Electrons_angle_CUTcomparison_withRICH",
229 "fh2Electrons_angle_CUTcomparison_withRICH; ; #", 14, 0., 14.);
230 fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_withRICH);
231 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(1, "true, no cut");
232 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(2, "false, no cut");
233 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(3, "true, cut1");
234 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(4, "false, cut1");
235 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(5, "true, cut2");
236 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(6, "false, cut2");
237 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(7, "true, cut3");
238 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(8, "false, cut3");
239 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(9, "true, cut4");
240 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(10, "false, cut4");
241 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(11, "true, cut5");
242 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(12, "false, cut5");
243 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(13, "true, cut6");
244 fh2Electrons_angle_CUTcomparison_withRICH->GetXaxis()->SetBinLabel(14, "false, cut6");
245
246
247 fh2Electrons_angle_CUTcomparison_withRICH_chi = new TH1I(
248 "fh2Electrons_angle_CUTcomparison_withRICH_chi", "fh2Electrons_angle_CUTcomparison_withRICH_chi; ; #", 10, 0., 10.);
249 fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_withRICH_chi);
250 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(1, "true, no cut");
251 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(2, "false, no cut");
252 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(3, "true, cut1");
253 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(4, "false, cut1");
254 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(5, "true, cut2");
255 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(6, "false, cut2");
256 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(7, "true, cut3");
257 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(8, "false, cut3");
258 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(9, "true, cut4");
259 fh2Electrons_angle_CUTcomparison_withRICH_chi->GetXaxis()->SetBinLabel(10, "false, cut4");
260
261
262 fh2Electrons_angle_CUTcomparison_withRICH_withChi =
263 new TH1I("fh2Electrons_angle_CUTcomparison_withRICH_withChi",
264 "fh2Electrons_angle_CUTcomparison_withRICH_withChi; ; #", 14, 0., 14.);
265 fHistoList_photons.push_back(fh2Electrons_angle_CUTcomparison_withRICH_withChi);
266 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(1, "true, no cut");
267 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(2, "false, no cut");
268 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(3, "true, cut1");
269 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(4, "false, cut1");
270 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(5, "true, cut2");
271 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(6, "false, cut2");
272 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(7, "true, cut3");
273 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(8, "false, cut3");
274 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(9, "true, cut4");
275 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(10, "false, cut4");
276 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(11, "true, cut5");
277 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(12, "false, cut5");
278 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(13, "true, cut6");
279 fh2Electrons_angle_CUTcomparison_withRICH_withChi->GetXaxis()->SetBinLabel(14, "false, cut6");
280
281
282 // opening angles for all photon-energies (RECO) with application of opening angle cuts
283 fh2Electrons_angle_all_cuts =
284 new TH1D("fh2Electrons_angle_all_cuts", "fh2Electrons_angle_all_cuts; opening angle [deg]; #", 101, -0.05, 10.05);
285 fh2Electrons_angle_combBack_cuts = new TH1D(
286 "fh2Electrons_angle_combBack_cuts", "fh2Electrons_angle_combBack_cuts; opening angle [deg]; #", 101, -0.05, 10.05);
287 fh2Electrons_angle_allSameG_cuts = new TH1D(
288 "fh2Electrons_angle_allSameG_cuts", "fh2Electrons_angle_allSameG_cuts; opening angle [deg]; #", 101, -0.05, 10.05);
289 fHistoList_photons.push_back(fh2Electrons_angle_all_cuts);
290 fHistoList_photons.push_back(fh2Electrons_angle_combBack_cuts);
291 fHistoList_photons.push_back(fh2Electrons_angle_allSameG_cuts);
292
293
294 fh2Electrons_invmass_all =
295 new TH1D("fh2Electrons_invmass_all", "fh2Electrons_invmass_all; invmass [GeV/c^2]; #", 5000, 0., 5.);
296 fh2Electrons_invmass_combBack =
297 new TH1D("fh2Electrons_invmass_combBack", "fh2Electrons_invmass_combBack; invmass [GeV/c^2]; #", 5000, 0., 5.);
298 fh2Electrons_invmass_allSameG =
299 new TH1D("fh2Electrons_invmass_allSameG", "fh2Electrons_invmass_allSameG; invmass [GeV/c^2]; #", 5000, 0., 5);
300 fHistoList_photons.push_back(fh2Electrons_invmass_all);
301 fHistoList_photons.push_back(fh2Electrons_invmass_combBack);
302 fHistoList_photons.push_back(fh2Electrons_invmass_allSameG);
303
304 fh2Electrons_invmass_all_cut =
305 new TH1D("fh2Electrons_invmass_all_cut", "fh2Electrons_invmass_all_cut; invmass [GeV/c^2]; #", 5000, 0., 5.);
306 fh2Electrons_invmass_combBack_cut = new TH1D("fh2Electrons_invmass_combBack_cut",
307 "fh2Electrons_invmass_combBack_cut; invmass [GeV/c^2]; #", 5000, 0., 5.);
308 fh2Electrons_invmass_allSameG_cut = new TH1D("fh2Electrons_invmass_allSameG_cut",
309 "fh2Electrons_invmass_allSameG_cut; invmass [GeV/c^2]; #", 5000, 0., 5);
310 fHistoList_photons.push_back(fh2Electrons_invmass_all_cut);
311 fHistoList_photons.push_back(fh2Electrons_invmass_combBack_cut);
312 fHistoList_photons.push_back(fh2Electrons_invmass_allSameG_cut);
313
314
315 // opening angle vs pt (reco)
316 fh2Electrons_angleVSpt_all =
317 new TH2D("fh2Electrons_angleVSpt_all", "fh2Electrons_angleVSpt_all;pt [GeV/c];opening angle [deg]", 500, 0., 5.,
318 400, 0., 20.);
319 fh2Electrons_angleVSpt_combBack =
320 new TH2D("fh2Electrons_angleVSpt_combBack", "fh2Electrons_angleVSpt_combBack;pt [GeV/c];opening angle [deg]", 500,
321 0., 5., 400, 0., 20.);
322 fh2Electrons_angleVSpt_allSameG =
323 new TH2D("fh2Electrons_angleVSpt_allSameG", "fh2Electrons_angleVSpt_allSameG;pt [GeV/c];opening angle [deg]", 500,
324 0., 5., 400, 0., 20.);
325 fHistoList_photons.push_back(fh2Electrons_angleVSpt_all);
326 fHistoList_photons.push_back(fh2Electrons_angleVSpt_combBack);
327 fHistoList_photons.push_back(fh2Electrons_angleVSpt_allSameG);
328
329
330 // invariant mass vs pt (reco)
331 fh2Electrons_invmassVSpt_all = new TH2D(
332 "fh2Electrons_invmassVSpt_all", "fh2Electrons_invmassVSpt_all;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
333 fh2Electrons_invmassVSpt_combBack =
334 new TH2D("fh2Electrons_invmassVSpt_combBack", "fh2Electrons_invmassVSpt_combBack;pt [GeV/c];invmass [GeV]", 500, 0.,
335 5., 5000, 0., 5.);
336 fh2Electrons_invmassVSpt_allSameG =
337 new TH2D("fh2Electrons_invmassVSpt_allSameG", "fh2Electrons_invmassVSpt_allSameG;pt [GeV/c];invmass [GeV]", 500, 0.,
338 5., 5000, 0., 5.);
339 fHistoList_photons.push_back(fh2Electrons_invmassVSpt_all);
340 fHistoList_photons.push_back(fh2Electrons_invmassVSpt_combBack);
341 fHistoList_photons.push_back(fh2Electrons_invmassVSpt_allSameG);
342
343
344 // ##############################################################################
345 // ##############################################################################
346 // ##############################################################################
347
348
349 // opening angles for all photon-energies (RECO) with RICH
350 fh2Electrons_angle_withRICH_all = new TH1D(
351 "fh2Electrons_angle_withRICH_all", "fh2Electrons_angle_withRICH_all; opening angle [deg]; #", 2001, -0.05, 200.05);
352 fh2Electrons_angle_withRICH_combBack =
353 new TH1D("fh2Electrons_angle_withRICH_combBack", "fh2Electrons_angle_withRICH_combBack; opening angle [deg]; #",
354 2001, -0.05, 200.05);
355 fh2Electrons_angle_withRICH_allSameG =
356 new TH1D("fh2Electrons_angle_withRICH_allSameG", "fh2Electrons_angle_withRICH_allSameG; opening angle [deg]; #",
357 1001, -0.05, 100.05);
358 fHistoList_photons_withRICH.push_back(fh2Electrons_angle_withRICH_all);
359 fHistoList_photons_withRICH.push_back(fh2Electrons_angle_withRICH_combBack);
360 fHistoList_photons_withRICH.push_back(fh2Electrons_angle_withRICH_allSameG);
361
362 // opening angle vs pt (reco), with RICH
363 fh2Electrons_angleVSpt_withRICH_all =
364 new TH2D("fh2Electrons_angleVSpt_withRICH_all",
365 "fh2Electrons_angleVSpt_withRICH_all;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
366 fh2Electrons_angleVSpt_withRICH_combBack =
367 new TH2D("fh2Electrons_angleVSpt_withRICH_combBack",
368 "fh2Electrons_angleVSpt_withRICH_combBack;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
369 fh2Electrons_angleVSpt_withRICH_allSameG =
370 new TH2D("fh2Electrons_angleVSpt_withRICH_allSameG",
371 "fh2Electrons_angleVSpt_withRICH_allSameG;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
372 fHistoList_photons_withRICH.push_back(fh2Electrons_angleVSpt_withRICH_all);
373 fHistoList_photons_withRICH.push_back(fh2Electrons_angleVSpt_withRICH_combBack);
374 fHistoList_photons_withRICH.push_back(fh2Electrons_angleVSpt_withRICH_allSameG);
375
376 // invmass for all photon-energies (RECO) with RICH
377 fh2Electrons_invmass_withRICH_all = new TH1D("fh2Electrons_invmass_withRICH_all",
378 "fh2Electrons_invmass_withRICH_all; invmass [GeV/c^2]; #", 5000, 0., 5.);
379 fh2Electrons_invmass_withRICH_combBack =
380 new TH1D("fh2Electrons_invmass_withRICH_combBack", "fh2Electrons_invmass_withRICH_combBack; invmass [GeV/c^2]; #",
381 5000, 0., 5.);
382 fh2Electrons_invmass_withRICH_allSameG =
383 new TH1D("fh2Electrons_invmass_withRICH_allSameG", "fh2Electrons_invmass_withRICH_allSameG; invmass [GeV/c^2]; #",
384 5000, 0., 5.);
385 fHistoList_photons_withRICH.push_back(fh2Electrons_invmass_withRICH_all);
386 fHistoList_photons_withRICH.push_back(fh2Electrons_invmass_withRICH_combBack);
387 fHistoList_photons_withRICH.push_back(fh2Electrons_invmass_withRICH_allSameG);
388
389 // invmass vs pt (reco), with RICH
390 fh2Electrons_invmassVSpt_withRICH_all =
391 new TH2D("fh2Electrons_invmassVSpt_withRICH_all", "fh2Electrons_invmassVSpt_withRICH_all;pt [GeV/c];invmass [GeV]",
392 500, 0., 5., 5000, 0., 5.);
393 fh2Electrons_invmassVSpt_withRICH_combBack =
394 new TH2D("fh2Electrons_invmassVSpt_withRICH_combBack",
395 "fh2Electrons_invmassVSpt_withRICH_combBack;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
396 fh2Electrons_invmassVSpt_withRICH_allSameG =
397 new TH2D("fh2Electrons_invmassVSpt_withRICH_allSameG",
398 "fh2Electrons_invmassVSpt_withRICH_allSameG;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
399 fHistoList_photons_withRICH.push_back(fh2Electrons_invmassVSpt_withRICH_all);
400 fHistoList_photons_withRICH.push_back(fh2Electrons_invmassVSpt_withRICH_combBack);
401 fHistoList_photons_withRICH.push_back(fh2Electrons_invmassVSpt_withRICH_allSameG);
402
403
404 fh2Electrons_fullrecoCheck = new TH1I("fh2Electrons_fullrecoCheck", "fh2Electrons_fullrecoCheck;; #", 5, 0., 5.);
405 fHistoList_photons.push_back(fh2Electrons_fullrecoCheck);
406
407
408 // ##############################################################################
409 // ##############################################################################
410 // ##############################################################################
411
412
413 // opening angles for all photon-energies (RECO) with RICH, with standard chi-cut of refitted momentum
414 fh2Electrons_angle_withRICH_withChi_all =
415 new TH1D("fh2Electrons_angle_withRICH_withChi_all",
416 "fh2Electrons_angle_withRICH_withChi_all; opening angle [deg]; #", 2001, -0.05, 200.05);
417 fh2Electrons_angle_withRICH_withChi_combBack =
418 new TH1D("fh2Electrons_angle_withRICH_withChi_combBack",
419 "fh2Electrons_angle_withRICH_withChi_combBack; opening angle [deg]; #", 2001, -0.05, 200.05);
420 fh2Electrons_angle_withRICH_withChi_allSameG =
421 new TH1D("fh2Electrons_angle_withRICH_withChi_allSameG",
422 "fh2Electrons_angle_withRICH_withChi_allSameG; opening angle [deg]; #", 1001, -0.05, 100.05);
423 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_angle_withRICH_withChi_all);
424 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_angle_withRICH_withChi_combBack);
425 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_angle_withRICH_withChi_allSameG);
426
427 // opening angle vs pt (reco), with RICH
428 fh2Electrons_angleVSpt_withRICH_withChi_all =
429 new TH2D("fh2Electrons_angleVSpt_withRICH_withChi_all",
430 "fh2Electrons_angleVSpt_withRICH_withChi_all;pt [GeV/c];opening "
431 "angle [deg]",
432 500, 0., 5., 400, 0., 20.);
433 fh2Electrons_angleVSpt_withRICH_withChi_combBack = new TH2D("fh2Electrons_angleVSpt_withRICH_withChi_combBack",
434 "fh2Electrons_angleVSpt_withRICH_withChi_combBack;pt "
435 "[GeV/c];opening angle [deg]",
436 500, 0., 5., 400, 0., 20.);
437 fh2Electrons_angleVSpt_withRICH_withChi_allSameG = new TH2D("fh2Electrons_angleVSpt_withRICH_withChi_allSameG",
438 "fh2Electrons_angleVSpt_withRICH_withChi_allSameG;pt "
439 "[GeV/c];opening angle [deg]",
440 500, 0., 5., 400, 0., 20.);
441 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_angleVSpt_withRICH_withChi_all);
442 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_angleVSpt_withRICH_withChi_combBack);
443 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_angleVSpt_withRICH_withChi_allSameG);
444
445 // invmass for all photon-energies (RECO) with RICH
446 fh2Electrons_invmass_withRICH_withChi_all =
447 new TH1D("fh2Electrons_invmass_withRICH_withChi_all",
448 "fh2Electrons_invmass_withRICH_withChi_all; invmass [GeV/c^2]; #", 5000, 0., 5.);
449 fh2Electrons_invmass_withRICH_withChi_combBack =
450 new TH1D("fh2Electrons_invmass_withRICH_withChi_combBack",
451 "fh2Electrons_invmass_withRICH_withChi_combBack; invmass [GeV/c^2]; #", 5000, 0., 5.);
452 fh2Electrons_invmass_withRICH_withChi_allSameG =
453 new TH1D("fh2Electrons_invmass_withRICH_withChi_allSameG",
454 "fh2Electrons_invmass_withRICH_withChi_allSameG; invmass [GeV/c^2]; #", 5000, 0., 5.);
455 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_invmass_withRICH_withChi_all);
456 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_invmass_withRICH_withChi_combBack);
457 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_invmass_withRICH_withChi_allSameG);
458
459 // invmass vs pt (reco), with RICH
460 fh2Electrons_invmassVSpt_withRICH_withChi_all =
461 new TH2D("fh2Electrons_invmassVSpt_withRICH_withChi_all",
462 "fh2Electrons_invmassVSpt_withRICH_withChi_all;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
463 fh2Electrons_invmassVSpt_withRICH_withChi_combBack = new TH2D("fh2Electrons_invmassVSpt_withRICH_withChi_combBack",
464 "fh2Electrons_invmassVSpt_withRICH_withChi_combBack;pt "
465 "[GeV/c];invmass [GeV]",
466 500, 0., 5., 5000, 0., 5.);
467 fh2Electrons_invmassVSpt_withRICH_withChi_allSameG = new TH2D("fh2Electrons_invmassVSpt_withRICH_withChi_allSameG",
468 "fh2Electrons_invmassVSpt_withRICH_withChi_allSameG;pt "
469 "[GeV/c];invmass [GeV]",
470 500, 0., 5., 5000, 0., 5.);
471 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_invmassVSpt_withRICH_withChi_all);
472 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_invmassVSpt_withRICH_withChi_combBack);
473 fHistoList_photons_withRICH_withChi.push_back(fh2Electrons_invmassVSpt_withRICH_withChi_allSameG);
474
475
476 // ##############################################################################
477 // ##############################################################################
478 // ##############################################################################
479
480
481 // opening angles for all photon-energies (RECO) with RICH, from target (z>1, selection from MC-true)
482 fh2Electrons_angle_withRICH_fromTarget_all =
483 new TH1D("fh2Electrons_angle_withRICH_fromTarget_all",
484 "fh2Electrons_angle_withRICH_fromTarget_all; opening angle [deg]; #", 2001, -0.05, 200.05);
485 fh2Electrons_angle_withRICH_fromTarget_combBack =
486 new TH1D("fh2Electrons_angle_withRICH_fromTarget_combBack",
487 "fh2Electrons_angle_withRICH_fromTarget_combBack; opening angle [deg]; #", 2001, -0.05, 200.05);
488 fh2Electrons_angle_withRICH_fromTarget_allSameG =
489 new TH1D("fh2Electrons_angle_withRICH_fromTarget_allSameG",
490 "fh2Electrons_angle_withRICH_fromTarget_allSameG; opening angle [deg]; #", 1001, -0.05, 100.05);
491 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_angle_withRICH_fromTarget_all);
492 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_angle_withRICH_fromTarget_combBack);
493 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_angle_withRICH_fromTarget_allSameG);
494
495 // opening angle vs pt (reco), with RICH
496 fh2Electrons_angleVSpt_withRICH_fromTarget_all = new TH2D("fh2Electrons_angleVSpt_withRICH_fromTarget_all",
497 "fh2Electrons_angleVSpt_withRICH_fromTarget_all;pt "
498 "[GeV/c];opening angle [deg]",
499 500, 0., 5., 400, 0., 20.);
500 fh2Electrons_angleVSpt_withRICH_fromTarget_combBack =
501 new TH2D("fh2Electrons_angleVSpt_withRICH_fromTarget_combBack",
502 "fh2Electrons_angleVSpt_withRICH_fromTarget_combBack;pt "
503 "[GeV/c];opening angle [deg]",
504 500, 0., 5., 400, 0., 20.);
505 fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG =
506 new TH2D("fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG",
507 "fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG;pt "
508 "[GeV/c];opening angle [deg]",
509 500, 0., 5., 400, 0., 20.);
510 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_angleVSpt_withRICH_fromTarget_all);
511 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_angleVSpt_withRICH_fromTarget_combBack);
512 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG);
513
514 // invmass for all photon-energies (RECO) with RICH
515 fh2Electrons_invmass_withRICH_fromTarget_all =
516 new TH1D("fh2Electrons_invmass_withRICH_fromTarget_all",
517 "fh2Electrons_invmass_withRICH_fromTarget_all; invmass [GeV/c^2]; #", 5000, 0., 5.);
518 fh2Electrons_invmass_withRICH_fromTarget_combBack =
519 new TH1D("fh2Electrons_invmass_withRICH_fromTarget_combBack",
520 "fh2Electrons_invmass_withRICH_fromTarget_combBack; invmass [GeV/c^2]; #", 5000, 0., 5.);
521 fh2Electrons_invmass_withRICH_fromTarget_allSameG =
522 new TH1D("fh2Electrons_invmass_withRICH_fromTarget_allSameG",
523 "fh2Electrons_invmass_withRICH_fromTarget_allSameG; invmass [GeV/c^2]; #", 5000, 0., 5.);
524 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_invmass_withRICH_fromTarget_all);
525 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_invmass_withRICH_fromTarget_combBack);
526 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_invmass_withRICH_fromTarget_allSameG);
527
528 // invmass vs pt (reco), with RICH
529 fh2Electrons_invmassVSpt_withRICH_fromTarget_all =
530 new TH2D("fh2Electrons_invmassVSpt_withRICH_fromTarget_all",
531 "fh2Electrons_invmassVSpt_withRICH_fromTarget_all;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
532 fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack =
533 new TH2D("fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack",
534 "fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack;pt "
535 "[GeV/c];invmass [GeV]",
536 500, 0., 5., 5000, 0., 5.);
537 fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG =
538 new TH2D("fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG",
539 "fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG;pt "
540 "[GeV/c];invmass [GeV]",
541 500, 0., 5., 5000, 0., 5.);
542 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_invmassVSpt_withRICH_fromTarget_all);
543 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack);
544 fHistoList_photons_withRICH_fromTarget.push_back(fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG);
545}
546
547
548void CbmAnaConversionPhotons2::Finish()
549{
550 //gDirectory->cd("analysis-conversion");
551 gDirectory->mkdir("Photons2");
552 gDirectory->cd("Photons2");
553
554 gDirectory->mkdir("With RICH");
555 gDirectory->cd("With RICH");
556
557 for (UInt_t i = 0; i < fHistoList_photons_withRICH.size(); i++) {
558 fHistoList_photons_withRICH[i]->Write();
559 }
560 gDirectory->cd("..");
561
562 gDirectory->mkdir("With RICH, with Chi");
563 gDirectory->cd("With RICH, with Chi");
564
565 for (UInt_t i = 0; i < fHistoList_photons_withRICH_withChi.size(); i++) {
566 fHistoList_photons_withRICH_withChi[i]->Write();
567 }
568 gDirectory->cd("..");
569
570 gDirectory->mkdir("With RICH, from target");
571 gDirectory->cd("With RICH, from target");
572
573 for (UInt_t i = 0; i < fHistoList_photons_withRICH_fromTarget.size(); i++) {
574 fHistoList_photons_withRICH_fromTarget[i]->Write();
575 }
576 gDirectory->cd("..");
577
578 for (UInt_t i = 0; i < fHistoList_photons.size(); i++) {
579 fHistoList_photons[i]->Write();
580 }
581 gDirectory->cd("..");
582}
583
584
585void CbmAnaConversionPhotons2::Exec()
586{
587 if (fPrimVertex != NULL) { fKFVertex = CbmKFVertex(*fPrimVertex); }
588 else {
589 Fatal("CbmAnaConversionPhotons2::Exec", "No PrimaryVertex array!");
590 }
591
592
593 fRecoTracklist_gtIndex.clear();
594 fRecoTracklist_mcIndex.clear();
595 fRecoTracklist_momentum.clear();
596 fRecoTracklist_chi.clear();
597 fRecoTracklist_mctrack.clear();
598
599 fRecoTracklist_withRICH_gtIndex.clear();
600 fRecoTracklist_withRICH_mcIndex.clear();
601 fRecoTracklist_withRICH_momentum.clear();
602 fRecoTracklist_withRICH_chi.clear();
603 fRecoTracklist_withRICH_mctrack.clear();
604
605 fVector_combinations.clear();
606
607
608 // everything related to reconstructed data
609 Int_t nofGlobalTracks = fGlobalTracks->GetEntriesFast();
610 for (int iG = 0; iG < nofGlobalTracks; iG++) {
611 CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iG);
612 if (NULL == gTrack) continue;
613 int stsInd = gTrack->GetStsTrackIndex();
614 int richInd = gTrack->GetRichRingIndex();
615 if (stsInd < 0) continue;
616
617 CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsInd);
618 if (stsTrack == NULL) continue;
619
620 CbmTrackMatchNew* stsMatch = (CbmTrackMatchNew*) fStsTrackMatches->At(stsInd);
621 if (stsMatch == NULL) continue;
622 if (stsMatch->GetNofLinks() <= 0) continue;
623 int stsMcTrackId = stsMatch->GetMatchedLink().GetIndex();
624 if (stsMcTrackId < 0) continue;
625 CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId);
626 if (mcTrack1 == NULL) continue;
627
628
629 int pdg = TMath::Abs(mcTrack1->GetPdgCode());
630
631
632 // calculate refitted momenta at primary vertex
633 TVector3 refittedMomentum;
634 CbmL1PFFitter fPFFitter;
635 vector<CbmStsTrack> stsTracks;
636 stsTracks.resize(1);
637 stsTracks[0] = *stsTrack;
638 vector<CbmL1PFFitter::PFFieldRegion> vField;
639 vector<float> chiPrim;
640 fPFFitter.GetChiToVertex(stsTracks, vField, chiPrim, fKFVertex, 3e6);
641 //cand.chi2sts = stsTracks[0].GetChiSq() / stsTracks[0].GetNDF();
642 //cand.chi2Prim = chiPrim[0];
643 const FairTrackParam* vtxTrack = stsTracks[0].GetParamFirst();
644 vtxTrack->Momentum(refittedMomentum);
645 float result_chi = chiPrim[0];
646
647
648 // Doing refit of momenta with electron assumption
649 CbmL1PFFitter fPFFitter_electron;
650 vector<CbmStsTrack> stsTracks_electron;
651 stsTracks_electron.resize(1);
652 stsTracks_electron[0] = *stsTrack;
653 vector<CbmL1PFFitter::PFFieldRegion> vField_electron;
654 vector<float> chiPrim_electron;
655 vector<int> pidHypo_electron;
656 pidHypo_electron.push_back(11);
657 fPFFitter_electron.Fit(stsTracks_electron, pidHypo_electron);
658 fPFFitter_electron.GetChiToVertex(stsTracks_electron, vField_electron, chiPrim_electron, fKFVertex, 3e6);
659
660 TVector3 refittedMomentum_electron;
661 const FairTrackParam* vtxTrack_electron = stsTracks_electron[0].GetParamFirst();
662 vtxTrack_electron->Momentum(refittedMomentum_electron);
663 float result_chi_electron = chiPrim_electron[0];
664
665 refittedMomentum = refittedMomentum_electron;
666 result_chi = result_chi_electron;
667
668
669 if (pdg == 11) {
670 fRecoTracklist_gtIndex.push_back(iG);
671 fRecoTracklist_mcIndex.push_back(stsMcTrackId);
672 fRecoTracklist_momentum.push_back(refittedMomentum);
673 fRecoTracklist_chi.push_back(result_chi);
674 fRecoTracklist_mctrack.push_back(mcTrack1);
675 }
676
677
678 if (richInd < 0) continue;
679 CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(richInd);
680 if (richMatch == NULL) continue;
681 int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
682 if (richMcTrackId < 0) continue;
683 CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
684 if (mcTrack2 == NULL) continue;
685
686
687 if (pdg == 11) {
688 fRecoTracklist_withRICH_gtIndex.push_back(iG);
689 fRecoTracklist_withRICH_mcIndex.push_back(stsMcTrackId);
690 fRecoTracklist_withRICH_momentum.push_back(refittedMomentum);
691 fRecoTracklist_withRICH_chi.push_back(result_chi);
692 fRecoTracklist_withRICH_mctrack.push_back(mcTrack1);
693 }
694 }
695
696 AnalyseElectronsReco();
697 AnalyseElectronsRecoWithRICH();
698}
699
700
701void CbmAnaConversionPhotons2::AnalyseElectronsReco()
702{
703 int electronnumber = fRecoTracklist_gtIndex.size();
704
705 cout << "CbmAnaConversionPhotons: array size in AnalyseElectronsReco(): " << electronnumber << endl;
706 for (int i = 0; i < electronnumber - 1; i++) {
707 for (int j = i + 1; j < electronnumber; j++) {
708 if (fRecoTracklist_mctrack[i]->GetPdgCode() + fRecoTracklist_mctrack[j]->GetPdgCode() != 0)
709 continue; // only 1 electron and 1 positron allowed
710
711
712 CbmAnaConversionKinematicParams paramSet = CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(
713 fRecoTracklist_momentum[i], fRecoTracklist_momentum[j]);
714 Double_t OpeningAngleCut = CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt);
715
716
717 int motherID_i = fRecoTracklist_mctrack[i]->GetMotherId();
718 int motherID_j = fRecoTracklist_mctrack[j]->GetMotherId();
719
720
721 // first all possible combinations are considered
722
723 fh2Electrons_angle_all->Fill(paramSet.fAngle);
724 fh2Electrons_angleVSpt_all->Fill(paramSet.fPt, paramSet.fAngle);
725 fh2Electrons_invmass_all->Fill(paramSet.fMinv);
726 fh2Electrons_invmassVSpt_all->Fill(paramSet.fPt, paramSet.fMinv);
727
728 if (paramSet.fAngle < OpeningAngleCut) {
729 fh2Electrons_invmass_all_cut->Fill(paramSet.fMinv);
730 fh2Electrons_angle_all_cuts->Fill(paramSet.fAngle);
731 }
732
733
734 // then all false combinations are analysed, after that "continue" of loop, i.e. break
735 if (motherID_i != motherID_j) {
736 fh2Electrons_angle_combBack->Fill(paramSet.fAngle);
737 fh2Electrons_angleVSpt_combBack->Fill(paramSet.fPt, paramSet.fAngle);
738 fh2Electrons_invmass_combBack->Fill(paramSet.fMinv);
739 fh2Electrons_invmassVSpt_combBack->Fill(paramSet.fPt, paramSet.fMinv);
740
741 if (paramSet.fAngle < OpeningAngleCut) {
742 fh2Electrons_invmass_combBack_cut->Fill(paramSet.fMinv);
743 fh2Electrons_angle_combBack_cuts->Fill(paramSet.fAngle);
744 }
745
746 // study of different opening angle cuts
747 fh2Electrons_angle_CUTcomparison->Fill(1); // no cuts applied
748 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
749 fh2Electrons_angle_CUTcomparison->Fill(3);
750 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
751 fh2Electrons_angle_CUTcomparison->Fill(5);
752 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
753 fh2Electrons_angle_CUTcomparison->Fill(7);
754 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
755 fh2Electrons_angle_CUTcomparison->Fill(9);
756 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
757 fh2Electrons_angle_CUTcomparison->Fill(11);
758 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
759 fh2Electrons_angle_CUTcomparison->Fill(13);
760
761
762 fh2Electrons_angle_CUTcomparison_chi->Fill(1); // no cuts applied
763 Double_t pt_e1 = fRecoTracklist_momentum[i].Perp();
764 Double_t pt_e2 = fRecoTracklist_momentum[j].Perp();
765 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
766 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
767 fh2Electrons_angle_CUTcomparison_chi->Fill(3);
768 }
769 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
770 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
771 fh2Electrons_angle_CUTcomparison_chi->Fill(5);
772 }
773 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
774 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
775 fh2Electrons_angle_CUTcomparison_chi->Fill(7);
776 }
777 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
778 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
779 fh2Electrons_angle_CUTcomparison_chi->Fill(9);
780 }
781
782 continue;
783 }
784
785
786 // everything, that is not a false combination, will be further analysed
787
788 fh2Electrons_angle_allSameG->Fill(paramSet.fAngle);
789 fh2Electrons_angleVSpt_allSameG->Fill(paramSet.fPt, paramSet.fAngle);
790 fh2Electrons_invmass_allSameG->Fill(paramSet.fMinv);
791 fh2Electrons_invmassVSpt_allSameG->Fill(paramSet.fPt, paramSet.fMinv);
792
793 if (paramSet.fAngle < OpeningAngleCut) {
794 fh2Electrons_invmass_allSameG_cut->Fill(paramSet.fMinv);
795 fh2Electrons_angle_allSameG_cuts->Fill(paramSet.fAngle);
796 }
797
798
799 // study of different opening angle cuts
800 fh2Electrons_angle_CUTcomparison->Fill(0); // no cuts applied
801 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
802 fh2Electrons_angle_CUTcomparison->Fill(2);
803 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
804 fh2Electrons_angle_CUTcomparison->Fill(4);
805 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
806 fh2Electrons_angle_CUTcomparison->Fill(6);
807 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
808 fh2Electrons_angle_CUTcomparison->Fill(8);
809 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
810 fh2Electrons_angle_CUTcomparison->Fill(10);
811 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
812 fh2Electrons_angle_CUTcomparison->Fill(12);
813
814
815 fh2Electrons_angle_CUTcomparison_chi->Fill(0); // no cuts applied
816 Double_t pt_e1 = fRecoTracklist_momentum[i].Perp();
817 Double_t pt_e2 = fRecoTracklist_momentum[j].Perp();
818 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
819 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
820 fh2Electrons_angle_CUTcomparison_chi->Fill(2);
821 }
822 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
823 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
824 fh2Electrons_angle_CUTcomparison_chi->Fill(4);
825 }
826 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
827 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
828 fh2Electrons_angle_CUTcomparison_chi->Fill(6);
829 }
830 if (fRecoTracklist_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
831 && fRecoTracklist_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
832 fh2Electrons_angle_CUTcomparison_chi->Fill(8);
833 }
834 }
835 }
836}
837
838
839void CbmAnaConversionPhotons2::AnalyseElectronsRecoWithRICH()
840{
841 int electronnumber = fRecoTracklist_withRICH_gtIndex.size();
842
843 cout << "CbmAnaConversionPhotons: array size in AnalyseElectronsReco(): " << electronnumber << endl;
844 for (int i = 0; i < electronnumber - 1; i++) {
845 for (int j = i + 1; j < electronnumber; j++) {
846 if (fRecoTracklist_withRICH_mctrack[i]->GetPdgCode() + fRecoTracklist_withRICH_mctrack[j]->GetPdgCode() != 0)
847 continue; // only 1 electron and 1 positron allowed
848
849
850 CbmAnaConversionKinematicParams paramSet = CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco(
851 fRecoTracklist_withRICH_momentum[i], fRecoTracklist_withRICH_momentum[j]);
852
853
854 fh2Electrons_angle_withRICH_all->Fill(paramSet.fAngle);
855 fh2Electrons_invmass_withRICH_all->Fill(paramSet.fMinv);
856 fh2Electrons_angleVSpt_withRICH_all->Fill(paramSet.fPt, paramSet.fAngle);
857 fh2Electrons_invmassVSpt_withRICH_all->Fill(paramSet.fPt, paramSet.fMinv);
858
859 Double_t pt_e1 = fRecoTracklist_withRICH_momentum[i].Perp();
860 Double_t pt_e2 = fRecoTracklist_withRICH_momentum[j].Perp();
861
862 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
863 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
864 fh2Electrons_angle_withRICH_withChi_all->Fill(paramSet.fAngle);
865 fh2Electrons_invmass_withRICH_withChi_all->Fill(paramSet.fMinv);
866 fh2Electrons_angleVSpt_withRICH_withChi_all->Fill(paramSet.fPt, paramSet.fAngle);
867 fh2Electrons_invmassVSpt_withRICH_withChi_all->Fill(paramSet.fPt, paramSet.fMinv);
868 }
869
870
871 TVector3 startvertex1;
872 fRecoTracklist_withRICH_mctrack[i]->GetStartVertex(startvertex1);
873 TVector3 startvertex2;
874 fRecoTracklist_withRICH_mctrack[j]->GetStartVertex(startvertex2);
875
876
877 if (startvertex1.Z() < 1 && startvertex2.Z() < 1) {
878 fh2Electrons_angle_withRICH_fromTarget_all->Fill(paramSet.fAngle);
879 fh2Electrons_invmass_withRICH_fromTarget_all->Fill(paramSet.fMinv);
880 fh2Electrons_angleVSpt_withRICH_fromTarget_all->Fill(paramSet.fPt, paramSet.fAngle);
881 fh2Electrons_invmassVSpt_withRICH_fromTarget_all->Fill(paramSet.fPt, paramSet.fMinv);
882 }
883
884 int motherID_i = fRecoTracklist_withRICH_mctrack[i]->GetMotherId();
885 int motherID_j = fRecoTracklist_withRICH_mctrack[j]->GetMotherId();
886
887
888 Bool_t electron_rich1 = CbmLitGlobalElectronId::GetInstance().IsRichElectron(
889 fRecoTracklist_withRICH_gtIndex[i], fRecoTracklist_withRICH_momentum[i].Mag());
890 Bool_t electron_rich2 = CbmLitGlobalElectronId::GetInstance().IsRichElectron(
891 fRecoTracklist_withRICH_gtIndex[j], fRecoTracklist_withRICH_momentum[j].Mag());
892
893
894 // then all false combinations are analysed, after that "continue" of loop, i.e. break
895 if (motherID_i != motherID_j) {
896 fh2Electrons_angle_withRICH_combBack->Fill(paramSet.fAngle);
897 fh2Electrons_invmass_withRICH_combBack->Fill(paramSet.fMinv);
898 fh2Electrons_angleVSpt_withRICH_combBack->Fill(paramSet.fPt, paramSet.fAngle);
899 fh2Electrons_invmassVSpt_withRICH_combBack->Fill(paramSet.fPt, paramSet.fMinv);
900
901
902 // study of different opening angle cuts
903 fh2Electrons_angle_CUTcomparison_withRICH->Fill(1); // no cuts applied
904 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
905 fh2Electrons_angle_CUTcomparison_withRICH->Fill(3);
906 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
907 fh2Electrons_angle_CUTcomparison_withRICH->Fill(5);
908 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
909 fh2Electrons_angle_CUTcomparison_withRICH->Fill(7);
910 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
911 fh2Electrons_angle_CUTcomparison_withRICH->Fill(9);
912 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
913 fh2Electrons_angle_CUTcomparison_withRICH->Fill(11);
914 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
915 fh2Electrons_angle_CUTcomparison_withRICH->Fill(13);
916
917
918 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(1); // no cuts applied
919 //Double_t pt_e1 = fRecoTracklist_withRICH_momentum[i].Perp();
920 //Double_t pt_e2 = fRecoTracklist_withRICH_momentum[j].Perp();
921 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
922 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
923 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(7);
924
925 fh2Electrons_angle_withRICH_withChi_combBack->Fill(paramSet.fAngle);
926 fh2Electrons_invmass_withRICH_withChi_combBack->Fill(paramSet.fMinv);
927 fh2Electrons_angleVSpt_withRICH_withChi_combBack->Fill(paramSet.fPt, paramSet.fAngle);
928 fh2Electrons_invmassVSpt_withRICH_withChi_combBack->Fill(paramSet.fPt, paramSet.fMinv);
929
930 // study of different opening angle cuts
931 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(1); // no cuts applied
932 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
933 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(3);
934 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
935 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(5);
936 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
937 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(7);
938 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
939 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(9);
940 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
941 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(11);
942 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
943 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(13);
944 }
945 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
946 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
947 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(3);
948 }
949 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
950 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
951 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(5);
952 }
953 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
954 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
955 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(9);
956 }
957
958
959 if (startvertex1.Z() < 1 && startvertex2.Z() < 1) {
960 fh2Electrons_angle_withRICH_fromTarget_combBack->Fill(paramSet.fAngle);
961 fh2Electrons_invmass_withRICH_fromTarget_combBack->Fill(paramSet.fMinv);
962 fh2Electrons_angleVSpt_withRICH_fromTarget_combBack->Fill(paramSet.fPt, paramSet.fAngle);
963 fh2Electrons_invmassVSpt_withRICH_fromTarget_combBack->Fill(paramSet.fPt, paramSet.fMinv);
964 }
965
966
967 Bool_t WithinChiCut = (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
968 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2));
969 Bool_t WithinAngleCut = (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt));
970 Bool_t WithinMassCut = (paramSet.fMinv < 0.03);
971 Bool_t WithElectronId = (electron_rich1 && electron_rich2);
972
973 if (WithinChiCut && WithinAngleCut && WithinMassCut && WithElectronId) {
974 vector<int> pair; // = {a, b};
975 pair.push_back(i);
976 pair.push_back(j);
977 fVector_combinations.push_back(pair);
978 }
979
980 continue;
981 }
982
983
984 fh2Electrons_angle_withRICH_allSameG->Fill(paramSet.fAngle);
985 fh2Electrons_invmass_withRICH_allSameG->Fill(paramSet.fMinv);
986 fh2Electrons_angleVSpt_withRICH_allSameG->Fill(paramSet.fPt, paramSet.fAngle);
987 fh2Electrons_invmassVSpt_withRICH_allSameG->Fill(paramSet.fPt, paramSet.fMinv);
988
989 // study of different opening angle cuts
990 fh2Electrons_angle_CUTcomparison_withRICH->Fill(0); // no cuts applied
991 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
992 fh2Electrons_angle_CUTcomparison_withRICH->Fill(2);
993 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
994 fh2Electrons_angle_CUTcomparison_withRICH->Fill(4);
995 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
996 fh2Electrons_angle_CUTcomparison_withRICH->Fill(6);
997 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
998 fh2Electrons_angle_CUTcomparison_withRICH->Fill(8);
999 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
1000 fh2Electrons_angle_CUTcomparison_withRICH->Fill(10);
1001 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
1002 fh2Electrons_angle_CUTcomparison_withRICH->Fill(12);
1003
1004
1005 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(0); // no cuts applied
1006 //Double_t pt_e1 = fRecoTracklist_withRICH_momentum[i].Perp();
1007 //Double_t pt_e2 = fRecoTracklist_withRICH_momentum[j].Perp();
1008 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1009 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2)) {
1010 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(6);
1011
1012 fh2Electrons_angle_withRICH_withChi_allSameG->Fill(paramSet.fAngle);
1013 fh2Electrons_invmass_withRICH_withChi_allSameG->Fill(paramSet.fMinv);
1014 fh2Electrons_angleVSpt_withRICH_withChi_allSameG->Fill(paramSet.fPt, paramSet.fAngle);
1015 fh2Electrons_invmassVSpt_withRICH_withChi_allSameG->Fill(paramSet.fPt, paramSet.fMinv);
1016
1017 // study of different opening angle cuts
1018 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(0); // no cuts applied
1019 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1020 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(2);
1021 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
1022 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(4);
1023 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
1024 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(6);
1025 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
1026 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(8);
1027 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
1028 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(10);
1029 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5(paramSet.fPt))
1030 fh2Electrons_angle_CUTcomparison_withRICH_withChi->Fill(12);
1031 }
1032 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e1)
1033 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt1(pt_e2)) {
1034 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(2);
1035 }
1036 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e1)
1037 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt2(pt_e2)) {
1038 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(4);
1039 }
1040 if (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e1)
1041 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCutAlt3(pt_e2)) {
1042 fh2Electrons_angle_CUTcomparison_withRICH_chi->Fill(8);
1043 }
1044
1045
1046 if (startvertex1.Z() < 1 && startvertex2.Z() < 1) {
1047 fh2Electrons_angle_withRICH_fromTarget_allSameG->Fill(paramSet.fAngle);
1048 fh2Electrons_invmass_withRICH_fromTarget_allSameG->Fill(paramSet.fMinv);
1049 fh2Electrons_angleVSpt_withRICH_fromTarget_allSameG->Fill(paramSet.fPt, paramSet.fAngle);
1050 fh2Electrons_invmassVSpt_withRICH_fromTarget_allSameG->Fill(paramSet.fPt, paramSet.fMinv);
1051 }
1052
1053
1054 Bool_t WithinChiCut = (fRecoTracklist_withRICH_chi[i] < CbmAnaConversionCutSettings::CalcChiCut(pt_e1)
1055 && fRecoTracklist_withRICH_chi[j] < CbmAnaConversionCutSettings::CalcChiCut(pt_e2));
1056 Bool_t WithinAngleCut = (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt));
1057 Bool_t WithinMassCut = (paramSet.fMinv < 0.03);
1058 Bool_t WithElectronId = (electron_rich1 && electron_rich2);
1059
1060 if (WithinChiCut && WithinAngleCut && WithinMassCut && WithElectronId) {
1061 vector<int> pair; // = {a, b};
1062 pair.push_back(i);
1063 pair.push_back(j);
1064 fVector_combinations.push_back(pair);
1065 }
1066 }
1067 }
1068 EstimateFullRecoResults();
1069}
1070
1071
1072void CbmAnaConversionPhotons2::EstimateFullRecoResults() // with RICH
1073{
1074 Int_t nof = fVector_combinations.size();
1075 if (nof < 2) return;
1076
1077 for (int i = 0; i < nof - 1; i++) {
1078 for (int j = i + 1; j < nof; j++) {
1079 Int_t electron11 = fVector_combinations[i][0];
1080 Int_t electron12 = fVector_combinations[i][1];
1081 Int_t electron21 = fVector_combinations[j][0];
1082 Int_t electron22 = fVector_combinations[j][1];
1083
1084 Int_t motherID_11 = fRecoTracklist_withRICH_mctrack[electron11]->GetMotherId();
1085 Int_t motherID_12 = fRecoTracklist_withRICH_mctrack[electron12]->GetMotherId();
1086 Int_t motherID_21 = fRecoTracklist_withRICH_mctrack[electron21]->GetMotherId();
1087 Int_t motherID_22 = fRecoTracklist_withRICH_mctrack[electron22]->GetMotherId();
1088
1089 CbmMCTrack* mothertrack_11 = (CbmMCTrack*) fMcTracks->At(motherID_11);
1090 CbmMCTrack* mothertrack_12 = (CbmMCTrack*) fMcTracks->At(motherID_12);
1091 CbmMCTrack* mothertrack_21 = (CbmMCTrack*) fMcTracks->At(motherID_21);
1092 CbmMCTrack* mothertrack_22 = (CbmMCTrack*) fMcTracks->At(motherID_22);
1093
1094 Int_t grandmotherID_11 = mothertrack_11->GetMotherId();
1095 Int_t grandmotherID_12 = mothertrack_12->GetMotherId();
1096 Int_t grandmotherID_21 = mothertrack_21->GetMotherId();
1097 Int_t grandmotherID_22 = mothertrack_22->GetMotherId();
1098
1099 if (grandmotherID_11 == grandmotherID_12 && grandmotherID_11 == grandmotherID_21
1100 && grandmotherID_11 == grandmotherID_22) {
1101 fh2Electrons_fullrecoCheck->Fill(1);
1102 }
1103 else {
1104 fh2Electrons_fullrecoCheck->Fill(2);
1105 }
1106 }
1107 }
1108}
CbmDrawHist.h
Helper functions for drawing 1D and 2D histograms and graphs.
CbmStsTrack.h
Data class for STS tracks.
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt5
static Double_t CalcOpeningAngleCutAlt5(Double_t pt)
Definition CbmAnaConversionCutSettings.h:68
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3
static Double_t CalcOpeningAngleCutAlt3(Double_t)
Definition CbmAnaConversionCutSettings.h:51
CbmAnaConversionCutSettings::CalcChiCutAlt3
static Double_t CalcChiCutAlt3(Double_t)
Definition CbmAnaConversionCutSettings.h:106
CbmAnaConversionCutSettings::CalcChiCutAlt2
static Double_t CalcChiCutAlt2(Double_t pt)
Definition CbmAnaConversionCutSettings.h:97
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1
static Double_t CalcOpeningAngleCutAlt1(Double_t pt)
Definition CbmAnaConversionCutSettings.h:35
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2
static Double_t CalcOpeningAngleCutAlt2(Double_t)
Definition CbmAnaConversionCutSettings.h:43
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4
static Double_t CalcOpeningAngleCutAlt4(Double_t pt)
Definition CbmAnaConversionCutSettings.h:59
CbmAnaConversionCutSettings::CalcOpeningAngleCut
static Double_t CalcOpeningAngleCut(Double_t pt)
Definition CbmAnaConversionCutSettings.h:26
CbmAnaConversionCutSettings::CalcChiCutAlt1
static Double_t CalcChiCutAlt1(Double_t)
Definition CbmAnaConversionCutSettings.h:89
CbmAnaConversionCutSettings::CalcChiCut
static Double_t CalcChiCut(Double_t pt)
Definition CbmAnaConversionCutSettings.h:80
CbmAnaConversionKinematicParams::KinematicParams_2particles_Reco
static CbmAnaConversionKinematicParams KinematicParams_2particles_Reco(const TVector3 electron1, const TVector3 electron2)
Definition CbmAnaConversionKinematicParams.h:128
CbmAnaConversionPhotons2::fHistoList_photons_withRICH
std::vector< TH1 * > fHistoList_photons_withRICH
Definition CbmAnaConversionPhotons2.h:60
CbmAnaConversionPhotons2::fRecoTracklist_mcIndex
std::vector< Int_t > fRecoTracklist_mcIndex
Definition CbmAnaConversionPhotons2.h:65
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_mctrack
std::vector< CbmMCTrack * > fRecoTracklist_withRICH_mctrack
Definition CbmAnaConversionPhotons2.h:74
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_chi
std::vector< Double_t > fRecoTracklist_withRICH_chi
Definition CbmAnaConversionPhotons2.h:73
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_momentum
std::vector< TVector3 > fRecoTracklist_withRICH_momentum
Definition CbmAnaConversionPhotons2.h:72
CbmAnaConversionPhotons2::fRecoTracklist_mctrack
std::vector< CbmMCTrack * > fRecoTracklist_mctrack
Definition CbmAnaConversionPhotons2.h:68
CbmAnaConversionPhotons2::fHistoList_photons_withRICH_withChi
std::vector< TH1 * > fHistoList_photons_withRICH_withChi
Definition CbmAnaConversionPhotons2.h:61
CbmAnaConversionPhotons2::fVector_combinations
std::vector< std::vector< int > > fVector_combinations
Definition CbmAnaConversionPhotons2.h:172
CbmAnaConversionPhotons2::fRecoTracklist_gtIndex
std::vector< Int_t > fRecoTracklist_gtIndex
Definition CbmAnaConversionPhotons2.h:64
CbmAnaConversionPhotons2::fRecoTracklist_chi
std::vector< Double_t > fRecoTracklist_chi
Definition CbmAnaConversionPhotons2.h:67
CbmAnaConversionPhotons2::fHistoList_photons_withRICH_fromTarget
std::vector< TH1 * > fHistoList_photons_withRICH_fromTarget
Definition CbmAnaConversionPhotons2.h:62
CbmAnaConversionPhotons2::fHistoList_photons
std::vector< TH1 * > fHistoList_photons
Definition CbmAnaConversionPhotons2.h:59
CbmAnaConversionPhotons2::fRecoTracklist_momentum
std::vector< TVector3 > fRecoTracklist_momentum
Definition CbmAnaConversionPhotons2.h:66
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_mcIndex
std::vector< Int_t > fRecoTracklist_withRICH_mcIndex
Definition CbmAnaConversionPhotons2.h:71
CbmAnaConversionPhotons2::fRecoTracklist_withRICH_gtIndex
std::vector< Int_t > fRecoTracklist_withRICH_gtIndex
Definition CbmAnaConversionPhotons2.h:70
CbmGlobalTrack::GetStsTrackIndex
int32_t GetStsTrackIndex() const
Definition CbmGlobalTrack.h:44
CbmGlobalTrack::GetRichRingIndex
int32_t GetRichRingIndex() const
Definition CbmGlobalTrack.h:47
CbmL1PFFitter::GetChiToVertex
void GetChiToVertex(std::vector< CbmStsTrack > &Tracks, std::vector< PFFieldRegion > &field, std::vector< float > &chiToVtx, CbmKFVertex &primVtx, float chiPrim=-1)
Definition CbmL1PFFitter.cxx:501
CbmL1PFFitter::Fit
void Fit(std::vector< CbmStsTrack > &Tracks, const std::vector< CbmMvdHit > &vMvdHits, const std::vector< CbmStsHit > &vStsHits, const std::vector< int > &pidHypo)
Definition CbmL1PFFitter.cxx:172
CbmLitGlobalElectronId::IsRichElectron
Bool_t IsRichElectron(Int_t globalTrackIndex, Double_t momentum)
Identify electron in RICH detector.
Definition CbmLitGlobalElectronId.cxx:64
CbmLitGlobalElectronId::GetInstance
static CbmLitGlobalElectronId & GetInstance()
Definition CbmLitGlobalElectronId.h:30
CbmMCTrack::GetMotherId
int32_t GetMotherId() const
Definition CbmMCTrack.h:69
CbmMCTrack::GetPdgCode
int32_t GetPdgCode() const
Definition CbmMCTrack.h:68
CbmMatch::GetNofLinks
int32_t GetNofLinks() const
Definition CbmMatch.h:42
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition CbmMatch.h:41
std
Hash for CbmL1LinkKey.
Definition algo/base/Options.cxx:21