CbmRoot
Loading...
Searching...
No Matches
CbmAnaConversionPhotons.cxx
Go to the documentation of this file.
1/* Copyright (C) 2014-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 */
4
11
12#include "CbmAnaConversionPhotons.h"
13
14#include "CbmDrawHist.h"
15#include "CbmGlobalTrack.h"
16#include "CbmL1PFFitter.h"
17#include "CbmMCTrack.h"
18#include "CbmRichPoint.h"
19#include "CbmRichRing.h"
20#include "CbmStsTrack.h"
21#include "CbmTrackMatchNew.h"
22
23#include "FairRootManager.h"
24#include <Logger.h>
25
26#include "CbmAnaConversionCutSettings.h"
27#include "CbmLitGlobalElectronId.h"
28
29#include "TCanvas.h"
30
31#include <algorithm>
32#include <map>
33
34
35using namespace std;
36
37
38CbmAnaConversionPhotons::CbmAnaConversionPhotons()
39 : fRichPoints(NULL)
40 , fRichRings(NULL)
41 , fRichRingMatches(NULL)
42 , fMcTracks(NULL)
43 , fStsTracks(NULL)
44 , fStsTrackMatches(NULL)
45 , fGlobalTracks(NULL)
46 , fPrimVertex(NULL)
47 , fKFVertex()
48 , fHistoList_photons()
49 , fHistoList_EFG()
50 , fHistoList_EFG_angle()
51 , fHistoList_EFG_invmass()
52 , fHistoList_EFG_energy()
53 , fPhotons_nofPerEvent(NULL)
54 , fPhotons_pt(NULL)
55 , fPhotons_test(NULL)
56 , fPhotons_nofMC(NULL)
57 , fPhotons_energyMC(NULL)
58 , fPhotons_ptMC(NULL)
59 , fPhotons_ptRapMC(NULL)
60 , fPhotonsRest_energyMC(NULL)
61 , fPhotonsRest_pdgMotherMC(NULL)
62 , fPhotonsRest_ptMC(NULL)
63 , fPhotonsRest_ptMC_pi0(NULL)
64 , fPhotonsRest_ptMC_n(NULL)
65 , fPhotonsRest_ptMC_e(NULL)
66 , fPhotonsRest_ptMC_eta(NULL)
67 , fMCTracklist()
68 , fMCTracklist_allElectronsFromGamma()
69 , fRecoTracklist_allElectronsFromGamma()
70 , fRecoTracklist_allElectronsFromGammaMom()
71 , fRecoTracklist_allElectronsFromPi0()
72 , fRecoTracklist_allElectronsFromPi0Mom()
73 , fMCTracklist_allGammas()
74 , fMCTracklist_allGammasFromPi0()
75 , global_nof_photonsMC(0)
76 , global_nof_photonsReco(0)
77 , fhGlobalNofDirectPhotons(NULL)
78 , fhEFG_angle_all(NULL)
79 , fhEFG_angle_combBack(NULL)
80 , fhEFG_angle_allSameG(NULL)
81 , fhEFG_angle_direct(NULL)
82 , fhEFG_angle_pi0(NULL)
83 , fhEFG_angle_eta(NULL)
84 ,
85 //fhEFG_angleVSenergy_all(NULL),
86 //fhEFG_angleVSenergy_combBack(NULL),
87 fhEFG_angleVSenergy_allSameG(NULL)
88 , fhEFG_angleVSenergy_direct(NULL)
89 , fhEFG_angleVSenergy_pi0(NULL)
90 , fhEFG_angleVSenergy_eta(NULL)
91 , fhEFG_angleVSpt_all(NULL)
92 , fhEFG_angleVSpt_combBack(NULL)
93 , fhEFG_angleVSpt_allSameG(NULL)
94 , fhEFG_angleVSpt_direct(NULL)
95 , fhEFG_angleVSpt_pi0(NULL)
96 , fhEFG_angleVSpt_eta(NULL)
97 , fhEFG_invmass_all(NULL)
98 , fhEFG_invmass_combBack(NULL)
99 , fhEFG_invmass_allSameG(NULL)
100 , fhEFG_invmass_direct(NULL)
101 , fhEFG_invmass_pi0(NULL)
102 , fhEFG_invmass_eta(NULL)
103 , fhEFG_energy_all(NULL)
104 , fhEFG_energy_combBack(NULL)
105 , fhEFG_energy_allSameG(NULL)
106 , fhEFG_energy_direct(NULL)
107 , fhEFG_energy_pi0(NULL)
108 , fhEFG_energy_eta(NULL)
109 , fhEFG_angleBelow1GeV_all(NULL)
110 , fhEFG_angleBelow1GeV_combBack(NULL)
111 , fhEFG_angleBelow1GeV_allSameG(NULL)
112 , fhEFG_angleBelow1GeV_direct(NULL)
113 , fhEFG_angleBelow1GeV_pi0(NULL)
114 , fhEFG_angleBelow1GeV_eta(NULL)
115 , fhEFG_angleAbove1GeV_all(NULL)
116 , fhEFG_angleAbove1GeV_combBack(NULL)
117 , fhEFG_angleAbove1GeV_allSameG(NULL)
118 , fhEFG_angleAbove1GeV_direct(NULL)
119 , fhEFG_angleAbove1GeV_pi0(NULL)
120 , fhEFG_angleAbove1GeV_eta(NULL)
121 , fhEFG_momentumPair_all(NULL)
122 , fhEFG_momentumPair_combBack(NULL)
123 , fhEFG_momentumPair_allSameG(NULL)
124 , fhEFG_momentumPair_direct(NULL)
125 , fhEFG_momentumPair_pi0(NULL)
126 , fhEFG_momentumPair_eta(NULL)
127 ,
128 //fhEFG_startvertexVSangle_all(NULL),
129 //fhEFG_startvertexVSangle_combBack(NULL),
130 fhEFG_startvertexVSangle_allSameG(NULL)
131 , fhEFG_startvertexVSangle_direct(NULL)
132 , fhEFG_startvertexVSangle_pi0(NULL)
133 , fhEFG_startvertexVSangle_eta(NULL)
134 , fhEFG_startvertex_allSameG(NULL)
135 , fhEFG_angle_all_reco(NULL)
136 , fhEFG_angle_combBack_reco(NULL)
137 , fhEFG_angle_allSameG_reco(NULL)
138 , fhEFG_angle_direct_reco(NULL)
139 , fhEFG_angle_pi0_reco(NULL)
140 , fhEFG_angle_eta_reco(NULL)
141 , fhEFG_angle_all_reco_cuts(NULL)
142 , fhEFG_angle_combBack_reco_cuts(NULL)
143 , fhEFG_angle_allSameG_reco_cuts(NULL)
144 , fhEFG_angle_reco_CUTcomparison(NULL)
145 , fhEFG_angleBelow1GeV_all_reco(NULL)
146 , fhEFG_angleBelow1GeV_combBack_reco(NULL)
147 , fhEFG_angleBelow1GeV_allSameG_reco(NULL)
148 , fhEFG_angleBelow1GeV_direct_reco(NULL)
149 , fhEFG_angleBelow1GeV_pi0_reco(NULL)
150 , fhEFG_angleBelow1GeV_eta_reco(NULL)
151 , fhEFG_invmass_all_reco(NULL)
152 , fhEFG_invmass_combBack_reco(NULL)
153 , fhEFG_invmass_allSameG_reco(NULL)
154 , fhEFG_invmass_direct_reco(NULL)
155 , fhEFG_invmass_pi0_reco(NULL)
156 , fhEFG_invmass_eta_reco(NULL)
157 , fhEFG_invmass_all_reco_cut(NULL)
158 , fhEFG_invmass_combBack_reco_cut(NULL)
159 , fhEFG_invmass_allSameG_reco_cut(NULL)
160 , fhEFG_invmass_direct_reco_cut(NULL)
161 , fhEFG_invmass_pi0_reco_cut(NULL)
162 , fhEFG_invmass_eta_reco_cut(NULL)
163 , fhEFG_angleVSpt_all_reco(NULL)
164 , fhEFG_angleVSpt_combBack_reco(NULL)
165 , fhEFG_angleVSpt_allSameG_reco(NULL)
166 , fhEFG_angleVSpt_direct_reco(NULL)
167 , fhEFG_angleVSpt_pi0_reco(NULL)
168 , fhEFG_angleVSpt_eta_reco(NULL)
169 , fhEFG_invmassVSpt_all_reco(NULL)
170 , fhEFG_invmassVSpt_combBack_reco(NULL)
171 , fhEFG_invmassVSpt_allSameG_reco(NULL)
172 , fhEFG_invmassVSpt_direct_reco(NULL)
173 , fhEFG_invmassVSpt_pi0_reco(NULL)
174 , fhEFG_invmassVSpt_eta_reco(NULL)
175 , fhEFG_momentumResolutionPhoton_reco(NULL)
176 , fhEFG_momentumResolutionElectrons_reco(NULL)
177 , fhEFPI0_angle_reco(NULL)
178 , fhG_invmass(NULL)
179 , fhG_invmass_pi0(NULL)
180 , timer()
181 , fTime(0.)
182{
183}
184
185CbmAnaConversionPhotons::~CbmAnaConversionPhotons() {}
186
187
188void CbmAnaConversionPhotons::Init()
189{
190 FairRootManager* ioman = FairRootManager::Instance();
191 if (NULL == ioman) { Fatal("CbmAnaConversion::Init", "RootManager not instantised!"); }
192
193 fRichPoints = (TClonesArray*) ioman->GetObject("RichPoint");
194 if (NULL == fRichPoints) { Fatal("CbmAnaConversion::Init", "No RichPoint array!"); }
195
196 fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
197 if (NULL == fMcTracks) { Fatal("CbmAnaConversion::Init", "No MCTrack array!"); }
198
199 fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
200 if (NULL == fStsTracks) { Fatal("CbmAnaConversion::Init", "No StsTrack array!"); }
201
202 fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
203 if (NULL == fStsTrackMatches) { Fatal("CbmAnaConversion::Init", "No StsTrackMatch array!"); }
204
205 fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
206 if (NULL == fGlobalTracks) { Fatal("CbmAnaConversion::Init", "No GlobalTrack array!"); }
207
208 // Get pointer to PrimaryVertex object from IOManager if it exists
209 // The old name for the object is "PrimaryVertex" the new one
210 // "PrimaryVertex." Check first for the new name
211 fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex."));
212 if (nullptr == fPrimVertex) { fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex")); }
213 if (nullptr == fPrimVertex) { LOG(fatal) << "No PrimaryVertex array!"; }
214
215 fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
216 if (NULL == fRichRings) { Fatal("CbmAnaConversion::Init", "No RichRing array!"); }
217
218 fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
219 if (NULL == fRichRingMatches) { Fatal("CbmAnaConversion::Init", "No RichRingMatch array!"); }
220
221
222 InitHistos();
223
224 global_nof_photonsMC = 0;
225 global_nof_photonsReco = 0;
226}
227
228
229void CbmAnaConversionPhotons::InitHistos()
230{
231 fHistoList_photons.clear();
232 fHistoList_EFG.clear();
233 fHistoList_EFG_angle.clear();
234 fHistoList_EFG_invmass.clear();
235 fHistoList_EFG_energy.clear();
236
237 fPhotons_nofPerEvent =
238 new TH1I("fPhotons_nofPerEvent", "fPhotons_nofPerEvent; nof photons per event; #", 30, -0.5, 29.5);
239 fHistoList_photons.push_back(fPhotons_nofPerEvent);
240 fPhotons_pt = new TH1D("fPhotons_pt", "fPhotons_pt; pt; #", 50, -0.5, 4.5);
241 fHistoList_photons.push_back(fPhotons_pt);
242 fPhotons_test = new TH1I("fPhotons_test", "fPhotons_test; test; #", 10, -0.5, 9.5);
243 fHistoList_photons.push_back(fPhotons_test);
244
245 fPhotons_nofMC = new TH1I("fPhotons_nofMC", "fPhotons_nofMC; test; #", 100, -0.5, 99.5);
246 fHistoList_photons.push_back(fPhotons_nofMC);
247 fPhotons_energyMC = new TH1D("fPhotons_energyMC", "fPhotons_energyMC; energy; #", 500, -0.5, 49.5);
248 fHistoList_photons.push_back(fPhotons_energyMC);
249 fPhotons_ptMC = new TH1D("fPhotons_ptMC", "fPhotons_ptMC; pt; #", 500, -0.5, 4.5);
250 fHistoList_photons.push_back(fPhotons_ptMC);
251 fPhotons_ptRapMC = new TH2D("fPhotons_ptRapMC", "fPhotons_ptRapMC; pt; #", 500, -0.5, 4.5, 1000, -0.5, 9.5);
252 fHistoList_photons.push_back(fPhotons_ptRapMC);
253 fPhotonsRest_energyMC = new TH1D("fPhotonsRest_energyMC", "fPhotonsRest_energyMC; energy; #", 500, -0.5, 49.5);
254 fHistoList_photons.push_back(fPhotonsRest_energyMC);
255 fPhotonsRest_pdgMotherMC =
256 new TH1D("fPhotonsRest_pdgMotherMC", "fPhotonsRest_pdgMotherMC; pdg code; #", 5000, -0.5, 4999.5);
257 fHistoList_photons.push_back(fPhotonsRest_pdgMotherMC);
258 fPhotonsRest_ptMC = new TH1D("fPhotonsRest_ptMC", "fPhotonsRest_ptMC; pt; #", 500, -0.5, 4.5);
259 fHistoList_photons.push_back(fPhotonsRest_ptMC);
260
261 fPhotonsRest_ptMC_pi0 = new TH1D("fDirectPhotonsRest_ptMC_pi0", "fDirectPhotonsRest_ptMC_pi0; pt; #", 500, -0.5, 4.5);
262 fHistoList_photons.push_back(fPhotonsRest_ptMC_pi0);
263 fPhotonsRest_ptMC_n = new TH1D("fPhotonsRest_ptMC_n", "fPhotonsRest_ptMC_n; pt; #", 500, -0.5, 4.5);
264 fHistoList_photons.push_back(fPhotonsRest_ptMC_n);
265 fPhotonsRest_ptMC_e = new TH1D("fPhotonsRest_ptMC_e", "fPhotonsRest_ptMC_e; pt; #", 500, -0.5, 4.5);
266 fHistoList_photons.push_back(fPhotonsRest_ptMC_e);
267 fPhotonsRest_ptMC_eta = new TH1D("fPhotonsRest_ptMC_eta", "fPhotonsRest_ptMC_eta; pt; #", 500, -0.5, 4.5);
268 fHistoList_photons.push_back(fPhotonsRest_ptMC_eta);
269
270 fhGlobalNofDirectPhotons = new TH1D("fhGlobalNofDirectPhotons", "fhGlobalNofDirectPhotons; ; #", 2, 0., 2.);
271 fHistoList_photons.push_back(fhGlobalNofDirectPhotons);
272 fhGlobalNofDirectPhotons->GetXaxis()->SetBinLabel(1, "nof global DP"); // number of all direct photons from MC
273 fhGlobalNofDirectPhotons->GetXaxis()->SetBinLabel(
274 2,
275 "nof reconstructed DP"); // number of all direct photons which can be reconstructed
276
277
278 fhEFG_angle_all = new TH1D("fhEFG_angle_all", "fhEFG_angle_all; opening angle [deg]; #", 2000, 0., 100.);
279 fhEFG_angle_combBack =
280 new TH1D("fhEFG_angle_combBack", "fhEFG_angle_combBack; opening angle [deg]; #", 2000, 0., 100.);
281 fhEFG_angle_allSameG = new TH1D("fhEFG_angle_allSameG", "fhEFG_angle_allSameG; opening angle [deg]; #", 400, 0., 20.);
282 fhEFG_angle_direct = new TH1D("fhEFG_angle_direct", "fhEFG_angle_direct; opening angle [deg]; #", 400, 0., 20.);
283 fhEFG_angle_pi0 = new TH1D("fhEFG_angle_pi0", "fhEFG_angle_pi0; opening angle [deg]; #", 400, 0., 20.);
284 fhEFG_angle_eta = new TH1D("fhEFG_angle_eta", "fhEFG_angle_eta; opening angle [deg]; #", 400, 0., 20.);
285 fHistoList_EFG_angle.push_back(fhEFG_angle_all);
286 fHistoList_EFG_angle.push_back(fhEFG_angle_combBack);
287 fHistoList_EFG_angle.push_back(fhEFG_angle_allSameG);
288 fHistoList_EFG_angle.push_back(fhEFG_angle_direct);
289 fHistoList_EFG_angle.push_back(fhEFG_angle_pi0);
290 fHistoList_EFG_angle.push_back(fhEFG_angle_eta);
291 fhEFG_invmass_all = new TH1D("fhEFG_invmass_all", "fhEFG_invmass_all; invmass [GeV/c^2]; #", 5000, 0., 0.5);
292 fhEFG_invmass_combBack =
293 new TH1D("fhEFG_invmass_combBack", "fhEFG_invmass_combBack; invmass [GeV/c^2]; #", 5000, 0., 0.5);
294 fhEFG_invmass_allSameG =
295 new TH1D("fhEFG_invmass_allSameG", "fhEFG_invmass_allSameG; invmass [GeV/c^2]; #", 1000, 0., 0.1);
296 fhEFG_invmass_direct = new TH1D("fhEFG_invmass_direct", "fhEFG_invmass_direct; invmass [GeV/c^2]; #", 1000, 0., 0.1);
297 fhEFG_invmass_pi0 = new TH1D("fhEFG_invmass_pi0", "fhEFG_invmass_pi0; invmass [GeV/c^2]; #", 1000, 0., 0.1);
298 fhEFG_invmass_eta = new TH1D("fhEFG_invmass_eta", "fhEFG_invmass_eta; invmass [GeV/c^2]; #", 1000, 0., 0.1);
299 fHistoList_EFG_invmass.push_back(fhEFG_invmass_all);
300 fHistoList_EFG_invmass.push_back(fhEFG_invmass_combBack);
301 fHistoList_EFG_invmass.push_back(fhEFG_invmass_allSameG);
302 fHistoList_EFG_invmass.push_back(fhEFG_invmass_direct);
303 fHistoList_EFG_invmass.push_back(fhEFG_invmass_pi0);
304 fHistoList_EFG_invmass.push_back(fhEFG_invmass_eta);
305 fhEFG_energy_all = new TH1D("fhEFG_energy_all", "fhEFG_energy_all; energy [GeV]; #", 1000, 0., 50);
306 fhEFG_energy_combBack = new TH1D("fhEFG_energy_combBack", "fhEFG_energy_combBack; energy [GeV]; #", 1000, 0., 50);
307 fhEFG_energy_allSameG = new TH1D("fhEFG_energy_allSameG", "fhEFG_energy_allSameG; energy [GeV]; #", 1000, 0., 50);
308 fhEFG_energy_direct = new TH1D("fhEFG_energy_direct", "fhEFG_energy_direct; energy [GeV]; #", 1000, 0., 50);
309 fhEFG_energy_pi0 = new TH1D("fhEFG_energy_pi0", "fhEFG_energy_pi0; energy [GeV]; #", 1000, 0., 50);
310 fhEFG_energy_eta = new TH1D("fhEFG_energy_eta", "fhEFG_energy_eta; energy [GeV]; #", 1000, 0., 50);
311 fHistoList_EFG_energy.push_back(fhEFG_energy_all);
312 fHistoList_EFG_energy.push_back(fhEFG_energy_combBack);
313 fHistoList_EFG_energy.push_back(fhEFG_energy_allSameG);
314 fHistoList_EFG_energy.push_back(fhEFG_energy_direct);
315 fHistoList_EFG_energy.push_back(fhEFG_energy_pi0);
316 fHistoList_EFG_energy.push_back(fhEFG_energy_eta);
317
318 // opening angles for photon-energies below 1 GeV
319 fhEFG_angleBelow1GeV_all =
320 new TH1D("fhEFG_angleBelow1GeV_all", "fhEFG_angleBelow1GeV_all; opening angle [deg]; #", 2000, 0., 100.);
321 fhEFG_angleBelow1GeV_combBack =
322 new TH1D("fhEFG_angleBelow1GeV_combBack", "fhEFG_angleBelow1GeV_combBack; opening angle [deg]; #", 2000, 0., 100.);
323 fhEFG_angleBelow1GeV_allSameG =
324 new TH1D("fhEFG_angleBelow1GeV_allSameG", "fhEFG_angleBelow1GeV_allSameG; opening angle [deg]; #", 400, 0., 20.);
325 fhEFG_angleBelow1GeV_direct =
326 new TH1D("fhEFG_angleBelow1GeV_direct", "fhEFG_angleBelow1GeV_direct; opening angle [deg]; #", 400, 0., 20.);
327 fhEFG_angleBelow1GeV_pi0 =
328 new TH1D("fhEFG_angleBelow1GeV_pi0", "fhEFG_angleBelow1GeV_pi0; opening angle [deg]; #", 400, 0., 20.);
329 fhEFG_angleBelow1GeV_eta =
330 new TH1D("fhEFG_angleBelow1GeV_eta", "fhEFG_angleBelow1GeV_eta; opening angle [deg]; #", 400, 0., 20.);
331 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_all);
332 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_combBack);
333 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_allSameG);
334 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_direct);
335 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_pi0);
336 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_eta);
337
338 // opening angles for photon-energies above 1 GeV
339 fhEFG_angleAbove1GeV_all =
340 new TH1D("fhEFG_angleAbove1GeV_all", "fhEFG_angleAbove1GeV_all; opening angle [deg]; #", 2000, 0., 100.);
341 fhEFG_angleAbove1GeV_combBack =
342 new TH1D("fhEFG_angleAbove1GeV_combBack", "fhEFG_angleAbove1GeV_combBack; opening angle [deg]; #", 2000, 0., 100.);
343 fhEFG_angleAbove1GeV_allSameG =
344 new TH1D("fhEFG_angleAbove1GeV_allSameG", "fhEFG_angleAbove1GeV_allSameG; opening angle [deg]; #", 400, 0., 20.);
345 fhEFG_angleAbove1GeV_direct =
346 new TH1D("fhEFG_angleAbove1GeV_direct", "fhEFG_angleAbove1GeV_direct; opening angle [deg]; #", 400, 0., 20.);
347 fhEFG_angleAbove1GeV_pi0 =
348 new TH1D("fhEFG_angleAbove1GeV_pi0", "fhEFG_angleAbove1GeV_pi0; opening angle [deg]; #", 400, 0., 20.);
349 fhEFG_angleAbove1GeV_eta =
350 new TH1D("fhEFG_angleAbove1GeV_eta", "fhEFG_angleAbove1GeV_eta; opening angle [deg]; #", 400, 0., 20.);
351 fHistoList_EFG_angle.push_back(fhEFG_angleAbove1GeV_all);
352 fHistoList_EFG_angle.push_back(fhEFG_angleAbove1GeV_combBack);
353 fHistoList_EFG_angle.push_back(fhEFG_angleAbove1GeV_allSameG);
354 fHistoList_EFG_angle.push_back(fhEFG_angleAbove1GeV_direct);
355 fHistoList_EFG_angle.push_back(fhEFG_angleAbove1GeV_pi0);
356 fHistoList_EFG_angle.push_back(fhEFG_angleAbove1GeV_eta);
357
358 // opening angle vs energy (MC)
359 //fhEFG_angleVSenergy_all = new TH2D("fhEFG_angleVSenergy_all", "fhEFG_angleVSenergy_all;opening angle [deg];energy [GeV]", 2000, 0., 100., 5000, 0., 50.);
360 //fhEFG_angleVSenergy_combBack = new TH2D("fhEFG_angleVSenergy_combBack", "fhEFG_angleVSenergy_combBack;opening angle [deg];energy [GeV]", 2000, 0., 100., 5000, 0., 50.);
361 fhEFG_angleVSenergy_allSameG =
362 new TH2D("fhEFG_angleVSenergy_allSameG", "fhEFG_angleVSenergy_allSameG;energy [GeV];opening angle [deg]", 5000, 0.,
363 50., 400, 0., 20.);
364 fhEFG_angleVSenergy_direct =
365 new TH2D("fhEFG_angleVSenergy_direct", "fhEFG_angleVSenergy_direct;energy [GeV];opening angle [deg]", 5000, 0., 50.,
366 400, 0., 20.);
367 fhEFG_angleVSenergy_pi0 = new TH2D(
368 "fhEFG_angleVSenergy_pi0", "fhEFG_angleVSenergy_pi0;energy [GeV];opening angle [deg]", 5000, 0., 50., 400, 0., 20.);
369 fhEFG_angleVSenergy_eta = new TH2D(
370 "fhEFG_angleVSenergy_eta", "fhEFG_angleVSenergy_eta;energy [GeV];opening angle [deg]", 5000, 0., 50., 400, 0., 20.);
371 //fHistoList_EFG_angle.push_back(fhEFG_angleVSenergy_all);
372 //fHistoList_EFG_angle.push_back(fhEFG_angleVSenergy_combBack);
373 fHistoList_EFG_angle.push_back(fhEFG_angleVSenergy_allSameG);
374 fHistoList_EFG_angle.push_back(fhEFG_angleVSenergy_direct);
375 fHistoList_EFG_angle.push_back(fhEFG_angleVSenergy_pi0);
376 fHistoList_EFG_angle.push_back(fhEFG_angleVSenergy_eta);
377
378 // opening angle vs pt (MC)
379 fhEFG_angleVSpt_all =
380 new TH2D("fhEFG_angleVSpt_all", "fhEFG_angleVSpt_all;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
381 fhEFG_angleVSpt_combBack = new TH2D(
382 "fhEFG_angleVSpt_combBack", "fhEFG_angleVSpt_combBack;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
383 fhEFG_angleVSpt_allSameG = new TH2D(
384 "fhEFG_angleVSpt_allSameG", "fhEFG_angleVSpt_allSameG;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
385 fhEFG_angleVSpt_direct = new TH2D("fhEFG_angleVSpt_direct", "fhEFG_angleVSpt_direct;pt [GeV/c];opening angle [deg]",
386 500, 0., 5., 400, 0., 20.);
387 fhEFG_angleVSpt_pi0 =
388 new TH2D("fhEFG_angleVSpt_pi0", "fhEFG_angleVSpt_pi0;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
389 fhEFG_angleVSpt_eta =
390 new TH2D("fhEFG_angleVSpt_eta", "fhEFG_angleVSpt_eta;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
391 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_all);
392 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_combBack);
393 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_allSameG);
394 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_direct);
395 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_pi0);
396 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_eta);
397
398 // momentum of the e+e- pair (sum)
399 fhEFG_momentumPair_all = new TH1D("fhEFG_momentumPair_all", "fhEFG_momentumPair_all; energy [GeV]; #", 1000, 0., 50);
400 fhEFG_momentumPair_combBack =
401 new TH1D("fhEFG_momentumPair_combBack", "fhEFG_momentumPair_combBack; energy [GeV]; #", 1000, 0., 50);
402 fhEFG_momentumPair_allSameG =
403 new TH1D("fhEFG_momentumPair_allSameG", "fhEFG_momentumPair_allSameG; energy [GeV]; #", 1000, 0., 50);
404 fhEFG_momentumPair_direct =
405 new TH1D("fhEFG_momentumPair_direct", "fhEFG_momentumPair_direct; energy [GeV]; #", 1000, 0., 50);
406 fhEFG_momentumPair_pi0 = new TH1D("fhEFG_momentumPair_pi0", "fhEFG_momentumPair_pi0; energy [GeV]; #", 1000, 0., 50);
407 fhEFG_momentumPair_eta = new TH1D("fhEFG_momentumPair_eta", "fhEFG_momentumPair_eta; energy [GeV]; #", 1000, 0., 50);
408 fHistoList_EFG.push_back(fhEFG_momentumPair_all);
409 fHistoList_EFG.push_back(fhEFG_momentumPair_combBack);
410 fHistoList_EFG.push_back(fhEFG_momentumPair_allSameG);
411 fHistoList_EFG.push_back(fhEFG_momentumPair_direct);
412 fHistoList_EFG.push_back(fhEFG_momentumPair_pi0);
413 fHistoList_EFG.push_back(fhEFG_momentumPair_eta);
414
415 //fhEFG_startvertexVSangle_all = new TH2D("fhEFG_startvertexVSangle_all", "fhEFG_startvertexVSangle_all; startvertex; angle", 100, -0.01, 0.02, 2000, 0., 100.);
416 //fhEFG_startvertexVSangle_combBack = new TH2D("fhEFG_startvertexVSangle_combBack", "fhEFG_startvertexVSangle_combBack; startvertex; angle", 100, -0.01, 0.02, 2000, 0., 100.);
417 fhEFG_startvertexVSangle_allSameG =
418 new TH2D("fhEFG_startvertexVSangle_allSameG", "fhEFG_startvertexVSangle_allSameG; startvertex [cm]; angle [deg]",
419 200, -0.02, 0.02, 400, 0., 20.);
420 fhEFG_startvertexVSangle_direct =
421 new TH2D("fhEFG_startvertexVSangle_direct", "fhEFG_startvertexVSangle_direct; startvertex [cm]; angle [deg]", 200,
422 -0.02, 0.02, 400, 0., 20.);
423 fhEFG_startvertexVSangle_pi0 =
424 new TH2D("fhEFG_startvertexVSangle_pi0", "fhEFG_startvertexVSangle_pi0; startvertex [cm]; angle [deg]", 200, -0.02,
425 0.02, 400, 0., 20.);
426 fhEFG_startvertexVSangle_eta =
427 new TH2D("fhEFG_startvertexVSangle_eta", "fhEFG_startvertexVSangle_eta; startvertex [cm]; angle [deg]", 200, -0.02,
428 0.02, 400, 0., 20.);
429 //fHistoList_EFG.push_back(fhEFG_startvertexVSangle_all);
430 //fHistoList_EFG.push_back(fhEFG_startvertexVSangle_combBack);
431 fHistoList_EFG.push_back(fhEFG_startvertexVSangle_allSameG);
432 fHistoList_EFG.push_back(fhEFG_startvertexVSangle_direct);
433 fHistoList_EFG.push_back(fhEFG_startvertexVSangle_pi0);
434 fHistoList_EFG.push_back(fhEFG_startvertexVSangle_eta);
435
436 fhEFG_startvertex_allSameG =
437 new TH1D("fhEFG_startvertex_allSameG", "fhEFG_startvertex_allSameG; startvertex [cm];#", 200, -0.02, 0.02);
438 fHistoList_EFG.push_back(fhEFG_startvertex_allSameG);
439
440
441 // opening angles for all photon-energies (RECO)
442 fhEFG_angle_all_reco =
443 new TH1D("fhEFG_angle_all_reco", "fhEFG_angle_all_reco; opening angle [deg]; #", 2001, -0.05, 200.05);
444 fhEFG_angle_combBack_reco =
445 new TH1D("fhEFG_angle_combBack_reco", "fhEFG_angle_combBack_reco; opening angle [deg]; #", 2001, -0.05, 200.05);
446 fhEFG_angle_allSameG_reco =
447 new TH1D("fhEFG_angle_allSameG_reco", "fhEFG_angle_allSameG_reco; opening angle [deg]; #", 1001, -0.05, 100.05);
448 fhEFG_angle_direct_reco =
449 new TH1D("fhEFG_angle_direct_reco", "fhEFG_angle_direct_reco; opening angle [deg]; #", 1001, -0.05, 100.05);
450 fhEFG_angle_pi0_reco =
451 new TH1D("fhEFG_angle_pi0_reco", "fhEFG_angle_pi0_reco; opening angle [deg]; #", 1001, -0.05, 100.05);
452 fhEFG_angle_eta_reco =
453 new TH1D("fhEFG_angle_eta_reco", "fhEFG_angle_eta_reco; opening angle [deg]; #", 1001, -0.05, 100.05);
454 fHistoList_EFG_angle.push_back(fhEFG_angle_all_reco);
455 fHistoList_EFG_angle.push_back(fhEFG_angle_combBack_reco);
456 fHistoList_EFG_angle.push_back(fhEFG_angle_allSameG_reco);
457 fHistoList_EFG_angle.push_back(fhEFG_angle_direct_reco);
458 fHistoList_EFG_angle.push_back(fhEFG_angle_pi0_reco);
459 fHistoList_EFG_angle.push_back(fhEFG_angle_eta_reco);
460
461
462 // histogram for comparison of different opening angle cuts and their influence on signal and background amounts
463 fhEFG_angle_reco_CUTcomparison =
464 new TH1I("fhEFG_angle_reco_CUTcomparison", "fhEFG_angle_reco_CUTcomparison; ; #", 12, 0., 12.);
465 fHistoList_EFG_angle.push_back(fhEFG_angle_reco_CUTcomparison);
466 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(1, "true, no cut");
467 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(2, "false, no cut");
468 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(3, "true, cut1");
469 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(4, "false, cut1");
470 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(5, "true, cut2");
471 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(6, "false, cut2");
472 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(7, "true, cut3");
473 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(8, "false, cut3");
474 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(9, "true, cut4");
475 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(10, "false, cut4");
476 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(11, "true, cut5");
477 fhEFG_angle_reco_CUTcomparison->GetXaxis()->SetBinLabel(12, "false, cut5");
478
479
480 // opening angles for all photon-energies (RECO) with application of opening angle cuts
481 fhEFG_angle_all_reco_cuts =
482 new TH1D("fhEFG_angle_all_reco_cuts", "fhEFG_angle_all_reco_cuts; opening angle [deg]; #", 101, -0.05, 10.05);
483 fhEFG_angle_combBack_reco_cuts = new TH1D(
484 "fhEFG_angle_combBack_reco_cuts", "fhEFG_angle_combBack_reco_cuts; opening angle [deg]; #", 101, -0.05, 10.05);
485 fhEFG_angle_allSameG_reco_cuts = new TH1D(
486 "fhEFG_angle_allSameG_reco_cuts", "fhEFG_angle_allSameG_reco_cuts; opening angle [deg]; #", 101, -0.05, 10.05);
487 fHistoList_EFG_angle.push_back(fhEFG_angle_all_reco_cuts);
488 fHistoList_EFG_angle.push_back(fhEFG_angle_combBack_reco_cuts);
489 fHistoList_EFG_angle.push_back(fhEFG_angle_allSameG_reco_cuts);
490
491
492 // opening angles for photon-energies below 1 GeV (RECO)
493 fhEFG_angleBelow1GeV_all_reco =
494 new TH1D("fhEFG_angleBelow1GeV_all_reco", "fhEFG_angleBelow1GeV_all_reco; opening angle [deg]; #", 2000, 0., 100.);
495 fhEFG_angleBelow1GeV_combBack_reco = new TH1D(
496 "fhEFG_angleBelow1GeV_combBack_reco", "fhEFG_angleBelow1GeV_combBack_reco; opening angle [deg]; #", 2000, 0., 100.);
497 fhEFG_angleBelow1GeV_allSameG_reco = new TH1D(
498 "fhEFG_angleBelow1GeV_allSameG_reco", "fhEFG_angleBelow1GeV_allSameG_reco; opening angle [deg]; #", 2000, 0., 100.);
499 fhEFG_angleBelow1GeV_direct_reco = new TH1D(
500 "fhEFG_angleBelow1GeV_direct_reco", "fhEFG_angleBelow1GeV_direct_reco; opening angle [deg]; #", 2000, 0., 100.);
501 fhEFG_angleBelow1GeV_pi0_reco =
502 new TH1D("fhEFG_angleBelow1GeV_pi0_reco", "fhEFG_angleBelow1GeV_pi0_reco; opening angle [deg]; #", 2000, 0., 100.);
503 fhEFG_angleBelow1GeV_eta_reco =
504 new TH1D("fhEFG_angleBelow1GeV_eta_reco", "fhEFG_angleBelow1GeV_eta_reco; opening angle [deg]; #", 2000, 0., 100.);
505 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_all_reco);
506 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_combBack_reco);
507 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_allSameG_reco);
508 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_direct_reco);
509 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_pi0_reco);
510 fHistoList_EFG_angle.push_back(fhEFG_angleBelow1GeV_eta_reco);
511
512 fhEFG_invmass_all_reco =
513 new TH1D("fhEFG_invmass_all_reco", "fhEFG_invmass_all_reco; invmass [GeV/c^2]; #", 5000, 0., 5.);
514 fhEFG_invmass_combBack_reco =
515 new TH1D("fhEFG_invmass_combBack_reco", "fhEFG_invmass_combBack_reco; invmass [GeV/c^2]; #", 5000, 0., 5.);
516 fhEFG_invmass_allSameG_reco =
517 new TH1D("fhEFG_invmass_allSameG_reco", "fhEFG_invmass_allSameG_reco; invmass [GeV/c^2]; #", 5000, 0., 5);
518 fhEFG_invmass_direct_reco =
519 new TH1D("fhEFG_invmass_direct_reco", "fhEFG_invmass_direct_reco; invmass [GeV/c^2]; #", 5000, 0., 5);
520 fhEFG_invmass_pi0_reco =
521 new TH1D("fhEFG_invmass_pi0_reco", "fhEFG_invmass_pi0_reco; invmass [GeV/c^2]; #", 5000, 0., 5);
522 fhEFG_invmass_eta_reco =
523 new TH1D("fhEFG_invmass_eta_reco", "fhEFG_invmass_eta_reco; invmass [GeV/c^2]; #", 5000, 0., 5);
524 fHistoList_EFG_invmass.push_back(fhEFG_invmass_all_reco);
525 fHistoList_EFG_invmass.push_back(fhEFG_invmass_combBack_reco);
526 fHistoList_EFG_invmass.push_back(fhEFG_invmass_allSameG_reco);
527 fHistoList_EFG_invmass.push_back(fhEFG_invmass_direct_reco);
528 fHistoList_EFG_invmass.push_back(fhEFG_invmass_pi0_reco);
529 fHistoList_EFG_invmass.push_back(fhEFG_invmass_eta_reco);
530
531 fhEFG_invmass_all_reco_cut =
532 new TH1D("fhEFG_invmass_all_reco_cut", "fhEFG_invmass_all_reco_cut; invmass [GeV/c^2]; #", 5000, 0., 5.);
533 fhEFG_invmass_combBack_reco_cut =
534 new TH1D("fhEFG_invmass_combBack_reco_cut", "fhEFG_invmass_combBack_reco_cut; invmass [GeV/c^2]; #", 5000, 0., 5.);
535 fhEFG_invmass_allSameG_reco_cut =
536 new TH1D("fhEFG_invmass_allSameG_reco_cut", "fhEFG_invmass_allSameG_reco_cut; invmass [GeV/c^2]; #", 5000, 0., 5);
537 fhEFG_invmass_direct_reco_cut =
538 new TH1D("fhEFG_invmass_direct_reco_cut", "fhEFG_invmass_direct_reco_cut; invmass [GeV/c^2]; #", 5000, 0., 5);
539 fhEFG_invmass_pi0_reco_cut =
540 new TH1D("fhEFG_invmass_pi0_reco_cut", "fhEFG_invmass_pi0_reco_cut; invmass [GeV/c^2]; #", 5000, 0., 5);
541 fhEFG_invmass_eta_reco_cut =
542 new TH1D("fhEFG_invmass_eta_reco_cut", "fhEFG_invmass_eta_reco_cut; invmass [GeV/c^2]; #", 5000, 0., 5);
543 fHistoList_EFG_invmass.push_back(fhEFG_invmass_all_reco_cut);
544 fHistoList_EFG_invmass.push_back(fhEFG_invmass_combBack_reco_cut);
545 fHistoList_EFG_invmass.push_back(fhEFG_invmass_allSameG_reco_cut);
546 fHistoList_EFG_invmass.push_back(fhEFG_invmass_direct_reco_cut);
547 fHistoList_EFG_invmass.push_back(fhEFG_invmass_pi0_reco_cut);
548 fHistoList_EFG_invmass.push_back(fhEFG_invmass_eta_reco_cut);
549
550
551 // opening angle vs pt (reco)
552 fhEFG_angleVSpt_all_reco = new TH2D(
553 "fhEFG_angleVSpt_all_reco", "fhEFG_angleVSpt_all_reco;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
554 fhEFG_angleVSpt_combBack_reco =
555 new TH2D("fhEFG_angleVSpt_combBack_reco", "fhEFG_angleVSpt_combBack_reco;pt [GeV/c];opening angle [deg]", 500, 0.,
556 5., 400, 0., 20.);
557 fhEFG_angleVSpt_allSameG_reco =
558 new TH2D("fhEFG_angleVSpt_allSameG_reco", "fhEFG_angleVSpt_allSameG_reco;pt [GeV/c];opening angle [deg]", 500, 0.,
559 5., 400, 0., 20.);
560 fhEFG_angleVSpt_direct_reco =
561 new TH2D("fhEFG_angleVSpt_direct_reco", "fhEFG_angleVSpt_direct_reco;pt [GeV/c];opening angle [deg]", 500, 0., 5.,
562 400, 0., 20.);
563 fhEFG_angleVSpt_pi0_reco = new TH2D(
564 "fhEFG_angleVSpt_pi0_reco", "fhEFG_angleVSpt_pi0_reco;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
565 fhEFG_angleVSpt_eta_reco = new TH2D(
566 "fhEFG_angleVSpt_eta_reco", "fhEFG_angleVSpt_eta_reco;pt [GeV/c];opening angle [deg]", 500, 0., 5., 400, 0., 20.);
567 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_all_reco);
568 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_combBack_reco);
569 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_allSameG_reco);
570 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_direct_reco);
571 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_pi0_reco);
572 fHistoList_EFG_angle.push_back(fhEFG_angleVSpt_eta_reco);
573
574
575 // invariant mass vs pt (reco)
576 fhEFG_invmassVSpt_all_reco = new TH2D(
577 "fhEFG_invmassVSpt_all_reco", "fhEFG_invmassVSpt_all_reco;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
578 fhEFG_invmassVSpt_combBack_reco =
579 new TH2D("fhEFG_invmassVSpt_combBack_reco", "fhEFG_invmassVSpt_combBack_reco;pt [GeV/c];invmass [GeV]", 500, 0., 5.,
580 5000, 0., 5.);
581 fhEFG_invmassVSpt_allSameG_reco =
582 new TH2D("fhEFG_invmassVSpt_allSameG_reco", "fhEFG_invmassVSpt_allSameG_reco;pt [GeV/c];invmass [GeV]", 500, 0., 5.,
583 5000, 0., 5.);
584 fhEFG_invmassVSpt_direct_reco =
585 new TH2D("fhEFG_invmassVSpt_direct_reco", "fhEFG_invmassVSpt_direct_reco;pt [GeV/c];invmass [GeV]", 500, 0., 5.,
586 5000, 0., 5.);
587 fhEFG_invmassVSpt_pi0_reco = new TH2D(
588 "fhEFG_invmassVSpt_pi0_reco", "fhEFG_invmassVSpt_pi0_reco;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
589 fhEFG_invmassVSpt_eta_reco = new TH2D(
590 "fhEFG_invmassVSpt_eta_reco", "fhEFG_invmassVSpt_eta_reco;pt [GeV/c];invmass [GeV]", 500, 0., 5., 5000, 0., 5.);
591 fHistoList_EFG_invmass.push_back(fhEFG_invmassVSpt_all_reco);
592 fHistoList_EFG_invmass.push_back(fhEFG_invmassVSpt_combBack_reco);
593 fHistoList_EFG_invmass.push_back(fhEFG_invmassVSpt_allSameG_reco);
594 fHistoList_EFG_invmass.push_back(fhEFG_invmassVSpt_direct_reco);
595 fHistoList_EFG_invmass.push_back(fhEFG_invmassVSpt_pi0_reco);
596 fHistoList_EFG_invmass.push_back(fhEFG_invmassVSpt_eta_reco);
597
598
599 fhEFG_momentumResolutionPhoton_reco =
600 new TH2D("fhEFG_momentumResolutionPhoton_reco", "fhEFG_momentumResolutionPhoton_reco;p [GeV/c]; dp/p [%]", 20, 0.,
601 20., 800, 0., 200.);
602 fhEFG_momentumResolutionElectrons_reco =
603 new TH2D("fhEFG_momentumResolutionElectrons_reco", "fhEFG_momentumResolutionElectrons_reco;p [GeV/c]; dp/p [%]", 20,
604 0., 20., 1600, 0., 400.);
605 fHistoList_EFG.push_back(fhEFG_momentumResolutionPhoton_reco);
606 fHistoList_EFG.push_back(fhEFG_momentumResolutionElectrons_reco);
607
608
609 fhEFPI0_angle_reco = new TH1D("fhEFPI0_angle_reco", "fhEFPI0_angle_reco; opening angle [deg]; #", 500, 0., 50.);
610 fHistoList_photons.push_back(fhEFPI0_angle_reco);
611
612
613 fhG_invmass = new TH1D("fhG_invmass", "fhG_invmass; invmass [GeV/c^2]; #", 10000, 0., 1.);
614 fHistoList_photons.push_back(fhG_invmass);
615 fhG_invmass_pi0 = new TH1D("fhG_invmass_pi0", "fhG_invmass_pi0; invmass [GeV/c^2]; #", 10000, 0., 1.);
616 fHistoList_photons.push_back(fhG_invmass_pi0);
617}
618
619
620void CbmAnaConversionPhotons::Finish()
621{
622 //gDirectory->cd("analysis-conversion");
623 gDirectory->mkdir("Photons");
624 gDirectory->cd("Photons");
625
626 gDirectory->mkdir("electrons from gamma");
627 gDirectory->cd("electrons from gamma");
628
629 gDirectory->mkdir("angle");
630 gDirectory->mkdir("invariant mass");
631 gDirectory->mkdir("energy");
632
633 gDirectory->cd("angle");
634 for (UInt_t i = 0; i < fHistoList_EFG_angle.size(); i++) {
635 fHistoList_EFG_angle[i]->Write();
636 }
637 gDirectory->cd("..");
638
639 gDirectory->cd("invariant mass");
640 for (UInt_t i = 0; i < fHistoList_EFG_invmass.size(); i++) {
641 fHistoList_EFG_invmass[i]->Write();
642 }
643 gDirectory->cd("..");
644
645 gDirectory->cd("energy");
646 for (UInt_t i = 0; i < fHistoList_EFG_energy.size(); i++) {
647 fHistoList_EFG_energy[i]->Write();
648 }
649 gDirectory->cd("..");
650
651
652 for (UInt_t i = 0; i < fHistoList_EFG.size(); i++) {
653 fHistoList_EFG[i]->Write();
654 }
655 gDirectory->cd("..");
656
657 for (UInt_t i = 0; i < fHistoList_photons.size(); i++) {
658 fHistoList_photons[i]->Write();
659 }
660 gDirectory->cd("..");
661
662
663 cout << "CbmAnaConversionPhotons: Realtime - " << fTime << endl;
664 //timer.Print();
665
666 cout << "CbmAnaConversionPhotons: all MC direct photons: " << global_nof_photonsMC
667 << ", all reconstructible direct photons: " << global_nof_photonsReco << " => "
668 << 1.0 * global_nof_photonsReco / (1.0 * global_nof_photonsMC) * 100 << " % can be reconstructed!" << endl;
669
670
671 // normalisation of some histograms
672 fPhotonsRest_ptMC_pi0->Scale(1.0 / (1.0 * fPhotonsRest_ptMC_pi0->Integral()));
673 fPhotonsRest_ptMC_n->Scale(1.0 / fPhotonsRest_ptMC_n->Integral());
674 fPhotonsRest_ptMC_e->Scale(1.0 / fPhotonsRest_ptMC_e->Integral());
675
676 // TCanvas* c = new TCanvas();
677 // c->SetWindowSize(1600, 1600);
678 // DrawH1(fPhotonsRest_ptMC_pi0);
679 // DrawH1(fPhotonsRest_ptMC_n);
680 // DrawH1(fPhotonsRest_ptMC_e);
681 // DrawH1(fPhotonsRest_ptMC_eta);
682}
683
684
685void CbmAnaConversionPhotons::Exec()
686{
687 timer.Start();
688
689
690 if (fPrimVertex != NULL) { fKFVertex = CbmKFVertex(*fPrimVertex); }
691 else {
692 Fatal("CbmAnaConversion::Exec", "No PrimaryVertex array!");
693 }
694
695 int nofDirectPhotons = 0;
696
697 fMCTracklist.clear();
698 fMCTracklist_allElectronsFromGamma.clear();
699 fRecoTracklist_allElectronsFromGamma.clear();
700 fRecoTracklist_allElectronsFromGammaMom.clear();
701 fRecoTracklist_allElectronsFromPi0.clear();
702 fRecoTracklist_allElectronsFromPi0Mom.clear();
703 fMCTracklist_allGammas.clear();
704 fMCTracklist_allGammasFromPi0.clear();
705
706 //AnalysePhotons();
707
708 // everything related to MC-true data
709 Int_t nofMcTracks = fMcTracks->GetEntriesFast();
710 for (int i = 0; i < nofMcTracks; i++) {
711 CbmMCTrack* mctrack = (CbmMCTrack*) fMcTracks->At(i);
712 if (mctrack == NULL) continue;
713 int pdg = TMath::Abs(mctrack->GetPdgCode());
714 if (pdg == 11)
715 FillMCTracklist_allElectrons(mctrack); // filling tracklist with all electrons with mother gamma (in function)
716 if (pdg == 22) FillMCTracklist_allGammas(mctrack);
717
718 nofDirectPhotons += CheckMC(mctrack);
719 }
720
721 fPhotons_nofPerEvent->Fill(nofDirectPhotons);
722 global_nof_photonsMC += nofDirectPhotons;
723
724 AnalyseElectronsFromGammaMC();
725 AnalyseGammas();
726
727
728 // everything related to reconstructed data
729 Int_t nofGlobalTracks = fGlobalTracks->GetEntriesFast();
730 for (int iG = 0; iG < nofGlobalTracks; iG++) {
731 CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iG);
732 if (NULL == gTrack) continue;
733 int stsInd = gTrack->GetStsTrackIndex();
734 int richInd = gTrack->GetRichRingIndex();
735 if (richInd < 0) continue;
736 if (stsInd < 0) continue;
737
738 CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsInd);
739 if (stsTrack == NULL) continue;
740
741 CbmTrackMatchNew* stsMatch = (CbmTrackMatchNew*) fStsTrackMatches->At(stsInd);
742 if (stsMatch == NULL) continue;
743 int stsMcTrackId = stsMatch->GetMatchedLink().GetIndex();
744 if (stsMcTrackId < 0) continue;
745 CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId);
746 if (mcTrack1 == NULL) continue;
747
748 CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(richInd);
749 if (richMatch == NULL) continue;
750 int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
751 if (richMcTrackId < 0) continue;
752 CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
753 if (mcTrack2 == NULL) continue;
754
755 if (stsMcTrackId != richMcTrackId) continue;
756
757 int pdg = TMath::Abs(mcTrack1->GetPdgCode());
758
759
760 // calculate refitted momenta at primary vertex
761 TVector3 refittedMomentum;
762 CbmL1PFFitter fPFFitter;
763 vector<CbmStsTrack> stsTracks;
764 stsTracks.resize(1);
765 stsTracks[0] = *stsTrack;
766 vector<CbmL1PFFitter::PFFieldRegion> vField;
767 vector<float> chiPrim;
768 fPFFitter.GetChiToVertex(stsTracks, vField, chiPrim, fKFVertex, 3e6);
769 //cand.chi2sts = stsTracks[0].GetChiSq() / stsTracks[0].GetNDF();
770 //cand.chi2Prim = chiPrim[0];
771 const FairTrackParam* vtxTrack = stsTracks[0].GetParamFirst();
772 vtxTrack->Momentum(refittedMomentum);
773
774
775 // Doing refit of momenta with electron assumption
776 CbmL1PFFitter fPFFitter_electron;
777 vector<CbmStsTrack> stsTracks_electron;
778 stsTracks_electron.resize(1);
779 stsTracks_electron[0] = *stsTrack;
780 vector<CbmL1PFFitter::PFFieldRegion> vField_electron;
781 vector<float> chiPrim_electron;
782 vector<int> pidHypo_electron;
783 pidHypo_electron.push_back(11);
784 fPFFitter_electron.Fit(stsTracks_electron, pidHypo_electron);
785 fPFFitter_electron.GetChiToVertex(stsTracks_electron, vField_electron, chiPrim_electron, fKFVertex, 3e6);
786
787 TVector3 refittedMomentum_electron;
788 const FairTrackParam* vtxTrack_electron = stsTracks_electron[0].GetParamFirst();
789 vtxTrack_electron->Momentum(refittedMomentum_electron);
790 refittedMomentum = refittedMomentum_electron;
791
792
793 if (pdg == 11) FillRecoTracklist_allElectrons(mcTrack1, refittedMomentum);
794
795 if (pdg == 11) {
796 int motherID = mcTrack1->GetMotherId();
797 if (motherID == -1) continue;
798 CbmMCTrack* mothermcTrack1 = (CbmMCTrack*) fMcTracks->At(motherID);
799 int motherpdg = TMath::Abs(mothermcTrack1->GetPdgCode());
800 if (motherpdg != 22) continue;
801 int grandmotherID = mothermcTrack1->GetMotherId();
802 if (grandmotherID != -1) continue;
803
804 //nof_photons++;
805 fPhotons_pt->Fill(mothermcTrack1->GetPt());
806 FillMCTracklist(mcTrack1);
807 }
808 }
809
810 CombineElectrons();
811 AnalyseElectronsFromGammaReco();
812 AnalyseElectronsFromPi0Reco();
813
814
815 timer.Stop();
816 cout << "CbmAnaConversionPhotons: time spent (Exec) " << timer.RealTime() << endl;
817 fTime += timer.RealTime();
818}
819
820
821void CbmAnaConversionPhotons::AnalysePhotons()
822{
823 Int_t nof_photons = 0;
824
825 Int_t nofGlobalTracks = fGlobalTracks->GetEntriesFast();
826 for (int iG = 0; iG < nofGlobalTracks; iG++) {
827 CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iG);
828 if (NULL == gTrack) continue;
829 int stsInd = gTrack->GetStsTrackIndex();
830 int richInd = gTrack->GetRichRingIndex();
831 if (richInd < 0) continue; // no RICH segment -> no ring
832 if (stsInd < 0) continue;
833
834 CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsInd);
835 if (stsTrack == NULL) continue;
836
837 CbmTrackMatchNew* stsMatch = (CbmTrackMatchNew*) fStsTrackMatches->At(stsInd);
838 if (stsMatch == NULL) continue;
839 int stsMcTrackId = stsMatch->GetMatchedLink().GetIndex();
840 if (stsMcTrackId < 0) continue;
841 CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId);
842 if (mcTrack1 == NULL) continue;
843
844 CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(richInd);
845 if (richMatch == NULL) continue;
846 int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
847 if (richMcTrackId < 0) continue;
848 CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
849 if (mcTrack2 == NULL) continue;
850
851 // stsMcTrackId == richMcTrackId -> track was reconstructed in STS and made a ring in RICH, track matching was correct
852 // in case they are not equal, the ring comes either from a secondary particle or STS track was not reconstructed
853 if (stsMcTrackId != richMcTrackId) continue;
854
855 int pdg = TMath::Abs(mcTrack2->GetPdgCode()); // extract pdg code of particle directly from rich ring
856
857 if (pdg == 11) {
858 int motherID = mcTrack1->GetMotherId();
859 if (motherID == -1) continue;
860 CbmMCTrack* mothermcTrack1 = (CbmMCTrack*) fMcTracks->At(motherID);
861 int motherpdg = TMath::Abs(mothermcTrack1->GetPdgCode());
862 if (motherpdg != 22) continue;
863 int grandmotherID = mothermcTrack1->GetMotherId();
864 if (grandmotherID != -1) continue;
865
866 nof_photons++;
867 fPhotons_pt->Fill(mothermcTrack1->GetPt());
868 FillMCTracklist(mcTrack1);
869 }
870 }
871
872 //fPhotons_nofPerEvent->Fill(nof_photons);
873
874 CombineElectrons();
875}
876
877
878void CbmAnaConversionPhotons::FillMCTracklist(CbmMCTrack* mctrack)
879{
880 fMCTracklist.push_back(mctrack);
881 int motherID = mctrack->GetMotherId();
882 CbmMCTrack* mothermctrack = (CbmMCTrack*) fMcTracks->At(motherID);
883 int motherpdg = mothermctrack->GetPdgCode();
884 cout << "CbmAnaConversionPhotons: filling tracklist, pdg " << mctrack->GetPdgCode() << " - motherpdg " << motherpdg
885 << " - motherID " << motherID << endl;
886}
887
888
889void CbmAnaConversionPhotons::FillMCTracklist_allElectrons(CbmMCTrack* mctrack)
890{
891 int motherID = mctrack->GetMotherId();
892 TVector3 startvertex;
893 mctrack->GetStartVertex(startvertex);
894 if (startvertex.Z() > 0.1) return;
895 if (motherID == -1) return;
896 else {
897 CbmMCTrack* mothermctrack = (CbmMCTrack*) fMcTracks->At(motherID);
898 int motherpdg = mothermctrack->GetPdgCode();
899 if (motherpdg == 22) { fMCTracklist_allElectronsFromGamma.push_back(mctrack); }
900 }
901}
902
903
904void CbmAnaConversionPhotons::FillMCTracklist_allGammas(CbmMCTrack* mctrack)
905{
906 int motherID = mctrack->GetMotherId();
907 TVector3 startvertex;
908 mctrack->GetStartVertex(startvertex);
909 if (startvertex.Z() > 0.1) return;
910 if (motherID == -1) return;
911 else {
912 fMCTracklist_allGammas.push_back(mctrack);
913 CbmMCTrack* mothermctrack = (CbmMCTrack*) fMcTracks->At(motherID);
914 int motherpdg = mothermctrack->GetPdgCode();
915 if (motherpdg == 111) { fMCTracklist_allGammasFromPi0.push_back(mctrack); }
916 }
917}
918
919
920void CbmAnaConversionPhotons::FillRecoTracklist_allElectrons(CbmMCTrack* mctrack, TVector3 refittedMom)
921{
922 int motherID = mctrack->GetMotherId();
923 TVector3 startvertex;
924 mctrack->GetStartVertex(startvertex);
925 if (startvertex.Z() > 0.1) return;
926 if (motherID == -1) return;
927 else {
928 CbmMCTrack* mothermctrack = (CbmMCTrack*) fMcTracks->At(motherID);
929 int motherpdg = mothermctrack->GetPdgCode();
930 if (motherpdg == 22) {
931 fRecoTracklist_allElectronsFromGamma.push_back(mctrack);
932 fRecoTracklist_allElectronsFromGammaMom.push_back(refittedMom);
933 }
934 if (motherpdg == 111) {
935 fRecoTracklist_allElectronsFromPi0.push_back(mctrack);
936 fRecoTracklist_allElectronsFromPi0Mom.push_back(refittedMom);
937 }
938 }
939}
940
941
942void CbmAnaConversionPhotons::CombineElectrons()
943{
944 TH1I* zwischenhisto = new TH1I("zwischenhisto", "zwischenhisto", 1000000, 0, 1000000);
945 for (unsigned int i = 0; i < fMCTracklist.size(); i++) {
946 zwischenhisto->Fill(fMCTracklist[i]->GetMotherId());
947 }
948 fPhotons_test->Fill(zwischenhisto->GetMaximum());
949 if (zwischenhisto->GetMaximum() >= 2) {
950 cout << "CbmAnaConversionPhotons: photon found, mother ids " << zwischenhisto->GetMaximumBin() - 1 << endl;
951 CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(zwischenhisto->GetMaximumBin() - 1);
952 cout << "CbmAnaConversionPhotons: additional data: pdg " << mcTrack1->GetPdgCode() << " motherId "
953 << mcTrack1->GetMotherId() << endl;
954 }
955 zwischenhisto->Delete();
956
957
958 int photoncounter = 0;
959 std::multimap<int, int> electronMap;
960 for (unsigned int i = 0; i < fMCTracklist.size(); i++) {
961 electronMap.insert(std::pair<int, int>(fMCTracklist[i]->GetMotherId(), i));
962 }
963
964 int check = 0;
965 for (std::map<int, int>::iterator it = electronMap.begin(); it != electronMap.end(); ++it) {
966 if (it == electronMap.begin()) check = 1;
967 if (it != electronMap.begin()) {
968 std::map<int, int>::iterator zwischen = it;
969 zwischen--;
970 int id = it->first;
971 int id_old = zwischen->first;
972 if (id == id_old) {
973 check++;
974 if (check > 1) {
975 cout << "CbmAnaConversionPhotons: map - photon found " << id << endl;
976 photoncounter++;
977 fhGlobalNofDirectPhotons->Fill(1);
978 }
979 }
980 else
981 check = 1;
982 }
983 }
984 //fPhotons_nofPerEvent->Fill(photoncounter);
985
986 global_nof_photonsReco += photoncounter;
987}
988
989
990int CbmAnaConversionPhotons::CheckMC(CbmMCTrack* mctrack)
991{
992 int nofDirectPhotons = 0;
993
994 // Int_t nofMcTracks = fMcTracks->GetEntriesFast();
995 // for (int i = 0; i < nofMcTracks; i++) {
996 // CbmMCTrack* mctrack = (CbmMCTrack*)fMcTracks->At(i);
997 // if (mctrack == NULL) continue;
998
999 int pdg = mctrack->GetPdgCode();
1000 int motherId = mctrack->GetMotherId();
1001 Double_t energy = mctrack->GetEnergy();
1002 Double_t pt = mctrack->GetPt();
1003 Double_t rapidity = mctrack->GetRapidity();
1004
1005 if (pdg == 22 && motherId == -1) { // only direct photons
1006 nofDirectPhotons++;
1007 fhGlobalNofDirectPhotons->Fill(0);
1008 fPhotons_energyMC->Fill(energy);
1009 fPhotons_ptMC->Fill(pt);
1010 fPhotons_ptRapMC->Fill(pt, rapidity);
1011 }
1012 if (pdg == 22 && motherId != -1) { // only secondary photons
1013 fPhotonsRest_energyMC->Fill(energy);
1014 fPhotonsRest_ptMC->Fill(pt);
1015
1016 CbmMCTrack* mothermctrack = (CbmMCTrack*) fMcTracks->At(motherId);
1017 int motherpdg = mothermctrack->GetPdgCode();
1018 fPhotonsRest_pdgMotherMC->Fill(motherpdg);
1019
1020 if (motherpdg == 111) fPhotonsRest_ptMC_pi0->Fill(pt);
1021 if (motherpdg == 2112) fPhotonsRest_ptMC_n->Fill(pt);
1022 if (motherpdg == 11) fPhotonsRest_ptMC_e->Fill(pt);
1023 if (motherpdg == 221) fPhotonsRest_ptMC_eta->Fill(pt);
1024 }
1025 // }
1026
1027 // fPhotons_nofMC->Fill(nofDirectPhotons);
1028
1029 // global_nof_photonsMC += nofDirectPhotons;
1030 return nofDirectPhotons;
1031}
1032
1033
1034LmvmKinePar CbmAnaConversionPhotons::CalculateKinematicParams(const CbmMCTrack* mctrackP, const CbmMCTrack* mctrackM)
1035{
1036 LmvmKinePar params;
1037
1038 TVector3 momP; //momentum e+
1039 mctrackP->GetMomentum(momP);
1040 Double_t energyP = TMath::Sqrt(momP.Mag2() + M2E);
1041 TLorentzVector lorVecP(momP, energyP);
1042
1043 TVector3 momM; //momentum e-
1044 mctrackM->GetMomentum(momM);
1045 Double_t energyM = TMath::Sqrt(momM.Mag2() + M2E);
1046 TLorentzVector lorVecM(momM, energyM);
1047
1048 TVector3 momPair = momP + momM;
1049 Double_t energyPair = energyP + energyM;
1050 Double_t ptPair = momPair.Perp();
1051 Double_t pzPair = momPair.Pz();
1052 Double_t yPair = 0.5 * TMath::Log((energyPair + pzPair) / (energyPair - pzPair));
1053 Double_t anglePair = lorVecM.Angle(lorVecP.Vect());
1054 Double_t theta = 180. * anglePair / TMath::Pi();
1055 Double_t minv = 2. * TMath::Sin(anglePair / 2.) * TMath::Sqrt(momM.Mag() * momP.Mag());
1056
1057 params.fMomentumMag = momPair.Mag();
1058 params.fPt = ptPair;
1059 params.fRapidity = yPair;
1060 params.fMinv = minv;
1061 params.fAngle = theta;
1062 //params.fMomentumPhoton = momPair;
1063 return params;
1064}
1065
1066
1067LmvmKinePar CbmAnaConversionPhotons::CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
1068{
1069 LmvmKinePar params;
1070
1071 Double_t energyP = TMath::Sqrt(electron1.Mag2() + M2E);
1072 TLorentzVector lorVecP(electron1, energyP);
1073
1074 Double_t energyM = TMath::Sqrt(electron2.Mag2() + M2E);
1075 TLorentzVector lorVecM(electron2, energyM);
1076
1077 TVector3 momPair = electron1 + electron2;
1078 Double_t energyPair = energyP + energyM;
1079 Double_t ptPair = momPair.Perp();
1080 Double_t pzPair = momPair.Pz();
1081 Double_t yPair = 0.5 * TMath::Log((energyPair + pzPair) / (energyPair - pzPair));
1082 Double_t anglePair = lorVecM.Angle(lorVecP.Vect());
1083 Double_t theta = 180. * anglePair / TMath::Pi();
1084 Double_t minv = 2. * TMath::Sin(anglePair / 2.) * TMath::Sqrt(electron1.Mag() * electron2.Mag());
1085
1086 params.fMomentumMag = momPair.Mag();
1087 params.fPt = ptPair;
1088 params.fRapidity = yPair;
1089 params.fMinv = minv;
1090 params.fAngle = theta;
1091 return params;
1092}
1093
1094
1095void CbmAnaConversionPhotons::AnalyseElectronsFromGammaMC()
1096{
1097 int electronnumber = fMCTracklist_allElectronsFromGamma.size();
1098 cout << "CbmAnaConversionPhotons: array size in AnalyseElectronsFromGammaMC(): " << electronnumber << endl;
1099 for (int i = 0; i < electronnumber - 1; i++) {
1100 for (int j = i; j < electronnumber; j++) {
1101 if (fMCTracklist_allElectronsFromGamma[i]->GetPdgCode() + fMCTracklist_allElectronsFromGamma[j]->GetPdgCode()
1102 != 0)
1103 continue; // only 1 electron and 1 positron allowed
1104
1105 int motherID_i = fMCTracklist_allElectronsFromGamma[i]->GetMotherId();
1106 int motherID_j = fMCTracklist_allElectronsFromGamma[j]->GetMotherId();
1107
1108 LmvmKinePar paramSet =
1109 CalculateKinematicParams(fMCTracklist_allElectronsFromGamma[i], fMCTracklist_allElectronsFromGamma[j]);
1110
1111 CbmMCTrack* mothermctrack_i = (CbmMCTrack*) fMcTracks->At(motherID_i);
1112 int grandmotherID_i = mothermctrack_i->GetMotherId();
1113
1114
1115 // fill all combinations of e+e-, even if they dont come from the same origin
1116 fhEFG_angle_all->Fill(paramSet.fAngle);
1117 fhEFG_angleVSpt_all->Fill(paramSet.fAngle, mothermctrack_i->GetPt());
1118 fhEFG_invmass_all->Fill(paramSet.fMinv);
1119 fhEFG_momentumPair_all->Fill(paramSet.fMomentumMag);
1120 fhEFG_energy_all->Fill(mothermctrack_i->GetEnergy());
1121
1122
1123 // fill only combinations of e+e-, which do not have the same mother gamma -> combinatorial background
1124 if (motherID_i != motherID_j) {
1125 fhEFG_angle_combBack->Fill(paramSet.fAngle);
1126 fhEFG_angleVSpt_combBack->Fill(paramSet.fAngle, mothermctrack_i->GetPt());
1127 fhEFG_invmass_combBack->Fill(paramSet.fMinv);
1128 fhEFG_momentumPair_combBack->Fill(paramSet.fMomentumMag);
1129 fhEFG_energy_combBack->Fill(mothermctrack_i->GetEnergy());
1130 continue;
1131 }
1132
1133 TVector3 startvertex;
1134 fMCTracklist_allElectronsFromGamma[i]->GetStartVertex(startvertex);
1135
1136
1137 // fill all combinations of e+e- with the same origin
1138 fhEFG_angle_allSameG->Fill(paramSet.fAngle);
1139 fhEFG_angleVSenergy_allSameG->Fill(paramSet.fAngle, mothermctrack_i->GetEnergy());
1140 fhEFG_angleVSpt_allSameG->Fill(paramSet.fAngle, mothermctrack_i->GetPt());
1141 fhEFG_invmass_allSameG->Fill(paramSet.fMinv);
1142 fhEFG_momentumPair_allSameG->Fill(paramSet.fMomentumMag);
1143 fhEFG_energy_allSameG->Fill(mothermctrack_i->GetEnergy());
1144 fhEFG_startvertexVSangle_allSameG->Fill(startvertex.Z(), paramSet.fAngle);
1145 fhEFG_startvertex_allSameG->Fill(startvertex.Z());
1146 if (mothermctrack_i->GetEnergy() <= 1) fhEFG_angleBelow1GeV_allSameG->Fill(paramSet.fAngle);
1147 if (mothermctrack_i->GetEnergy() > 1) fhEFG_angleAbove1GeV_allSameG->Fill(paramSet.fAngle);
1148
1149
1150 // combinations of e+e- from the same gamma, gamma = direct gamma
1151 if (grandmotherID_i == -1) {
1152 fhEFG_angle_direct->Fill(paramSet.fAngle);
1153 fhEFG_angleVSenergy_direct->Fill(paramSet.fAngle, mothermctrack_i->GetEnergy());
1154 fhEFG_angleVSpt_direct->Fill(paramSet.fAngle, mothermctrack_i->GetPt());
1155 fhEFG_invmass_direct->Fill(paramSet.fMinv);
1156 fhEFG_momentumPair_direct->Fill(paramSet.fMomentumMag);
1157 fhEFG_energy_direct->Fill(mothermctrack_i->GetEnergy());
1158 fhEFG_startvertexVSangle_direct->Fill(startvertex.Z(), paramSet.fAngle);
1159 if (mothermctrack_i->GetEnergy() <= 1) fhEFG_angleBelow1GeV_direct->Fill(paramSet.fAngle);
1160 if (mothermctrack_i->GetEnergy() > 1) fhEFG_angleAbove1GeV_direct->Fill(paramSet.fAngle);
1161 }
1162 // combinations of e+e- from the same gamma, with gamma estimating from another particle (pi0/eta/...)
1163 else {
1164 CbmMCTrack* grandmothermctrack_i = (CbmMCTrack*) fMcTracks->At(grandmotherID_i);
1165 int grandmotherpdg_i = grandmothermctrack_i->GetPdgCode();
1166 if (grandmotherpdg_i == 111) { // pi0
1167 fhEFG_angle_pi0->Fill(paramSet.fAngle);
1168 fhEFG_angleVSenergy_pi0->Fill(paramSet.fAngle, mothermctrack_i->GetEnergy());
1169 fhEFG_angleVSpt_pi0->Fill(paramSet.fAngle, mothermctrack_i->GetPt());
1170 fhEFG_invmass_pi0->Fill(paramSet.fMinv);
1171 fhEFG_momentumPair_pi0->Fill(paramSet.fMomentumMag);
1172 fhEFG_energy_pi0->Fill(mothermctrack_i->GetEnergy());
1173 fhEFG_startvertexVSangle_pi0->Fill(startvertex.Z(), paramSet.fAngle);
1174 if (mothermctrack_i->GetEnergy() <= 1) fhEFG_angleBelow1GeV_pi0->Fill(paramSet.fAngle);
1175 if (mothermctrack_i->GetEnergy() > 1) fhEFG_angleAbove1GeV_pi0->Fill(paramSet.fAngle);
1176 }
1177 if (grandmotherpdg_i == 221) { // eta
1178 fhEFG_angle_eta->Fill(paramSet.fAngle);
1179 fhEFG_angleVSenergy_eta->Fill(paramSet.fAngle, mothermctrack_i->GetEnergy());
1180 fhEFG_angleVSpt_eta->Fill(paramSet.fAngle, mothermctrack_i->GetPt());
1181 fhEFG_invmass_eta->Fill(paramSet.fMinv);
1182 fhEFG_momentumPair_eta->Fill(paramSet.fMomentumMag);
1183 fhEFG_energy_eta->Fill(mothermctrack_i->GetEnergy());
1184 fhEFG_startvertexVSangle_eta->Fill(startvertex.Z(), paramSet.fAngle);
1185 if (mothermctrack_i->GetEnergy() <= 1) fhEFG_angleBelow1GeV_eta->Fill(paramSet.fAngle);
1186 if (mothermctrack_i->GetEnergy() > 1) fhEFG_angleAbove1GeV_eta->Fill(paramSet.fAngle);
1187 }
1188 }
1189 }
1190 }
1191}
1192
1193
1194void CbmAnaConversionPhotons::AnalyseElectronsFromGammaReco()
1195{
1196 int electronnumber = fRecoTracklist_allElectronsFromGamma.size();
1197 if (fRecoTracklist_allElectronsFromGamma.size() != fRecoTracklist_allElectronsFromGammaMom.size()) {
1198 cout << "CbmAnaConversionPhotons::AnalyseElectronsFromGammaReco() - array "
1199 "sizes dont fit!"
1200 << endl;
1201 return;
1202 }
1203 cout << "CbmAnaConversionPhotons: array size in "
1204 "AnalyseElectronsFromGammaReco(): "
1205 << electronnumber << endl;
1206 for (int i = 0; i < electronnumber; i++) {
1207 for (int j = i; j < electronnumber; j++) {
1208 if (fRecoTracklist_allElectronsFromGamma[i]->GetPdgCode() + fRecoTracklist_allElectronsFromGamma[j]->GetPdgCode()
1209 != 0)
1210 continue; // only 1 electron and 1 positron allowed
1211
1212
1213 LmvmKinePar paramSet = CalculateKinematicParamsReco(fRecoTracklist_allElectronsFromGammaMom[i],
1214 fRecoTracklist_allElectronsFromGammaMom[j]);
1215 Double_t OpeningAngleCut = CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt);
1216
1217
1218 fhEFG_angle_all_reco->Fill(
1219 paramSet.fAngle); // fill all combinations of e+e-, even if they dont come from the same origin
1220 fhEFG_angleVSpt_all_reco->Fill(paramSet.fPt, paramSet.fAngle);
1221 fhEFG_invmassVSpt_all_reco->Fill(paramSet.fPt, paramSet.fMinv);
1222 fhEFG_invmass_all_reco->Fill(paramSet.fMinv);
1223 if (paramSet.fAngle < OpeningAngleCut) {
1224 fhEFG_invmass_all_reco_cut->Fill(paramSet.fMinv);
1225 fhEFG_angle_all_reco_cuts->Fill(paramSet.fAngle);
1226 }
1227
1228 int motherID_i = fRecoTracklist_allElectronsFromGamma[i]->GetMotherId();
1229 int motherID_j = fRecoTracklist_allElectronsFromGamma[j]->GetMotherId();
1230
1231 if (motherID_i != motherID_j) {
1232 fhEFG_angle_combBack_reco->Fill(paramSet.fAngle);
1233 fhEFG_angleVSpt_combBack_reco->Fill(paramSet.fPt, paramSet.fAngle);
1234 fhEFG_invmassVSpt_combBack_reco->Fill(paramSet.fPt, paramSet.fMinv);
1235 fhEFG_invmass_combBack_reco->Fill(paramSet.fMinv);
1236 if (paramSet.fAngle < OpeningAngleCut) {
1237 fhEFG_invmass_combBack_reco_cut->Fill(paramSet.fMinv);
1238 fhEFG_angle_combBack_reco_cuts->Fill(paramSet.fAngle);
1239 }
1240
1241 // study of different opening angle cuts
1242 fhEFG_angle_reco_CUTcomparison->Fill(1); // no cuts applied
1243 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1244 fhEFG_angle_reco_CUTcomparison->Fill(3);
1245 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
1246 fhEFG_angle_reco_CUTcomparison->Fill(5);
1247 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
1248 fhEFG_angle_reco_CUTcomparison->Fill(7);
1249 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
1250 fhEFG_angle_reco_CUTcomparison->Fill(9);
1251 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
1252 fhEFG_angle_reco_CUTcomparison->Fill(11);
1253 continue;
1254 }
1255
1256 fhEFG_angle_allSameG_reco->Fill(paramSet.fAngle); // all combinations of e+e- with the same origin
1257 fhEFG_invmass_allSameG_reco->Fill(paramSet.fMinv);
1258 fhEFG_angleVSpt_allSameG_reco->Fill(paramSet.fPt, paramSet.fAngle);
1259 fhEFG_invmassVSpt_allSameG_reco->Fill(paramSet.fPt, paramSet.fMinv);
1260 if (paramSet.fAngle < OpeningAngleCut) {
1261 fhEFG_invmass_allSameG_reco_cut->Fill(paramSet.fMinv);
1262 fhEFG_angle_allSameG_reco_cuts->Fill(paramSet.fAngle);
1263 }
1264
1265
1266 // study of different opening angle cuts
1267 fhEFG_angle_reco_CUTcomparison->Fill(0); // no cuts applied
1268 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCut(paramSet.fPt))
1269 fhEFG_angle_reco_CUTcomparison->Fill(2);
1270 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt1(paramSet.fPt))
1271 fhEFG_angle_reco_CUTcomparison->Fill(4);
1272 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt2(paramSet.fPt))
1273 fhEFG_angle_reco_CUTcomparison->Fill(6);
1274 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3(paramSet.fPt))
1275 fhEFG_angle_reco_CUTcomparison->Fill(8);
1276 if (paramSet.fAngle < CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt4(paramSet.fPt))
1277 fhEFG_angle_reco_CUTcomparison->Fill(10);
1278
1279
1280 CbmMCTrack* mothermctrack_i = (CbmMCTrack*) fMcTracks->At(motherID_i);
1281 int grandmotherID_i = mothermctrack_i->GetMotherId();
1282
1283 fhEFG_momentumResolutionPhoton_reco->Fill(paramSet.fMomentumMag,
1284 TMath::Abs(mothermctrack_i->GetP() - paramSet.fMomentumMag)
1285 / paramSet.fMomentumMag * 100); // dp/p in percent
1286 fhEFG_momentumResolutionElectrons_reco->Fill(
1287 fRecoTracklist_allElectronsFromGammaMom[i].Mag(),
1288 TMath::Abs(fRecoTracklist_allElectronsFromGammaMom[i].Mag() - fRecoTracklist_allElectronsFromGamma[i]->GetP())
1289 / fRecoTracklist_allElectronsFromGammaMom[i].Mag() * 100);
1290 fhEFG_momentumResolutionElectrons_reco->Fill(
1291 fRecoTracklist_allElectronsFromGammaMom[j].Mag(),
1292 TMath::Abs(fRecoTracklist_allElectronsFromGammaMom[j].Mag() - fRecoTracklist_allElectronsFromGamma[j]->GetP())
1293 / fRecoTracklist_allElectronsFromGammaMom[j].Mag() * 100);
1294
1295
1296 if (grandmotherID_i == -1) { // combinations of e+e- from the same gamma, gamma = direct gamma
1297 fhEFG_angle_direct_reco->Fill(paramSet.fAngle);
1298 fhEFG_invmass_direct_reco->Fill(paramSet.fMinv);
1299 fhEFG_angleVSpt_direct_reco->Fill(paramSet.fPt, paramSet.fAngle);
1300 fhEFG_invmassVSpt_direct_reco->Fill(paramSet.fPt, paramSet.fMinv);
1301 if (paramSet.fAngle < 1) fhEFG_invmass_direct_reco_cut->Fill(paramSet.fMinv);
1302 }
1303 else { // combinations of e+e- from the same gamma, with gamma estimating from another particle (pi0/eta/...)
1304 CbmMCTrack* grandmothermctrack_i = (CbmMCTrack*) fMcTracks->At(grandmotherID_i);
1305 int grandmotherpdg_i = grandmothermctrack_i->GetPdgCode();
1306
1307 if (grandmotherpdg_i == 111) {
1308 fhEFG_angle_pi0_reco->Fill(paramSet.fAngle);
1309 fhEFG_invmass_pi0_reco->Fill(paramSet.fMinv);
1310 fhEFG_angleVSpt_pi0_reco->Fill(paramSet.fPt, paramSet.fAngle);
1311 fhEFG_invmassVSpt_pi0_reco->Fill(paramSet.fPt, paramSet.fMinv);
1312 if (paramSet.fAngle < 1) fhEFG_invmass_pi0_reco_cut->Fill(paramSet.fMinv);
1313 }
1314 if (grandmotherpdg_i == 221) {
1315 fhEFG_angle_eta_reco->Fill(paramSet.fAngle);
1316 fhEFG_invmass_eta_reco->Fill(paramSet.fMinv);
1317 fhEFG_angleVSpt_eta_reco->Fill(paramSet.fPt, paramSet.fAngle);
1318 fhEFG_invmassVSpt_eta_reco->Fill(paramSet.fPt, paramSet.fMinv);
1319 if (paramSet.fAngle < 1) fhEFG_invmass_eta_reco_cut->Fill(paramSet.fMinv);
1320 }
1321 }
1322 }
1323 }
1324}
1325
1326
1327void CbmAnaConversionPhotons::AnalyseElectronsFromPi0Reco()
1328{
1329 int electronnumber = fRecoTracklist_allElectronsFromPi0.size();
1330 if (fRecoTracklist_allElectronsFromPi0.size() != fRecoTracklist_allElectronsFromPi0Mom.size()) {
1331 cout << "CbmAnaConversionPhotons::AnalyseElectronsFromGammaPi0() - array "
1332 "sizes dont fit!"
1333 << endl;
1334 return;
1335 }
1336 cout << "CbmAnaConversionPhotons: array size in AnalyseElectronsFromPi0Reco(): " << electronnumber << endl;
1337 for (int i = 0; i < electronnumber; i++) {
1338 for (int j = i; j < electronnumber; j++) {
1339 if (fRecoTracklist_allElectronsFromPi0[i]->GetPdgCode() + fRecoTracklist_allElectronsFromPi0[j]->GetPdgCode()
1340 != 0)
1341 continue; // only 1 electron and 1 positron allowed
1342
1343
1344 LmvmKinePar paramSet = CalculateKinematicParamsReco(fRecoTracklist_allElectronsFromPi0Mom[i],
1345 fRecoTracklist_allElectronsFromPi0Mom[j]);
1346
1347 int motherID_i = fRecoTracklist_allElectronsFromPi0[i]->GetMotherId();
1348 int motherID_j = fRecoTracklist_allElectronsFromPi0[j]->GetMotherId();
1349
1350 if (motherID_i != motherID_j) { continue; }
1351 fhEFPI0_angle_reco->Fill(paramSet.fAngle);
1352 }
1353 }
1354}
1355
1356
1357void CbmAnaConversionPhotons::AnalyseGammas()
1358{
1359 int number = fMCTracklist_allGammas.size();
1360 cout << "CbmAnaConversionPhotons: array size in AnalyseGammas(): " << number << endl;
1361 for (int i = 0; i < number - 1; i++) {
1362 for (int j = i; j < number; j++) {
1363
1364 // calculate invariant mass
1365 TVector3 gamma1;
1366 fMCTracklist_allGammas[i]->GetMomentum(gamma1);
1367 Double_t energy1 = TMath::Sqrt(gamma1.Mag2());
1368 TLorentzVector lorVec1(gamma1, energy1);
1369 TVector3 gamma2;
1370 fMCTracklist_allGammas[j]->GetMomentum(gamma2);
1371 Double_t energy2 = TMath::Sqrt(gamma2.Mag2());
1372 TLorentzVector lorVec2(gamma2, energy2);
1373 TLorentzVector sum;
1374 sum = lorVec1 + lorVec2;
1375
1376 fhG_invmass->Fill(sum.Mag());
1377 }
1378 }
1379
1380
1381 int number_pi0 = fMCTracklist_allGammasFromPi0.size();
1382 cout << "CbmAnaConversionPhotons: array size in AnalyseGammas(): " << number_pi0 << endl;
1383 for (int i = 0; i < number_pi0 - 1; i++) {
1384 for (int j = i; j < number_pi0; j++) {
1385
1386 // calculate invariant mass
1387 TVector3 gamma1;
1388 fMCTracklist_allGammasFromPi0[i]->GetMomentum(gamma1);
1389 Double_t energy1 = TMath::Sqrt(gamma1.Mag2());
1390 TLorentzVector lorVec1(gamma1, energy1);
1391 TVector3 gamma2;
1392 fMCTracklist_allGammasFromPi0[j]->GetMomentum(gamma2);
1393 Double_t energy2 = TMath::Sqrt(gamma2.Mag2());
1394 TLorentzVector lorVec2(gamma2, energy2);
1395 TLorentzVector sum;
1396 sum = lorVec1 + lorVec2;
1397
1398 fhG_invmass_pi0->Fill(sum.Mag());
1399 }
1400 }
1401}
M2E
#define M2E
Definition CbmAnaJpsiKinematicParams.h:14
CbmDrawHist.h
Helper functions for drawing 1D and 2D histograms and graphs.
CbmStsTrack.h
Data class for STS tracks.
Int_t
int Int_t
Definition RootTypesDef.h:16
CbmAnaConversionCutSettings::CalcOpeningAngleCutAlt3
static Double_t CalcOpeningAngleCutAlt3(Double_t)
Definition CbmAnaConversionCutSettings.h:51
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
CbmAnaConversionPhotons::CheckMC
int CheckMC(CbmMCTrack *mctrack)
Definition CbmAnaConversionPhotons.cxx:990
CbmAnaConversionPhotons::fHistoList_EFG_angle
std::vector< TH1 * > fHistoList_EFG_angle
Definition CbmAnaConversionPhotons.h:89
CbmAnaConversionPhotons::FillMCTracklist
void FillMCTracklist(CbmMCTrack *mctrack)
Definition CbmAnaConversionPhotons.cxx:878
CbmAnaConversionPhotons::FillMCTracklist_allGammas
void FillMCTracklist_allGammas(CbmMCTrack *mctrack)
Definition CbmAnaConversionPhotons.cxx:904
CbmAnaConversionPhotons::FillRecoTracklist_allElectrons
void FillRecoTracklist_allElectrons(CbmMCTrack *mctrack, TVector3 refittedMom)
Definition CbmAnaConversionPhotons.cxx:920
CbmAnaConversionPhotons::fRecoTracklist_allElectronsFromGamma
std::vector< CbmMCTrack * > fRecoTracklist_allElectronsFromGamma
Definition CbmAnaConversionPhotons.h:112
CbmAnaConversionPhotons::fMCTracklist_allGammasFromPi0
std::vector< CbmMCTrack * > fMCTracklist_allGammasFromPi0
Definition CbmAnaConversionPhotons.h:118
CbmAnaConversionPhotons::fMCTracklist_allGammas
std::vector< CbmMCTrack * > fMCTracklist_allGammas
Definition CbmAnaConversionPhotons.h:117
CbmAnaConversionPhotons::fHistoList_EFG
std::vector< TH1 * > fHistoList_EFG
Definition CbmAnaConversionPhotons.h:88
CbmAnaConversionPhotons::FillMCTracklist_allElectrons
void FillMCTracklist_allElectrons(CbmMCTrack *mctrack)
Definition CbmAnaConversionPhotons.cxx:889
CbmAnaConversionPhotons::fRecoTracklist_allElectronsFromPi0
std::vector< CbmMCTrack * > fRecoTracklist_allElectronsFromPi0
Definition CbmAnaConversionPhotons.h:114
CbmAnaConversionPhotons::fMCTracklist
std::vector< CbmMCTrack * > fMCTracklist
Definition CbmAnaConversionPhotons.h:110
CbmAnaConversionPhotons::CalculateKinematicParams
LmvmKinePar CalculateKinematicParams(const CbmMCTrack *mctrackP, const CbmMCTrack *mctrackM)
Definition CbmAnaConversionPhotons.cxx:1034
CbmAnaConversionPhotons::fMCTracklist_allElectronsFromGamma
std::vector< CbmMCTrack * > fMCTracklist_allElectronsFromGamma
Definition CbmAnaConversionPhotons.h:111
CbmAnaConversionPhotons::fHistoList_photons
std::vector< TH1 * > fHistoList_photons
Definition CbmAnaConversionPhotons.h:87
CbmAnaConversionPhotons::fRecoTracklist_allElectronsFromPi0Mom
std::vector< TVector3 > fRecoTracklist_allElectronsFromPi0Mom
Definition CbmAnaConversionPhotons.h:115
CbmAnaConversionPhotons::fHistoList_EFG_energy
std::vector< TH1 * > fHistoList_EFG_energy
Definition CbmAnaConversionPhotons.h:91
CbmAnaConversionPhotons::CalculateKinematicParamsReco
LmvmKinePar CalculateKinematicParamsReco(const TVector3 electron1, const TVector3 electron2)
Definition CbmAnaConversionPhotons.cxx:1067
CbmAnaConversionPhotons::fHistoList_EFG_invmass
std::vector< TH1 * > fHistoList_EFG_invmass
Definition CbmAnaConversionPhotons.h:90
CbmAnaConversionPhotons::fRecoTracklist_allElectronsFromGammaMom
std::vector< TVector3 > fRecoTracklist_allElectronsFromGammaMom
Definition CbmAnaConversionPhotons.h:113
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:506
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:174
CbmMCTrack::GetPt
double GetPt() const
Definition CbmMCTrack.h:96
CbmMCTrack::GetP
double GetP() const
Definition CbmMCTrack.h:97
CbmMCTrack::GetMomentum
void GetMomentum(TVector3 &momentum) const
Definition CbmMCTrack.h:169
CbmMCTrack::GetMotherId
int32_t GetMotherId() const
Definition CbmMCTrack.h:68
CbmMCTrack::GetPdgCode
int32_t GetPdgCode() const
Definition CbmMCTrack.h:67
CbmMCTrack::GetRapidity
double GetRapidity() const
Definition CbmMCTrack.cxx:187
CbmMCTrack::GetStartVertex
void GetStartVertex(TVector3 &vertex) const
Definition CbmMCTrack.h:175
CbmMCTrack::GetEnergy
double GetEnergy() const
Definition CbmMCTrack.h:161
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition CbmMatch.h:41
LmvmKinePar::fAngle
Double_t fAngle
Definition LmvmKinePar.h:21
LmvmKinePar::fMinv
Double_t fMinv
Definition LmvmKinePar.h:20
LmvmKinePar::fPt
Double_t fPt
Definition LmvmKinePar.h:18
LmvmKinePar::fMomentumMag
Double_t fMomentumMag
Definition LmvmKinePar.h:17
LmvmKinePar::fRapidity
Double_t fRapidity
Definition LmvmKinePar.h:19
std
Hash for CbmL1LinkKey.
Definition algo/base/Options.cxx:22