CbmRoot
Loading...
Searching...
No Matches
CbmKresConversionKF.cxx
Go to the documentation of this file.
1/* Copyright (C) 2017-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Ievgenii Kres, Florian Uhlig [committer] */
4
22#include "CbmKresConversionKF.h"
23
24#include "CbmGlobalTrack.h"
25#include "CbmKFParticleFinder.h"
26#include "CbmKFParticleFinderQa.h"
27#include "CbmKresConversionBG.h"
28#include "CbmKresFunctions.h"
29#include "CbmMCTrack.h"
30#include "CbmRichHit.h"
31#include "CbmRichRing.h"
32#include "CbmRichRingFitterEllipseTau.h"
33#include "CbmRichRingLight.h"
34#include "CbmStsTrack.h"
35#include "CbmTrackMatchNew.h"
36
37#include <FairRootManager.h>
38
39#include <TDirectory.h>
40
41#include "KFParticle.h"
42#include "KFParticleTopoReconstructor.h"
43#include "LmvmKinePar.h"
44
45using namespace std;
46
47CbmKresConversionKF::CbmKresConversionKF()
48 : fKFparticle(nullptr)
49 , fKFparticleFinderQA(nullptr)
50 , fKFtopo(nullptr)
51 , fTauFit(nullptr)
52 , fAnaBG(nullptr)
53 , fMcTracks(nullptr)
54 , fStsTracks(nullptr)
55 , fStsTrackMatches(nullptr)
56 , fGlobalTracks(nullptr)
57 , fRichRingMatches(nullptr)
58 , fRichProjections(nullptr)
59 , fRichRings(nullptr)
60 , fRichHits(nullptr)
61 , frefmomentum()
62 , GammasAll()
63 , GammasZero()
64 , GammasOne()
65 , GammasTwo()
66 , GammasOneTwo()
67 , fStsInd()
68 , GammasAllStsIndex()
69 , GammasZeroStsIndex()
70 , GammasOneStsIndex()
71 , GammasTwoStsIndex()
72 , GammasOneTwoStsIndex()
73 , fmcvector()
74 , GammasAllMC()
75 , GammasZeroMC()
76 , GammasOneMC()
77 , GammasTwoMC()
78 , GammasOneTwoMC()
79 , GammasAllZ()
80 , GammasZeroZ()
81 , GammasOneZ()
82 , GammasTwoZ()
83 , GammasOneTwoZ()
84 , EMT_Event()
85 , EMT_pair_momenta()
86 , EMT_NofRings()
87 , EMT_Z()
88 , EMT_Event_multi_all()
89 , EMT_pair_momenta_multi_all()
90 , EMT_Event_multi_one()
91 , EMT_pair_momenta_multi_one()
92 , EMT_Event_multi_two()
93 , EMT_pair_momenta_multi_two()
94 , EMT_Event_multi_zero()
95 , EMT_pair_momenta_multi_zero()
96 , EMT_Event_multi_onetwo()
97 , EMT_pair_momenta_multi_onetwo()
98 , EMT_multi_all()
99 , EMT_multi_one()
100 , EMT_multi_two()
101 , EMT_multi_zero()
102 , EMT_multi_onetwo()
103 , fHistoList_CheckForCuts()
104 , CheckForCuts_InvMass_MC(nullptr)
105 , CheckForCuts_InvMass_Reco(nullptr)
106 , CheckForCuts_OA_MC(nullptr)
107 , CheckForCuts_OA_Reco(nullptr)
108 , CheckForCuts_InvMass_MC_from_one_pi0(nullptr)
109 , CheckForCuts_InvMass_Reco_from_one_pi0(nullptr)
110 , CheckForCuts_OA_MC_from_one_pi0(nullptr)
111 , CheckForCuts_OA_Reco_from_one_pi0(nullptr)
112 , CheckForCuts_z_vs_InvMass_MC_from_one_pi0(nullptr)
113 , CheckForCuts_z_vs_InvMass_Reco_from_one_pi0(nullptr)
114 , CheckForCuts_z_vs_OA_MC_from_one_pi0(nullptr)
115 , CheckForCuts_z_vs_OA_Reco_from_one_pi0(nullptr)
116 , CheckForCuts_InvMass_Reco_from_one_pi0_less4cm(nullptr)
117 , CheckForCuts_OA_Reco_from_one_pi0_less4cm(nullptr)
118 , CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm(nullptr)
119 , CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm(nullptr)
120 , CheckForCuts_InvMass_Reco_from_one_pi0_more21cm(nullptr)
121 , CheckForCuts_OA_Reco_from_one_pi0_more21cm(nullptr)
122 , fHistoList_All()
123 , fGammaInvMassReco_All(nullptr)
124 , fGammaOpeningAngleReco_All(nullptr)
125 , fPdg_All(nullptr)
126 , fP_reco_All(nullptr)
127 , fPt_reco_All(nullptr)
128 , fPi0InvMassRecoKF_All(nullptr)
129 , fEMT_InvMass_All(nullptr)
130 , fPi0_pt_vs_rap_All(nullptr)
131 , fPi0_pt_vs_rap_est_All(nullptr)
132 , fHistoList_All_target()
133 , fGammaInvMassReco_All_target(nullptr)
134 , fGammaOpeningAngleReco_All_target(nullptr)
135 , fPi0InvMassRecoKF_All_target(nullptr)
136 , fEMT_InvMass_All_target(nullptr)
137 , fHistoList_All_mvd()
138 , fGammaInvMassReco_All_mvd(nullptr)
139 , fGammaOpeningAngleReco_All_mvd(nullptr)
140 , fPi0InvMassRecoKF_All_mvd(nullptr)
141 , fHistoList_All_sts()
142 , fGammaInvMassReco_All_sts(nullptr)
143 , fGammaOpeningAngleReco_All_sts(nullptr)
144 , fPi0InvMassRecoKF_All_sts(nullptr)
145 , fHistoList_All_outside()
146 , fGammaInvMassReco_All_outside(nullptr)
147 , fGammaOpeningAngleReco_All_outside(nullptr)
148 , fPi0InvMassRecoKF_All_outside(nullptr)
149 , fEMT_InvMass_All_outside(nullptr)
150 , fHistoList_Zero()
151 , fGammaInvMassReco_Zero(nullptr)
152 , fGammaOpeningAngleReco_Zero(nullptr)
153 , fPdg_Zero(nullptr)
154 , fP_reco_Zero(nullptr)
155 , fPt_reco_Zero(nullptr)
156 , fPi0InvMassRecoKF_Zero(nullptr)
157 , fEMT_InvMass_Zero(nullptr)
158 , fPi0_pt_vs_rap_Zero(nullptr)
159 , fPi0_pt_vs_rap_est_Zero(nullptr)
160 , fHistoList_Zero_target()
161 , fGammaInvMassReco_Zero_target(nullptr)
162 , fGammaOpeningAngleReco_Zero_target(nullptr)
163 , fPi0InvMassRecoKF_Zero_target(nullptr)
164 , fEMT_InvMass_Zero_target(nullptr)
165 , fHistoList_Zero_mvd()
166 , fGammaInvMassReco_Zero_mvd(nullptr)
167 , fGammaOpeningAngleReco_Zero_mvd(nullptr)
168 , fPi0InvMassRecoKF_Zero_mvd(nullptr)
169 , fHistoList_Zero_sts()
170 , fGammaInvMassReco_Zero_sts(nullptr)
171 , fGammaOpeningAngleReco_Zero_sts(nullptr)
172 , fPi0InvMassRecoKF_Zero_sts(nullptr)
173 , fHistoList_Zero_outside()
174 , fGammaInvMassReco_Zero_outside(nullptr)
175 , fGammaOpeningAngleReco_Zero_outside(nullptr)
176 , fPi0InvMassRecoKF_Zero_outside(nullptr)
177 , fEMT_InvMass_Zero_outside(nullptr)
178 , fHistoList_One()
179 , fGammaInvMassReco_One(nullptr)
180 , fGammaOpeningAngleReco_One(nullptr)
181 , fPdg_One(nullptr)
182 , fP_reco_One(nullptr)
183 , fPt_reco_One(nullptr)
184 , fPi0InvMassRecoKF_One(nullptr)
185 , fEMT_InvMass_One(nullptr)
186 , fPi0_pt_vs_rap_One(nullptr)
187 , fPi0_pt_vs_rap_est_One(nullptr)
188 , fHistoList_One_target()
189 , fGammaInvMassReco_One_target(nullptr)
190 , fGammaOpeningAngleReco_One_target(nullptr)
191 , fPi0InvMassRecoKF_One_target(nullptr)
192 , fEMT_InvMass_One_target(nullptr)
193 , fHistoList_One_mvd()
194 , fGammaInvMassReco_One_mvd(nullptr)
195 , fGammaOpeningAngleReco_One_mvd(nullptr)
196 , fPi0InvMassRecoKF_One_mvd(nullptr)
197 , fHistoList_One_sts()
198 , fGammaInvMassReco_One_sts(nullptr)
199 , fGammaOpeningAngleReco_One_sts(nullptr)
200 , fPi0InvMassRecoKF_One_sts(nullptr)
201 , fHistoList_One_outside()
202 , fGammaInvMassReco_One_outside(nullptr)
203 , fGammaOpeningAngleReco_One_outside(nullptr)
204 , fPi0InvMassRecoKF_One_outside(nullptr)
205 , fEMT_InvMass_One_outside(nullptr)
206 , fHistoList_Two()
207 , fGammaInvMassReco_Two(nullptr)
208 , fGammaOpeningAngleReco_Two(nullptr)
209 , fPdg_Two(nullptr)
210 , fP_reco_Two(nullptr)
211 , fPt_reco_Two(nullptr)
212 , fPi0InvMassRecoKF_Two(nullptr)
213 , fEMT_InvMass_Two(nullptr)
214 , fPi0_pt_vs_rap_Two(nullptr)
215 , fPi0_pt_vs_rap_est_Two(nullptr)
216 , fHistoList_Two_target()
217 , fGammaInvMassReco_Two_target(nullptr)
218 , fGammaOpeningAngleReco_Two_target(nullptr)
219 , fPi0InvMassRecoKF_Two_target(nullptr)
220 , fEMT_InvMass_Two_target(nullptr)
221 , fHistoList_Two_mvd()
222 , fGammaInvMassReco_Two_mvd(nullptr)
223 , fGammaOpeningAngleReco_Two_mvd(nullptr)
224 , fPi0InvMassRecoKF_Two_mvd(nullptr)
225 , fHistoList_Two_sts()
226 , fGammaInvMassReco_Two_sts(nullptr)
227 , fGammaOpeningAngleReco_Two_sts(nullptr)
228 , fPi0InvMassRecoKF_Two_sts(nullptr)
229 , fHistoList_Two_outside()
230 , fGammaInvMassReco_Two_outside(nullptr)
231 , fGammaOpeningAngleReco_Two_outside(nullptr)
232 , fPi0InvMassRecoKF_Two_outside(nullptr)
233 , fEMT_InvMass_Two_outside(nullptr)
234 , fHistoList_OneTwo()
235 , fGammaInvMassReco_OneTwo(nullptr)
236 , fGammaOpeningAngleReco_OneTwo(nullptr)
237 , fPdg_OneTwo(nullptr)
238 , fP_reco_OneTwo(nullptr)
239 , fPt_reco_OneTwo(nullptr)
240 , fPi0InvMassRecoKF_OneTwo(nullptr)
241 , fEMT_InvMass_OneTwo(nullptr)
242 , fPi0_pt_vs_rap_OneTwo(nullptr)
243 , fPi0_pt_vs_rap_est_OneTwo(nullptr)
244 , fHistoList_OneTwo_target()
245 , fGammaInvMassReco_OneTwo_target(nullptr)
246 , fGammaOpeningAngleReco_OneTwo_target(nullptr)
247 , fPi0InvMassRecoKF_OneTwo_target(nullptr)
248 , fEMT_InvMass_OneTwo_target(nullptr)
249 , fHistoList_OneTwo_mvd()
250 , fGammaInvMassReco_OneTwo_mvd(nullptr)
251 , fGammaOpeningAngleReco_OneTwo_mvd(nullptr)
252 , fPi0InvMassRecoKF_OneTwo_mvd(nullptr)
253 , fHistoList_OneTwo_sts()
254 , fGammaInvMassReco_OneTwo_sts(nullptr)
255 , fGammaOpeningAngleReco_OneTwo_sts(nullptr)
256 , fPi0InvMassRecoKF_OneTwo_sts(nullptr)
257 , fHistoList_OneTwo_outside()
258 , fGammaInvMassReco_OneTwo_outside(nullptr)
259 , fGammaOpeningAngleReco_OneTwo_outside(nullptr)
260 , fPi0InvMassRecoKF_OneTwo_outside(nullptr)
261 , fEMT_InvMass_OneTwo_outside(nullptr)
262 , fHistoList_multiplicity()
263 , MultiplicityGamma_All(nullptr)
264 , MultiplicityGamma_Zero(nullptr)
265 , MultiplicityGamma_One(nullptr)
266 , MultiplicityGamma_Two(nullptr)
267 , MultiplicityGamma_OneTwo(nullptr)
268 , MultiplicityChargedParticles_All(nullptr)
269 , MultiplicityChargedParticles_Zero(nullptr)
270 , MultiplicityChargedParticles_One(nullptr)
271 , MultiplicityChargedParticles_Two(nullptr)
272 , MultiplicityChargedParticles_OneTwo(nullptr)
273 , fHistoList_multiplicity_All()
274 , fHistoList_multiplicity_One()
275 , fHistoList_multiplicity_Two()
276 , fHistoList_multiplicity_Zero()
277 , fHistoList_multiplicity_OneTwo()
278 , EMTMulti_InvMass_All_m1(nullptr)
279 , EMTMulti_InvMass_All_m2(nullptr)
280 , EMTMulti_InvMass_All_m3(nullptr)
281 , EMTMulti_InvMass_All_m4(nullptr)
282 , EMTMulti_InvMass_All_m5(nullptr)
283 , EMTMulti_InvMass_All_m6(nullptr)
284 , EMTMulti_InvMass_All_m7(nullptr)
285 , EMTMulti_InvMass_Zero_m1(nullptr)
286 , EMTMulti_InvMass_Zero_m2(nullptr)
287 , EMTMulti_InvMass_Zero_m3(nullptr)
288 , EMTMulti_InvMass_Zero_m4(nullptr)
289 , EMTMulti_InvMass_Zero_m5(nullptr)
290 , EMTMulti_InvMass_Zero_m6(nullptr)
291 , EMTMulti_InvMass_Zero_m7(nullptr)
292 , EMTMulti_InvMass_One_m1(nullptr)
293 , EMTMulti_InvMass_One_m2(nullptr)
294 , EMTMulti_InvMass_One_m3(nullptr)
295 , EMTMulti_InvMass_One_m4(nullptr)
296 , EMTMulti_InvMass_One_m5(nullptr)
297 , EMTMulti_InvMass_One_m6(nullptr)
298 , EMTMulti_InvMass_One_m7(nullptr)
299 , EMTMulti_InvMass_Two_m1(nullptr)
300 , EMTMulti_InvMass_Two_m2(nullptr)
301 , EMTMulti_InvMass_Two_m3(nullptr)
302 , EMTMulti_InvMass_Two_m4(nullptr)
303 , EMTMulti_InvMass_Two_m5(nullptr)
304 , EMTMulti_InvMass_Two_m6(nullptr)
305 , EMTMulti_InvMass_Two_m7(nullptr)
306 , EMTMulti_InvMass_OneTwo_m1(nullptr)
307 , EMTMulti_InvMass_OneTwo_m2(nullptr)
308 , EMTMulti_InvMass_OneTwo_m3(nullptr)
309 , EMTMulti_InvMass_OneTwo_m4(nullptr)
310 , EMTMulti_InvMass_OneTwo_m5(nullptr)
311 , EMTMulti_InvMass_OneTwo_m6(nullptr)
312 , EMTMulti_InvMass_OneTwo_m7(nullptr)
313 , fHistoList_bg_all()
314 , BG1_all(nullptr)
315 , BG2_all(nullptr)
316 , BG3_all(nullptr)
317 , BG4_all(nullptr)
318 , BG5_all(nullptr)
319 , BG6_all(nullptr)
320 , BG7_all(nullptr)
321 , BG8_all(nullptr)
322 , BG9_all(nullptr)
323 , BG10_all(nullptr)
324 , PdgCase8_all(nullptr)
325 , PdgCase8mothers_all(nullptr)
326 , sameMIDcase8_all(nullptr)
327 , sameGRIDcase8_all(nullptr)
328 , Case1ZYPos_all(nullptr)
329 , sameMIDcase8_mothedPDG_all(nullptr)
330 , PdgCase8NonEComeFromTarget_all(nullptr)
331 , PdgCase8NonE_NOT_FromTarget_all(nullptr)
332 , PdgCase8motherNonE_all(nullptr)
333 , Case8ElFromDalitz_all(nullptr)
334 , Case8NonElFrom_pn_all(nullptr)
335 , Case8NonElFrom_eta_all(nullptr)
336 , Case8NonElFrom_kaon_all(nullptr)
337 , sameMIDcase8NonEPdg_all(nullptr)
338 , sameMIDcase8NonEMotherPdg_all(nullptr)
339 , sameMIDcase8NonEMotherIM_all(nullptr)
340 , sameMIDcase8NonEPdgFromTarget_all(nullptr)
341 , sameMIDcase8NonEComeFromTargetIM_all(nullptr)
342 , sameMIDcase8NonEComeFromTargetP_all(nullptr)
343 , sameMIDcase8NonEComeFromTargetPt_all(nullptr)
344 , fHistoList_bg_zero()
345 , BG1_zero(nullptr)
346 , BG2_zero(nullptr)
347 , BG3_zero(nullptr)
348 , BG4_zero(nullptr)
349 , BG5_zero(nullptr)
350 , BG6_zero(nullptr)
351 , BG7_zero(nullptr)
352 , BG8_zero(nullptr)
353 , BG9_zero(nullptr)
354 , BG10_zero(nullptr)
355 , PdgCase8_zero(nullptr)
356 , PdgCase8mothers_zero(nullptr)
357 , sameMIDcase8_zero(nullptr)
358 , sameGRIDcase8_zero(nullptr)
359 , Case1ZYPos_zero(nullptr)
360 , sameMIDcase8_mothedPDG_zero(nullptr)
361 , PdgCase8NonEComeFromTarget_zero(nullptr)
362 , PdgCase8NonE_NOT_FromTarget_zero(nullptr)
363 , PdgCase8motherNonE_zero(nullptr)
364 , Case8ElFromDalitz_zero(nullptr)
365 , Case8NonElFrom_pn_zero(nullptr)
366 , Case8NonElFrom_eta_zero(nullptr)
367 , Case8NonElFrom_kaon_zero(nullptr)
368 , sameMIDcase8NonEPdg_zero(nullptr)
369 , sameMIDcase8NonEMotherPdg_zero(nullptr)
370 , sameMIDcase8NonEMotherIM_zero(nullptr)
371 , sameMIDcase8NonEPdgFromTarget_zero(nullptr)
372 , sameMIDcase8NonEComeFromTargetIM_zero(nullptr)
373 , sameMIDcase8NonEComeFromTargetP_zero(nullptr)
374 , sameMIDcase8NonEComeFromTargetPt_zero(nullptr)
375 , fHistoList_bg_one()
376 , BG1_one(nullptr)
377 , BG2_one(nullptr)
378 , BG3_one(nullptr)
379 , BG4_one(nullptr)
380 , BG5_one(nullptr)
381 , BG6_one(nullptr)
382 , BG7_one(nullptr)
383 , BG8_one(nullptr)
384 , BG9_one(nullptr)
385 , BG10_one(nullptr)
386 , PdgCase8_one(nullptr)
387 , PdgCase8mothers_one(nullptr)
388 , sameMIDcase8_one(nullptr)
389 , sameGRIDcase8_one(nullptr)
390 , Case1ZYPos_one(nullptr)
391 , sameMIDcase8_mothedPDG_one(nullptr)
392 , PdgCase8NonEComeFromTarget_one(nullptr)
393 , PdgCase8NonE_NOT_FromTarget_one(nullptr)
394 , PdgCase8motherNonE_one(nullptr)
395 , Case8ElFromDalitz_one(nullptr)
396 , Case8NonElFrom_pn_one(nullptr)
397 , Case8NonElFrom_eta_one(nullptr)
398 , Case8NonElFrom_kaon_one(nullptr)
399 , sameMIDcase8NonEPdg_one(nullptr)
400 , sameMIDcase8NonEMotherPdg_one(nullptr)
401 , sameMIDcase8NonEMotherIM_one(nullptr)
402 , sameMIDcase8NonEPdgFromTarget_one(nullptr)
403 , sameMIDcase8NonEComeFromTargetIM_one(nullptr)
404 , sameMIDcase8NonEComeFromTargetP_one(nullptr)
405 , sameMIDcase8NonEComeFromTargetPt_one(nullptr)
406 , fHistoList_bg_two()
407 , BG1_two(nullptr)
408 , BG2_two(nullptr)
409 , BG3_two(nullptr)
410 , BG4_two(nullptr)
411 , BG5_two(nullptr)
412 , BG6_two(nullptr)
413 , BG7_two(nullptr)
414 , BG8_two(nullptr)
415 , BG9_two(nullptr)
416 , BG10_two(nullptr)
417 , PdgCase8_two(nullptr)
418 , PdgCase8mothers_two(nullptr)
419 , sameMIDcase8_two(nullptr)
420 , sameGRIDcase8_two(nullptr)
421 , Case1ZYPos_two(nullptr)
422 , sameMIDcase8_mothedPDG_two(nullptr)
423 , PdgCase8NonEComeFromTarget_two(nullptr)
424 , PdgCase8NonE_NOT_FromTarget_two(nullptr)
425 , PdgCase8motherNonE_two(nullptr)
426 , Case8ElFromDalitz_two(nullptr)
427 , Case8NonElFrom_pn_two(nullptr)
428 , Case8NonElFrom_eta_two(nullptr)
429 , Case8NonElFrom_kaon_two(nullptr)
430 , sameMIDcase8NonEPdg_two(nullptr)
431 , sameMIDcase8NonEMotherPdg_two(nullptr)
432 , sameMIDcase8NonEMotherIM_two(nullptr)
433 , sameMIDcase8NonEPdgFromTarget_two(nullptr)
434 , sameMIDcase8NonEComeFromTargetIM_two(nullptr)
435 , sameMIDcase8NonEComeFromTargetP_two(nullptr)
436 , sameMIDcase8NonEComeFromTargetPt_two(nullptr)
437 , fHistoList_bg_onetwo()
438 , BG1_onetwo(nullptr)
439 , BG2_onetwo(nullptr)
440 , BG3_onetwo(nullptr)
441 , BG4_onetwo(nullptr)
442 , BG5_onetwo(nullptr)
443 , BG6_onetwo(nullptr)
444 , BG7_onetwo(nullptr)
445 , BG8_onetwo(nullptr)
446 , BG9_onetwo(nullptr)
447 , BG10_onetwo(nullptr)
448 , PdgCase8_onetwo(nullptr)
449 , PdgCase8mothers_onetwo(nullptr)
450 , sameMIDcase8_onetwo(nullptr)
451 , sameGRIDcase8_onetwo(nullptr)
452 , Case1ZYPos_onetwo(nullptr)
453 , sameMIDcase8_mothedPDG_onetwo(nullptr)
454 , PdgCase8NonEComeFromTarget_onetwo(nullptr)
455 , PdgCase8NonE_NOT_FromTarget_onetwo(nullptr)
456 , PdgCase8motherNonE_onetwo(nullptr)
457 , Case8ElFromDalitz_onetwo(nullptr)
458 , Case8NonElFrom_pn_onetwo(nullptr)
459 , Case8NonElFrom_eta_onetwo(nullptr)
460 , Case8NonElFrom_kaon_onetwo(nullptr)
461 , sameMIDcase8NonEPdg_onetwo(nullptr)
462 , sameMIDcase8NonEMotherPdg_onetwo(nullptr)
463 , sameMIDcase8NonEMotherIM_onetwo(nullptr)
464 , sameMIDcase8NonEPdgFromTarget_onetwo(nullptr)
465 , sameMIDcase8NonEComeFromTargetIM_onetwo(nullptr)
466 , sameMIDcase8NonEComeFromTargetP_onetwo(nullptr)
467 , sameMIDcase8NonEComeFromTargetPt_onetwo(nullptr)
468{
469}
470
471CbmKresConversionKF::~CbmKresConversionKF() {}
472
473void CbmKresConversionKF::SetKF(CbmKFParticleFinder* kfparticle, CbmKFParticleFinderQa* kfparticleQA)
474{
475 fKFparticle = kfparticle;
476 fKFparticleFinderQA = kfparticleQA;
477 if (fKFparticle) { cout << "CbmKresConversionKF: kf works" << endl; }
478 else {
479 cout << "CbmKresConversionKF: kf does not work" << endl;
480 }
481}
482
483void CbmKresConversionKF::Init()
484{
485 fKFtopo = fKFparticle->GetTopoReconstructor();
486
487 fTauFit = new CbmRichRingFitterEllipseTau();
488
489 FairRootManager* ioman = FairRootManager::Instance();
490 if (nullptr == ioman) { Fatal("CbmKresConversionKF::Init", "RootManager not instantised!"); }
491
492 fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
493 if (nullptr == fMcTracks) { Fatal("CbmKresConversionKF::Init", "No MCTrack array!"); }
494
495 fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
496 if (nullptr == fStsTracks) { Fatal("CbmKresConversionKF::Init", "No StsTrack array!"); }
497
498 fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
499 if (nullptr == fStsTrackMatches) { Fatal("CbmKresConversionKF::Init", "No StsTrackMatch array!"); }
500
501 fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
502 if (nullptr == fGlobalTracks) { Fatal("CbmKresConversionKF::Init", "No GlobalTrack array!"); }
503
504 fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
505 if (nullptr == fRichRingMatches) { Fatal("CbmKresConversionKF::Init", "No RichRingMatch array!"); }
506
507 fRichProjections = (TClonesArray*) ioman->GetObject("RichProjection");
508 if (nullptr == fRichProjections) { Fatal("CbmKresConversionKF::Init", "No RichProjection array!"); }
509
510 fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
511 if (nullptr == fRichRings) { Fatal("CbmKresConversionKF::Init", "No RichRing array!"); }
512
513 fRichHits = (TClonesArray*) ioman->GetObject("RichHit");
514 if (nullptr == fRichHits) { Fatal("CbmKresConversionKF::Init", "No RichHit array!"); }
515
516 InitHistograms();
517
518 fAnaBG = new CbmKresConversionBG();
519 fAnaBG->Init();
520}
521
522
523void CbmKresConversionKF::Exec(int fEventNumKF, double OpeningAngleCut, double GammaInvMassCut, int RealPID)
524{
525 cout << "CbmKresConversionKF, event No. " << fEventNumKF << endl;
526
527 //***** extract all particles from KFParticleFinder
528 vector<KFParticle> particlevector;
529 particlevector = fKFtopo->GetParticles();
530
531 //***** extract from all particles in KFParticleFinder only gammas
532 vector<KFParticle> allgammas;
533 allgammas.clear();
534 for (size_t vv = 0; vv < particlevector.size(); vv++) {
535 if (particlevector[vv].KFParticleBase::GetPDG() == 22) { // particle is gamma
536 if (particlevector[vv].KFParticleBase::NDaughters() != 2) continue; // check - if gamma has two particles
537 allgammas.push_back(particlevector[vv]);
538 }
539 }
540 cout << "number of all gammas from KFParticleFinder before any cuts = " << allgammas.size() << endl;
541
542 //***** sort gammas via number of identified leptons in RICH
543 GammasAll.clear();
544 GammasZero.clear();
545 GammasOne.clear();
546 GammasTwo.clear();
547 GammasOneTwo.clear();
548 GammasAllStsIndex.clear();
549 GammasZeroStsIndex.clear();
550 GammasOneStsIndex.clear();
551 GammasTwoStsIndex.clear();
552 GammasOneTwoStsIndex.clear();
553 GammasAllMC.clear();
554 GammasZeroMC.clear();
555 GammasOneMC.clear();
556 GammasTwoMC.clear();
557 GammasOneTwoMC.clear();
558 GammasAllZ.clear();
559 GammasZeroZ.clear();
560 GammasOneZ.clear();
561 GammasTwoZ.clear();
562 GammasOneTwoZ.clear();
563
564
565 FindGammas(allgammas, particlevector, fEventNumKF, OpeningAngleCut, GammaInvMassCut, RealPID);
566
567
568 FindPi0("All", GammasAll, GammasAllStsIndex, GammasAllMC, GammasAllZ, fPi0InvMassRecoKF_All, fPi0_pt_vs_rap_All,
569 fPi0_pt_vs_rap_est_All, fPi0InvMassRecoKF_All_target, fPi0InvMassRecoKF_All_mvd, fPi0InvMassRecoKF_All_sts,
570 fPi0InvMassRecoKF_All_outside, MultiplicityGamma_All, MultiplicityChargedParticles_All, fHistoList_bg_all);
571
572 FindPi0("Zero", GammasZero, GammasZeroStsIndex, GammasZeroMC, GammasZeroZ, fPi0InvMassRecoKF_Zero,
573 fPi0_pt_vs_rap_Zero, fPi0_pt_vs_rap_est_Zero, fPi0InvMassRecoKF_Zero_target, fPi0InvMassRecoKF_Zero_mvd,
574 fPi0InvMassRecoKF_Zero_sts, fPi0InvMassRecoKF_Zero_outside, MultiplicityGamma_Zero,
575 MultiplicityChargedParticles_Zero, fHistoList_bg_zero);
576
577 FindPi0("One", GammasOne, GammasOneStsIndex, GammasOneMC, GammasOneZ, fPi0InvMassRecoKF_One, fPi0_pt_vs_rap_One,
578 fPi0_pt_vs_rap_est_One, fPi0InvMassRecoKF_One_target, fPi0InvMassRecoKF_One_mvd, fPi0InvMassRecoKF_One_sts,
579 fPi0InvMassRecoKF_One_outside, MultiplicityGamma_One, MultiplicityChargedParticles_One, fHistoList_bg_one);
580
581 FindPi0("Two", GammasTwo, GammasTwoStsIndex, GammasTwoMC, GammasTwoZ, fPi0InvMassRecoKF_Two, fPi0_pt_vs_rap_Two,
582 fPi0_pt_vs_rap_est_Two, fPi0InvMassRecoKF_Two_target, fPi0InvMassRecoKF_Two_mvd, fPi0InvMassRecoKF_Two_sts,
583 fPi0InvMassRecoKF_Two_outside, MultiplicityGamma_Two, MultiplicityChargedParticles_Two, fHistoList_bg_two);
584
585 FindPi0("OneTwo", GammasOneTwo, GammasOneTwoStsIndex, GammasOneTwoMC, GammasOneTwoZ, fPi0InvMassRecoKF_OneTwo,
586 fPi0_pt_vs_rap_OneTwo, fPi0_pt_vs_rap_est_OneTwo, fPi0InvMassRecoKF_OneTwo_target,
587 fPi0InvMassRecoKF_OneTwo_mvd, fPi0InvMassRecoKF_OneTwo_sts, fPi0InvMassRecoKF_OneTwo_outside,
588 MultiplicityGamma_OneTwo, MultiplicityChargedParticles_OneTwo, fHistoList_bg_onetwo);
589
590
591 if (fEventNumKF % 500 == 0) {
592 MixedEvent();
593 EMT_Event.clear();
594 EMT_pair_momenta.clear();
595 EMT_NofRings.clear();
596 EMT_Z.clear();
597 }
598
599 if (fEventNumKF % 1000 == 0) {
600 MixedEventMulti();
601 EMT_Event_multi_all.clear();
602 EMT_pair_momenta_multi_all.clear();
603 EMT_Event_multi_zero.clear();
604 EMT_pair_momenta_multi_zero.clear();
605 EMT_Event_multi_one.clear();
606 EMT_pair_momenta_multi_one.clear();
607 EMT_Event_multi_two.clear();
608 EMT_pair_momenta_multi_two.clear();
609 EMT_Event_multi_onetwo.clear();
610 EMT_pair_momenta_multi_onetwo.clear();
611 EMT_multi_all.clear();
612 EMT_multi_one.clear();
613 EMT_multi_two.clear();
614 EMT_multi_zero.clear();
615 EMT_multi_onetwo.clear();
616 }
617
618
619 // pi0, which maksym accept
620 vector<vector<KFParticle>> primpi0;
621 primpi0 = fKFtopo->GetKFParticleFinder()->GetPrimaryPi0();
622 vector<KFParticle> primpi0inside;
623 primpi0inside = primpi0.at(0);
624 for (size_t tt = 0; tt < primpi0inside.size(); tt++) {
625 cout << "\t *********** primpi0->GetPt = " << primpi0inside[tt].GetPt()
626 << "; ->GetMass = " << primpi0inside[tt].GetMass() << "; ->GetX = " << primpi0inside[tt].GetX()
627 << "; ->GetY = " << primpi0inside[tt].GetY() << "; ->GetZ = " << primpi0inside[tt].GetZ()
628 << "; ->GetE = " << primpi0inside[tt].GetE() << endl;
629 }
630}
631
632
633void CbmKresConversionKF::FindGammas(vector<KFParticle> allgammas, vector<KFParticle> particlevector, int Event,
634 double AngleCut, double InvMassCut, int RealPID)
635{
636 for (size_t tt = 0; tt < allgammas.size(); tt++) {
637 if (allgammas[tt].GetZ() > 75 || allgammas[tt].GetZ() < -5) continue;
638 std::vector<int> electronIds = allgammas[tt].KFParticleBase::DaughterIds();
639 std::vector<int> grDaughter0 = particlevector[electronIds.at(0)].KFParticleBase::DaughterIds();
640 std::vector<int> grDaughter1 = particlevector[electronIds.at(1)].KFParticleBase::DaughterIds();
641 if (grDaughter0.size() != 1 || grDaughter1.size() != 1) continue; // check that it made only two particles
642
643 // STS ind
644 CbmStsTrack* stsTrack0 = (CbmStsTrack*) fStsTracks->At(grDaughter0.at(0));
645 CbmStsTrack* stsTrack1 = (CbmStsTrack*) fStsTracks->At(grDaughter1.at(0));
646 if (stsTrack0 == nullptr || stsTrack1 == nullptr) continue;
647 CbmTrackMatchNew* stsMatch0 = (CbmTrackMatchNew*) fStsTrackMatches->At(grDaughter0.at(0));
648 CbmTrackMatchNew* stsMatch1 = (CbmTrackMatchNew*) fStsTrackMatches->At(grDaughter1.at(0));
649 if (stsMatch0 == nullptr || stsMatch1 == nullptr) continue;
650 if (stsMatch0->GetNofLinks() <= 0 || stsMatch1->GetNofLinks() <= 0) continue;
651 int stsMcTrackId0 = stsMatch0->GetMatchedLink().GetIndex();
652 int stsMcTrackId1 = stsMatch1->GetMatchedLink().GetIndex();
653 if (stsMcTrackId0 < 0 || stsMcTrackId1 < 0) continue;
654 CbmMCTrack* mcTrack0 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId0);
655 CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId1);
656 if (mcTrack0 == nullptr || mcTrack1 == nullptr) continue;
657
658 TVector3 refmomentum0 =
659 CbmKresFunctions::FitToVertex(stsTrack0, allgammas[tt].GetX(), allgammas[tt].GetY(), allgammas[tt].GetZ());
660 TVector3 refmomentum1 =
661 CbmKresFunctions::FitToVertex(stsTrack1, allgammas[tt].GetX(), allgammas[tt].GetY(), allgammas[tt].GetZ());
662
663 // RICH ind
664 Int_t ngTracks = fGlobalTracks->GetEntriesFast();
665 int richInd0 = 99999;
666 int richInd1 = 99999;
667 for (Int_t iTr = 0; iTr < ngTracks; iTr++) {
668 CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iTr);
669 if (nullptr == gTrack) continue;
670 int stsInd = gTrack->GetStsTrackIndex();
671 if (stsInd < 0) continue;
672 if (stsInd == grDaughter0.at(0)) {
673 if (gTrack->GetRichRingIndex() > -1) richInd0 = gTrack->GetRichRingIndex();
674 }
675 if (stsInd == grDaughter1.at(0)) {
676 if (gTrack->GetRichRingIndex() > -1) richInd1 = gTrack->GetRichRingIndex();
677 }
678 }
679
680 int richcheck_0 = 0;
681 int richcheck_1 = 0;
682 //***** MCPID for RICH identification
683 if (RealPID != 1) {
684 if (richInd0 != 99999) {
685 CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(richInd0);
686 if (richMatch == nullptr) continue;
687 if (richMatch->GetNofLinks() <= 0) continue;
688 int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
689 if (richMcTrackId < 0) continue;
690 if (stsMcTrackId0 != richMcTrackId)
691 continue; // check that global track was matched correctly for STS and RICH together
692 CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
693 if (mcTrack2 == nullptr) continue;
694 int pdgRICH = mcTrack2->GetPdgCode();
695 if (TMath::Abs(pdgRICH) == 11) richcheck_0++;
696 }
697 if (richInd1 != 99999) {
698 CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(richInd1);
699 if (richMatch == nullptr) continue;
700 if (richMatch->GetNofLinks() <= 0) continue;
701 int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
702 if (richMcTrackId < 0) continue;
703 if (stsMcTrackId1 != richMcTrackId)
704 continue; // check that global track was matched correctly for STS and RICH together
705 CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
706 if (mcTrack2 == nullptr) continue;
707 int pdgRICH = mcTrack2->GetPdgCode();
708 if (TMath::Abs(pdgRICH) == 11) richcheck_1++;
709 }
710 }
711
712 // Real PID for RICH identification
713 if (RealPID == 1) {
714 if (richInd0 != 99999) {
715 CbmRichRing* richRing = static_cast<CbmRichRing*>(fRichRings->At(richInd0));
716 richcheck_0 = CheckIfElectron(richRing, refmomentum0.Mag());
717 }
718 if (richInd1 != 99999) {
719 CbmRichRing* richRing = static_cast<CbmRichRing*>(fRichRings->At(richInd1));
720 richcheck_1 = CheckIfElectron(richRing, refmomentum1.Mag());
721 }
722 }
723 // Real RICH PID (END).
724
725 int richcheck = richcheck_0 + richcheck_1;
726
727
728 FairTrackParam* proj = (FairTrackParam*) fRichProjections->At(grDaughter0.at(0));
729 if (richcheck_0 == 0 && proj->GetX() > -115 && proj->GetX() < 115
730 && ((proj->GetY() < -120 && proj->GetY() > -200) || (proj->GetY() > 120 && proj->GetY() < 200)))
731 continue;
732 FairTrackParam* proj2 = (FairTrackParam*) fRichProjections->At(grDaughter1.at(0));
733 if (richcheck_1 == 0 && proj2->GetX() > -115 && proj2->GetX() < 115
734 && ((proj2->GetY() < -120 && proj2->GetY() > -200) || (proj2->GetY() > 120 && proj2->GetY() < 200)))
735 continue;
736
737
738 //cout << "=================" << endl;
739 //cout << "FitToVertex part1: px = " << refmomentum0.X() << "; \t py = " << refmomentum0.Y() << "; \t pz = " << refmomentum0.Z() << endl;
740 //cout << "FitToVertex part2: px = " << refmomentum1.X() << "; \t py = " << refmomentum1.Y() << "; \t pz = " << refmomentum1.Z() << endl;
741 //cout << "KFParticle part1: px = " << particlevector[electronIds.at(0)].KFParticleBase::Px() << "; \t py = " << particlevector[electronIds.at(0)].KFParticleBase::Py() << "; \t pz = " << particlevector[electronIds.at(0)].KFParticleBase::Pz() << endl;
742 //cout << "KFParticle part2: px = " << particlevector[electronIds.at(1)].KFParticleBase::Px() << "; \t py = " << particlevector[electronIds.at(1)].KFParticleBase::Py() << "; \t pz = " << particlevector[electronIds.at(1)].KFParticleBase::Pz() << endl;
743 //TVector3 refmomentum0(particlevector[electronIds.at(0)].KFParticleBase::Px(), particlevector[electronIds.at(0)].KFParticleBase::Py(), particlevector[electronIds.at(0)].KFParticleBase::Pz());
744 //TVector3 refmomentum1(particlevector[electronIds.at(1)].KFParticleBase::Px(), particlevector[electronIds.at(1)].KFParticleBase::Py(), particlevector[electronIds.at(1)].KFParticleBase::Pz());
745
746
747 frefmomentum.clear();
748 frefmomentum.push_back(refmomentum0);
749 frefmomentum.push_back(refmomentum1);
750 fmcvector.clear();
751 fmcvector.push_back(mcTrack0);
752 fmcvector.push_back(mcTrack1);
753 fStsInd.clear();
754 fStsInd.push_back(grDaughter0.at(0));
755 fStsInd.push_back(grDaughter1.at(0));
756
757 Double_t invmassTrue = CbmKresFunctions::Invmass_2particles_MC(fmcvector.at(0), fmcvector.at(1));
758 Double_t invmassReco = CbmKresFunctions::Invmass_2particles_RECO(frefmomentum.at(0), frefmomentum.at(1));
759 Double_t opening_angle_mc = CbmKresFunctions::CalculateOpeningAngle_MC(fmcvector.at(0), fmcvector.at(1));
760 Double_t opening_angle_refitted =
761 CbmKresFunctions::CalculateOpeningAngle_Reco(frefmomentum.at(0), frefmomentum.at(1));
762
763
764 // graphs for understanding cuts:
765 CheckForCuts_InvMass_MC->Fill(invmassTrue);
766 CheckForCuts_InvMass_Reco->Fill(invmassReco);
767 CheckForCuts_OA_MC->Fill(opening_angle_mc);
768 CheckForCuts_OA_Reco->Fill(opening_angle_refitted);
769
770
771 if (TMath::Abs(mcTrack0->GetPdgCode()) == 11 && (mcTrack0->GetPdgCode() + mcTrack1->GetPdgCode()) == 0
772 && (mcTrack0->GetMotherId() == mcTrack1->GetMotherId()) && mcTrack0->GetMotherId() != -1) {
773 CbmMCTrack* mcTrackMother = (CbmMCTrack*) fMcTracks->At(mcTrack0->GetMotherId());
774 if (mcTrackMother != nullptr && mcTrackMother->GetPdgCode() == 22
775 && mcTrackMother->GetMotherId() != -1) { // electrons/positrons from gamma
776 CbmMCTrack* mcTrackMotherOfGamma = (CbmMCTrack*) fMcTracks->At(mcTrackMother->GetMotherId()); // pi0
777 if (mcTrackMotherOfGamma->GetPdgCode() == 111) {
778 CheckForCuts_OA_MC_from_one_pi0->Fill(opening_angle_mc);
779 CheckForCuts_OA_Reco_from_one_pi0->Fill(opening_angle_refitted);
780 CheckForCuts_InvMass_MC_from_one_pi0->Fill(invmassTrue);
781 CheckForCuts_InvMass_Reco_from_one_pi0->Fill(invmassReco);
782 CheckForCuts_z_vs_InvMass_MC_from_one_pi0->Fill(mcTrack0->GetStartZ(), invmassTrue);
783 CheckForCuts_z_vs_OA_MC_from_one_pi0->Fill(mcTrack0->GetStartZ(), opening_angle_mc);
784 CheckForCuts_z_vs_InvMass_Reco_from_one_pi0->Fill(allgammas[tt].GetZ(), invmassReco);
785 CheckForCuts_z_vs_OA_Reco_from_one_pi0->Fill(allgammas[tt].GetZ(), opening_angle_refitted);
786 if (allgammas[tt].GetZ() <= 4) {
787 CheckForCuts_InvMass_Reco_from_one_pi0_less4cm->Fill(invmassReco);
788 CheckForCuts_OA_Reco_from_one_pi0_less4cm->Fill(opening_angle_refitted);
789 }
790 if (allgammas[tt].GetZ() <= 21 && allgammas[tt].GetZ() > 4) {
791 CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm->Fill(invmassReco);
792 CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm->Fill(opening_angle_refitted);
793 }
794 if (allgammas[tt].GetZ() > 21) {
795 CheckForCuts_InvMass_Reco_from_one_pi0_more21cm->Fill(invmassReco);
796 CheckForCuts_OA_Reco_from_one_pi0_more21cm->Fill(opening_angle_refitted);
797 }
798 }
799 }
800 }
801
802
803 // cuts
804 if (TMath::Abs(opening_angle_refitted) > AngleCut) continue;
805 if (TMath::Abs(invmassReco) > InvMassCut) continue;
806
807
808 // for event mixing
809 EMT_Event.push_back(Event);
810 EMT_pair_momenta.push_back(frefmomentum);
811 EMT_NofRings.push_back(richcheck);
812 EMT_Z.push_back(allgammas[tt].GetZ());
813
814
815 // everything (RICH == 0, RICH == 1, RICH == 2) together
816 if (richcheck == 0 || richcheck == 1 || richcheck == 2) {
817 // for event mixing multi
818 EMT_Event_multi_all.push_back(Event);
819 EMT_pair_momenta_multi_all.push_back(frefmomentum);
820
821 GammasAll.push_back(frefmomentum);
822 GammasAllStsIndex.push_back(fStsInd);
823 GammasAllMC.push_back(fmcvector);
824 GammasAllZ.push_back(allgammas[tt].GetZ());
825
826 fGammaInvMassReco_All->Fill(invmassReco);
827 fGammaOpeningAngleReco_All->Fill(opening_angle_refitted);
828 fPdg_All->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
829 fPdg_All->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
830 fP_reco_All->Fill(refmomentum0.Mag());
831 fP_reco_All->Fill(refmomentum1.Mag());
832 fPt_reco_All->Fill(refmomentum0.Perp());
833 fPt_reco_All->Fill(refmomentum1.Perp());
834 if (allgammas[tt].GetZ() < 4) {
835 fGammaInvMassReco_All_target->Fill(invmassReco);
836 fGammaOpeningAngleReco_All_target->Fill(opening_angle_refitted);
837 }
838 if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
839 fGammaInvMassReco_All_mvd->Fill(invmassReco);
840 fGammaOpeningAngleReco_All_mvd->Fill(opening_angle_refitted);
841 }
842 if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
843 fGammaInvMassReco_All_sts->Fill(invmassReco);
844 fGammaOpeningAngleReco_All_sts->Fill(opening_angle_refitted);
845 }
846 if (allgammas[tt].GetZ() > 4) {
847 fGammaInvMassReco_All_outside->Fill(invmassReco);
848 fGammaOpeningAngleReco_All_outside->Fill(opening_angle_refitted);
849 }
850 }
851
852
853 // only cases, when RICH == 0
854 if (richcheck == 0) {
855 // for event mixing multi
856 EMT_Event_multi_zero.push_back(Event);
857 EMT_pair_momenta_multi_zero.push_back(frefmomentum);
858
859 GammasZero.push_back(frefmomentum);
860 GammasZeroStsIndex.push_back(fStsInd);
861 GammasZeroMC.push_back(fmcvector);
862 GammasZeroZ.push_back(allgammas[tt].GetZ());
863
864 fGammaInvMassReco_Zero->Fill(invmassReco);
865 fGammaOpeningAngleReco_Zero->Fill(opening_angle_refitted);
866 fPdg_Zero->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
867 fPdg_Zero->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
868 fP_reco_Zero->Fill(refmomentum0.Mag());
869 fP_reco_Zero->Fill(refmomentum1.Mag());
870 fPt_reco_Zero->Fill(refmomentum0.Perp());
871 fPt_reco_Zero->Fill(refmomentum1.Perp());
872 if (allgammas[tt].GetZ() < 4) {
873 fGammaInvMassReco_Zero_target->Fill(invmassReco);
874 fGammaOpeningAngleReco_Zero_target->Fill(opening_angle_refitted);
875 }
876 if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
877 fGammaInvMassReco_Zero_mvd->Fill(invmassReco);
878 fGammaOpeningAngleReco_Zero_mvd->Fill(opening_angle_refitted);
879 }
880 if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
881 fGammaInvMassReco_Zero_sts->Fill(invmassReco);
882 fGammaOpeningAngleReco_Zero_sts->Fill(opening_angle_refitted);
883 }
884 if (allgammas[tt].GetZ() > 4) {
885 fGammaInvMassReco_Zero_outside->Fill(invmassReco);
886 fGammaOpeningAngleReco_Zero_outside->Fill(opening_angle_refitted);
887 }
888 }
889
890 // only cases, when RICH == 1
891 if (richcheck == 1) {
892 // for event mixing multi
893 EMT_Event_multi_one.push_back(Event);
894 EMT_pair_momenta_multi_one.push_back(frefmomentum);
895
896 GammasOne.push_back(frefmomentum);
897 GammasOneStsIndex.push_back(fStsInd);
898 GammasOneMC.push_back(fmcvector);
899 GammasOneZ.push_back(allgammas[tt].GetZ());
900
901 fGammaInvMassReco_One->Fill(invmassReco);
902 fGammaOpeningAngleReco_One->Fill(opening_angle_refitted);
903 fPdg_One->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
904 fPdg_One->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
905 fP_reco_One->Fill(refmomentum0.Mag());
906 fP_reco_One->Fill(refmomentum1.Mag());
907 fPt_reco_One->Fill(refmomentum0.Perp());
908 fPt_reco_One->Fill(refmomentum1.Perp());
909 if (allgammas[tt].GetZ() < 4) {
910 fGammaInvMassReco_One_target->Fill(invmassReco);
911 fGammaOpeningAngleReco_One_target->Fill(opening_angle_refitted);
912 }
913 if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
914 fGammaInvMassReco_One_mvd->Fill(invmassReco);
915 fGammaOpeningAngleReco_One_mvd->Fill(opening_angle_refitted);
916 }
917 if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
918 fGammaInvMassReco_One_sts->Fill(invmassReco);
919 fGammaOpeningAngleReco_One_sts->Fill(opening_angle_refitted);
920 }
921 if (allgammas[tt].GetZ() > 4) {
922 fGammaInvMassReco_One_outside->Fill(invmassReco);
923 fGammaOpeningAngleReco_One_outside->Fill(opening_angle_refitted);
924 }
925 }
926
927 // only cases, when RICH == 2
928 if (richcheck == 2) {
929 // for event mixing multi
930 EMT_Event_multi_two.push_back(Event);
931 EMT_pair_momenta_multi_two.push_back(frefmomentum);
932
933 GammasTwo.push_back(frefmomentum);
934 GammasTwoStsIndex.push_back(fStsInd);
935 GammasTwoMC.push_back(fmcvector);
936 GammasTwoZ.push_back(allgammas[tt].GetZ());
937
938 fGammaInvMassReco_Two->Fill(invmassReco);
939 fGammaOpeningAngleReco_Two->Fill(opening_angle_refitted);
940 fPdg_Two->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
941 fPdg_Two->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
942 fP_reco_Two->Fill(refmomentum0.Mag());
943 fP_reco_Two->Fill(refmomentum1.Mag());
944 fPt_reco_Two->Fill(refmomentum0.Perp());
945 fPt_reco_Two->Fill(refmomentum1.Perp());
946 if (allgammas[tt].GetZ() < 4) {
947 fGammaInvMassReco_Two_target->Fill(invmassReco);
948 fGammaOpeningAngleReco_Two_target->Fill(opening_angle_refitted);
949 }
950 if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
951 fGammaInvMassReco_Two_mvd->Fill(invmassReco);
952 fGammaOpeningAngleReco_Two_mvd->Fill(opening_angle_refitted);
953 }
954 if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
955 fGammaInvMassReco_Two_sts->Fill(invmassReco);
956 fGammaOpeningAngleReco_Two_sts->Fill(opening_angle_refitted);
957 }
958 if (allgammas[tt].GetZ() > 4) {
959 fGammaInvMassReco_Two_outside->Fill(invmassReco);
960 fGammaOpeningAngleReco_Two_outside->Fill(opening_angle_refitted);
961 }
962 }
963
964 // cases, when RICH == 1 or RICH == 2 together
965 if (richcheck == 1 || richcheck == 2) {
966 // for event mixing multi
967 EMT_Event_multi_onetwo.push_back(Event);
968 EMT_pair_momenta_multi_onetwo.push_back(frefmomentum);
969
970 GammasOneTwo.push_back(frefmomentum);
971 GammasOneTwoStsIndex.push_back(fStsInd);
972 GammasOneTwoMC.push_back(fmcvector);
973 GammasOneTwoZ.push_back(allgammas[tt].GetZ());
974
975 fGammaInvMassReco_OneTwo->Fill(invmassReco);
976 fGammaOpeningAngleReco_OneTwo->Fill(opening_angle_refitted);
977 fPdg_OneTwo->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
978 fPdg_OneTwo->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
979 fP_reco_OneTwo->Fill(refmomentum0.Mag());
980 fP_reco_OneTwo->Fill(refmomentum1.Mag());
981 fPt_reco_OneTwo->Fill(refmomentum0.Perp());
982 fPt_reco_OneTwo->Fill(refmomentum1.Perp());
983 if (allgammas[tt].GetZ() < 4) {
984 fGammaInvMassReco_OneTwo_target->Fill(invmassReco);
985 fGammaOpeningAngleReco_OneTwo_target->Fill(opening_angle_refitted);
986 }
987 if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
988 fGammaInvMassReco_OneTwo_mvd->Fill(invmassReco);
989 fGammaOpeningAngleReco_OneTwo_mvd->Fill(opening_angle_refitted);
990 }
991 if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
992 fGammaInvMassReco_OneTwo_sts->Fill(invmassReco);
993 fGammaOpeningAngleReco_OneTwo_sts->Fill(opening_angle_refitted);
994 }
995 if (allgammas[tt].GetZ() > 4) {
996 fGammaInvMassReco_OneTwo_outside->Fill(invmassReco);
997 fGammaOpeningAngleReco_OneTwo_outside->Fill(opening_angle_refitted);
998 }
999 }
1000 }
1001
1002 //cout << "number of gammas with 0-2 electron identified in RICH = " << GammasAll.size() << endl;
1003 //cout << "number of gammas with 0 electron identified in RICH = " << GammasZero.size() << endl;
1004 //cout << "number of gammas with 1 electron identified in RICH = " << GammasOne.size() << endl;
1005 //cout << "number of gammas with 2 electron identified in RICH = " << GammasTwo.size() << endl;
1006 //cout << "number of gammas with 1-2 electron identified in RICH = " << GammasOneTwo.size() << endl;
1007
1008 for (size_t kk = 0; kk < GammasAll.size(); kk++) {
1009 EMT_multi_all.push_back(GammasAll.size());
1010 }
1011 for (size_t kk = 0; kk < GammasZero.size(); kk++) {
1012 EMT_multi_zero.push_back(GammasZero.size());
1013 }
1014 for (size_t kk = 0; kk < GammasOne.size(); kk++) {
1015 EMT_multi_one.push_back(GammasOne.size());
1016 }
1017 for (size_t kk = 0; kk < GammasTwo.size(); kk++) {
1018 EMT_multi_two.push_back(GammasTwo.size());
1019 }
1020 for (size_t kk = 0; kk < GammasOneTwo.size(); kk++) {
1021 EMT_multi_onetwo.push_back(GammasOneTwo.size());
1022 }
1023}
1024
1025
1026void CbmKresConversionKF::FindPi0(TString /*mod*/, vector<vector<TVector3>> Gammas, vector<vector<int>> StsIndex,
1027 vector<vector<CbmMCTrack*>> GammasMC, vector<Double_t> GammasZ,
1028 TH1D* Pi0InvMassRecoKF, TH2D* Pi0_pt_vs_rap, TH2D* Pi0_pt_vs_rap_est,
1029 TH1D* Pi0InvMassRecoKF_target, TH1D* Pi0InvMassRecoKF_mvd, TH1D* Pi0InvMassRecoKF_sts,
1030 TH1D* Pi0InvMassRecoKF_outside, TH2D* MultiplicityGamma,
1031 TH2D* MultiplicityChargedParticles, vector<TH1*> BGCases)
1032
1033{
1034 // combine all gamma in pi0 --> calculate inv mass for pi0 // not the case, when one particle used twice for different gammas
1035 if (Gammas.size() < 2) return; // min 2 gammas to form pi0 are required
1036
1037 for (size_t gamma1 = 0; gamma1 < Gammas.size() - 1; gamma1++) {
1038 for (size_t gamma2 = gamma1 + 1; gamma2 < Gammas.size(); gamma2++) {
1039
1040 if (StsIndex[gamma1][0] == StsIndex[gamma2][0] || StsIndex[gamma1][0] == StsIndex[gamma2][1]
1041 || StsIndex[gamma1][1] == StsIndex[gamma2][0] || StsIndex[gamma1][1] == StsIndex[gamma2][1])
1042 continue; // particles not used twice --> different
1043
1044 // 4 reconstructed particles from gammas
1045 TVector3 e1 = Gammas[gamma1][0];
1046 TVector3 e2 = Gammas[gamma1][1];
1047 TVector3 e3 = Gammas[gamma2][0];
1048 TVector3 e4 = Gammas[gamma2][1];
1049
1050 // MC true data for this particles
1051 CbmMCTrack* mcTrack1 = GammasMC[gamma1][0];
1052 CbmMCTrack* mcTrack2 = GammasMC[gamma1][1];
1053 CbmMCTrack* mcTrack3 = GammasMC[gamma2][0];
1054 CbmMCTrack* mcTrack4 = GammasMC[gamma2][1];
1055
1056 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e1, e2, e3, e4);
1057
1058 Pi0InvMassRecoKF->Fill(params.fMinv);
1059
1060 MultiplicityGamma->Fill(Gammas.size(), params.fMinv);
1061 MultiplicityChargedParticles->Fill(fGlobalTracks->GetEntriesFast(), params.fMinv);
1062
1063 // check reconsrtucted z position of conversion
1064 if (GammasZ[gamma1] < 4 && GammasZ[gamma2] < 4) { Pi0InvMassRecoKF_target->Fill(params.fMinv); }
1065 if (GammasZ[gamma1] > 4 && GammasZ[gamma1] < 21 && GammasZ[gamma2] > 4 && GammasZ[gamma2] < 21) {
1066 Pi0InvMassRecoKF_mvd->Fill(params.fMinv);
1067 }
1068 if (GammasZ[gamma1] > 21 && GammasZ[gamma1] < 75 && GammasZ[gamma2] > 21 && GammasZ[gamma2] < 75) {
1069 Pi0InvMassRecoKF_sts->Fill(params.fMinv);
1070 }
1071 if (GammasZ[gamma1] > 4 && GammasZ[gamma2] > 4) { Pi0InvMassRecoKF_outside->Fill(params.fMinv); }
1072
1073 fAnaBG->Exec(mcTrack1, mcTrack2, mcTrack3, mcTrack4, params.fMinv, BGCases);
1074
1075 // fill histos with rapidity and Pt for correctly reconstructed pi0(dalitz) and pi0(g+g)
1076 if (nullptr == mcTrack1 || nullptr == mcTrack2 || nullptr == mcTrack3 || nullptr == mcTrack4) continue;
1077 if (TMath::Abs(mcTrack1->GetPdgCode()) != 11 || TMath::Abs(mcTrack2->GetPdgCode()) != 11
1078 || TMath::Abs(mcTrack3->GetPdgCode()) != 11 || TMath::Abs(mcTrack4->GetPdgCode()) != 11)
1079 continue;
1080 if (mcTrack1->GetPdgCode() + mcTrack2->GetPdgCode() != 0) continue;
1081 if (mcTrack3->GetPdgCode() + mcTrack4->GetPdgCode() != 0) continue;
1082 int motherId1 = mcTrack1->GetMotherId();
1083 int motherId2 = mcTrack2->GetMotherId();
1084 int motherId3 = mcTrack3->GetMotherId();
1085 int motherId4 = mcTrack4->GetMotherId();
1086 if (motherId1 == -1 || motherId2 == -1 || motherId3 == -1 || motherId4 == -1) continue;
1087 if (motherId1 != motherId2 || motherId3 != motherId4) continue;
1088 CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(motherId1);
1089 CbmMCTrack* mother2 = (CbmMCTrack*) fMcTracks->At(motherId2);
1090 CbmMCTrack* mother3 = (CbmMCTrack*) fMcTracks->At(motherId3);
1091 CbmMCTrack* mother4 = (CbmMCTrack*) fMcTracks->At(motherId4);
1092 if (nullptr == mother1 || nullptr == mother2 || nullptr == mother3 || nullptr == mother4) continue;
1093 int mcMotherPdg1 = mother1->GetPdgCode();
1094 int mcMotherPdg2 = mother2->GetPdgCode();
1095 int mcMotherPdg3 = mother3->GetPdgCode();
1096 int mcMotherPdg4 = mother4->GetPdgCode();
1097 int grandmotherId1 = mother1->GetMotherId();
1098 int grandmotherId2 = mother2->GetMotherId();
1099 int grandmotherId3 = mother3->GetMotherId();
1100 int grandmotherId4 = mother4->GetMotherId();
1101
1102 if (mcMotherPdg1 == 22 && mcMotherPdg2 == 22 && mcMotherPdg3 == 111 && mcMotherPdg4 == 111) {
1103 if (grandmotherId1 != motherId3) continue;
1104 Pi0_pt_vs_rap->Fill(params.fRapidity, params.fPt);
1105 Pi0_pt_vs_rap_est->Fill(params.fRapidity, params.fPt);
1106 }
1107
1108 if (mcMotherPdg1 == 111 && mcMotherPdg2 == 111 && mcMotherPdg3 == 22 && mcMotherPdg4 == 22) {
1109 if (grandmotherId3 != motherId1) continue;
1110 Pi0_pt_vs_rap->Fill(params.fRapidity, params.fPt);
1111 Pi0_pt_vs_rap_est->Fill(params.fRapidity, params.fPt);
1112 }
1113
1114 if (mcMotherPdg1 == 22 && mcMotherPdg2 == 22 && mcMotherPdg3 == 22 && mcMotherPdg4 == 22) {
1115 if (grandmotherId1 != grandmotherId2 || grandmotherId3 != grandmotherId4 || grandmotherId1 != grandmotherId3)
1116 continue;
1117 if (grandmotherId1 == -1) continue;
1118 CbmMCTrack* grandmother1 = (CbmMCTrack*) fMcTracks->At(grandmotherId1);
1119 if (nullptr == grandmother1) continue;
1120 int mcGrandMotherPdg1 = grandmother1->GetPdgCode();
1121 if (mcGrandMotherPdg1 != 111) continue;
1122 Pi0_pt_vs_rap->Fill(params.fRapidity, params.fPt);
1123 Pi0_pt_vs_rap_est->Fill(params.fRapidity, params.fPt);
1124 }
1125 }
1126 }
1127}
1128
1129
1130int CbmKresConversionKF::CheckIfElectron(CbmRichRing* ring, double momentum)
1131{
1132 int identified = 0;
1133
1134 if (nullptr != ring) {
1135 CbmRichRingLight ringHit;
1136 int nofHits = ring->GetNofHits();
1137 for (int i = 0; i < nofHits; i++) {
1138 Int_t hitInd = ring->GetHit(i);
1139 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
1140 if (nullptr == hit) continue;
1141 CbmRichHitLight hl(hit->GetX(), hit->GetY());
1142 ringHit.AddHit(hl);
1143 }
1144 fTauFit->DoFit(&ringHit);
1145 if (ringHit.GetAaxis() > 4 && ringHit.GetAaxis() < 6 && ringHit.GetBaxis() > 4 && ringHit.GetBaxis() < 6
1146 && momentum > 0.2 && momentum < 4.)
1147 identified++;
1148 //if (ring->GetDistance() < 2 && ringHit.GetAaxis() > 4 && ringHit.GetAaxis() < 6 && ringHit.GetBaxis() > 4 && ringHit.GetBaxis() < 6 && momentum > 0.2 && momentum < 4.) identified ++;
1149 }
1150
1151 return identified;
1152}
1153
1154
1155void CbmKresConversionKF::MixedEvent()
1156// combines photons from two different events, taken from each time N events
1157{
1158 Int_t nof = EMT_Event.size();
1159 cout << "MixedEvent CbmKresConversionKF - nof entries " << nof << endl;
1160 for (Int_t a = 0; a < nof - 1; a++) {
1161 for (Int_t b = a + 1; b < nof; b++) {
1162 if (EMT_Event[a] == EMT_Event[b]) continue; // to make sure that the photons are from two different events
1163 TVector3 e11 = EMT_pair_momenta[a][0];
1164 TVector3 e12 = EMT_pair_momenta[a][1];
1165 TVector3 e21 = EMT_pair_momenta[b][0];
1166 TVector3 e22 = EMT_pair_momenta[b][1];
1167 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
1168
1169 fEMT_InvMass_All->Fill(params.fMinv);
1170 if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0) fEMT_InvMass_Zero->Fill(params.fMinv);
1171 if (EMT_NofRings[a] == 1 && EMT_NofRings[b] == 1) fEMT_InvMass_One->Fill(params.fMinv);
1172 if (EMT_NofRings[a] == 2 && EMT_NofRings[b] == 2) fEMT_InvMass_Two->Fill(params.fMinv);
1173 if ((EMT_NofRings[a] == 1 || EMT_NofRings[a] == 2) && (EMT_NofRings[b] == 1 || EMT_NofRings[b] == 2))
1174 fEMT_InvMass_OneTwo->Fill(params.fMinv);
1175
1176 // for inside the targte and outside the target
1177 if (EMT_Z[a] < 4 && EMT_Z[b] < 4) {
1178 fEMT_InvMass_All_target->Fill(params.fMinv);
1179 if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0) fEMT_InvMass_Zero_target->Fill(params.fMinv);
1180 if (EMT_NofRings[a] == 1 && EMT_NofRings[b] == 1) fEMT_InvMass_One_target->Fill(params.fMinv);
1181 if (EMT_NofRings[a] == 2 && EMT_NofRings[b] == 2) fEMT_InvMass_Two_target->Fill(params.fMinv);
1182 if ((EMT_NofRings[a] == 1 || EMT_NofRings[a] == 2) && (EMT_NofRings[b] == 1 || EMT_NofRings[b] == 2))
1183 fEMT_InvMass_OneTwo_target->Fill(params.fMinv);
1184 }
1185 if (EMT_Z[a] > 4 && EMT_Z[b] > 4) {
1186 fEMT_InvMass_All_outside->Fill(params.fMinv);
1187 if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0) fEMT_InvMass_Zero_outside->Fill(params.fMinv);
1188 if (EMT_NofRings[a] == 1 && EMT_NofRings[b] == 1) fEMT_InvMass_One_outside->Fill(params.fMinv);
1189 if (EMT_NofRings[a] == 2 && EMT_NofRings[b] == 2) fEMT_InvMass_Two_outside->Fill(params.fMinv);
1190 if ((EMT_NofRings[a] == 1 || EMT_NofRings[a] == 2) && (EMT_NofRings[b] == 1 || EMT_NofRings[b] == 2))
1191 fEMT_InvMass_OneTwo_outside->Fill(params.fMinv);
1192 }
1193 }
1194 }
1195}
1196
1197
1198void CbmKresConversionKF::MixedEventMulti()
1199// combines photons from two different events, taken from each time N events
1200{
1201 // all
1202 Int_t nof_all = EMT_Event_multi_all.size();
1203 cout << "MixedEventMulti CbmKresConversionKF - nof entries all " << nof_all << endl;
1204 for (Int_t a = 0; a < nof_all - 1; a++) {
1205 for (Int_t b = a + 1; b < nof_all; b++) {
1206 if (EMT_Event_multi_all[a] == EMT_Event_multi_all[b])
1207 continue; // to make sure that the photons are from two different events
1208 if (EMT_multi_all[a] != EMT_multi_all[b]) continue; // check same multiplicity
1209 TVector3 e11 = EMT_pair_momenta_multi_all[a][0];
1210 TVector3 e12 = EMT_pair_momenta_multi_all[a][1];
1211 TVector3 e21 = EMT_pair_momenta_multi_all[b][0];
1212 TVector3 e22 = EMT_pair_momenta_multi_all[b][1];
1213 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
1214
1215 if (EMT_multi_all[a] == 1) EMTMulti_InvMass_All_m1->Fill(params.fMinv);
1216 if (EMT_multi_all[a] == 2) EMTMulti_InvMass_All_m2->Fill(params.fMinv);
1217 if (EMT_multi_all[a] == 3) EMTMulti_InvMass_All_m3->Fill(params.fMinv);
1218 if (EMT_multi_all[a] == 4) EMTMulti_InvMass_All_m4->Fill(params.fMinv);
1219 if (EMT_multi_all[a] == 5) EMTMulti_InvMass_All_m5->Fill(params.fMinv);
1220 if (EMT_multi_all[a] == 6) EMTMulti_InvMass_All_m6->Fill(params.fMinv);
1221 if (EMT_multi_all[a] == 7) EMTMulti_InvMass_All_m7->Fill(params.fMinv);
1222 }
1223 }
1224
1225 // zero
1226 Int_t nof_zero = EMT_Event_multi_zero.size();
1227 cout << "MixedEvent - nof entries zero " << nof_zero << endl;
1228 for (Int_t a = 0; a < nof_zero - 1; a++) {
1229 for (Int_t b = a + 1; b < nof_zero; b++) {
1230 if (EMT_Event_multi_zero[a] == EMT_Event_multi_zero[b])
1231 continue; // to make sure that the photons are from two different events
1232 if (EMT_multi_zero[a] != EMT_multi_zero[b]) continue; // check same multiplicity
1233 TVector3 e11 = EMT_pair_momenta_multi_zero[a][0];
1234 TVector3 e12 = EMT_pair_momenta_multi_zero[a][1];
1235 TVector3 e21 = EMT_pair_momenta_multi_zero[b][0];
1236 TVector3 e22 = EMT_pair_momenta_multi_zero[b][1];
1237 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
1238
1239 if (EMT_multi_zero[a] == 1) EMTMulti_InvMass_Zero_m1->Fill(params.fMinv);
1240 if (EMT_multi_zero[a] == 2) EMTMulti_InvMass_Zero_m2->Fill(params.fMinv);
1241 if (EMT_multi_zero[a] == 3) EMTMulti_InvMass_Zero_m3->Fill(params.fMinv);
1242 if (EMT_multi_zero[a] == 4) EMTMulti_InvMass_Zero_m4->Fill(params.fMinv);
1243 if (EMT_multi_zero[a] == 5) EMTMulti_InvMass_Zero_m5->Fill(params.fMinv);
1244 if (EMT_multi_zero[a] == 6) EMTMulti_InvMass_Zero_m6->Fill(params.fMinv);
1245 if (EMT_multi_zero[a] == 7) EMTMulti_InvMass_Zero_m7->Fill(params.fMinv);
1246 }
1247 }
1248
1249 // one
1250 Int_t nof_one = EMT_Event_multi_one.size();
1251 cout << "MixedEvent - nof entries one " << nof_one << endl;
1252 for (Int_t a = 0; a < nof_one - 1; a++) {
1253 for (Int_t b = a + 1; b < nof_one; b++) {
1254 if (EMT_Event_multi_one[a] == EMT_Event_multi_one[b])
1255 continue; // to make sure that the photons are from two different events
1256 if (EMT_multi_one[a] != EMT_multi_one[b]) continue; // check same multiplicity
1257 TVector3 e11 = EMT_pair_momenta_multi_one[a][0];
1258 TVector3 e12 = EMT_pair_momenta_multi_one[a][1];
1259 TVector3 e21 = EMT_pair_momenta_multi_one[b][0];
1260 TVector3 e22 = EMT_pair_momenta_multi_one[b][1];
1261 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
1262
1263 if (EMT_multi_one[a] == 1) EMTMulti_InvMass_One_m1->Fill(params.fMinv);
1264 if (EMT_multi_one[a] == 2) EMTMulti_InvMass_One_m2->Fill(params.fMinv);
1265 if (EMT_multi_one[a] == 3) EMTMulti_InvMass_One_m3->Fill(params.fMinv);
1266 if (EMT_multi_one[a] == 4) EMTMulti_InvMass_One_m4->Fill(params.fMinv);
1267 if (EMT_multi_one[a] == 5) EMTMulti_InvMass_One_m5->Fill(params.fMinv);
1268 if (EMT_multi_one[a] == 6) EMTMulti_InvMass_One_m6->Fill(params.fMinv);
1269 if (EMT_multi_one[a] == 7) EMTMulti_InvMass_One_m7->Fill(params.fMinv);
1270 }
1271 }
1272
1273 // two
1274 Int_t nof_two = EMT_Event_multi_two.size();
1275 cout << "MixedEvent - nof entries two " << nof_two << endl;
1276 for (Int_t a = 0; a < nof_two - 1; a++) {
1277 for (Int_t b = a + 1; b < nof_two; b++) {
1278 if (EMT_Event_multi_two[a] == EMT_Event_multi_two[b])
1279 continue; // to make sure that the photons are from two different events
1280 if (EMT_multi_two[a] != EMT_multi_two[b]) continue; // check same multiplicity
1281 TVector3 e11 = EMT_pair_momenta_multi_two[a][0];
1282 TVector3 e12 = EMT_pair_momenta_multi_two[a][1];
1283 TVector3 e21 = EMT_pair_momenta_multi_two[b][0];
1284 TVector3 e22 = EMT_pair_momenta_multi_two[b][1];
1285 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
1286
1287 if (EMT_multi_two[a] == 1) EMTMulti_InvMass_Two_m1->Fill(params.fMinv);
1288 if (EMT_multi_two[a] == 2) EMTMulti_InvMass_Two_m2->Fill(params.fMinv);
1289 if (EMT_multi_two[a] == 3) EMTMulti_InvMass_Two_m3->Fill(params.fMinv);
1290 if (EMT_multi_two[a] == 4) EMTMulti_InvMass_Two_m4->Fill(params.fMinv);
1291 if (EMT_multi_two[a] == 5) EMTMulti_InvMass_Two_m5->Fill(params.fMinv);
1292 if (EMT_multi_two[a] == 6) EMTMulti_InvMass_Two_m6->Fill(params.fMinv);
1293 if (EMT_multi_two[a] == 7) EMTMulti_InvMass_Two_m7->Fill(params.fMinv);
1294 }
1295 }
1296
1297 // onetwo
1298 Int_t nof_onetwo = EMT_Event_multi_onetwo.size();
1299 cout << "MixedEvent - nof entries onetwo " << nof_onetwo << endl;
1300 for (Int_t a = 0; a < nof_onetwo - 1; a++) {
1301 for (Int_t b = a + 1; b < nof_onetwo; b++) {
1302 if (EMT_Event_multi_onetwo[a] == EMT_Event_multi_onetwo[b])
1303 continue; // to make sure that the photons are from two different events
1304 if (EMT_multi_onetwo[a] != EMT_multi_onetwo[b]) continue; // check same multiplicity
1305 TVector3 e11 = EMT_pair_momenta_multi_onetwo[a][0];
1306 TVector3 e12 = EMT_pair_momenta_multi_onetwo[a][1];
1307 TVector3 e21 = EMT_pair_momenta_multi_onetwo[b][0];
1308 TVector3 e22 = EMT_pair_momenta_multi_onetwo[b][1];
1309 LmvmKinePar params = CbmKresFunctions::CalculateKinematicParams_4particles(e11, e12, e21, e22);
1310
1311 if (EMT_multi_onetwo[a] == 1) EMTMulti_InvMass_OneTwo_m1->Fill(params.fMinv);
1312 if (EMT_multi_onetwo[a] == 2) EMTMulti_InvMass_OneTwo_m2->Fill(params.fMinv);
1313 if (EMT_multi_onetwo[a] == 3) EMTMulti_InvMass_OneTwo_m3->Fill(params.fMinv);
1314 if (EMT_multi_onetwo[a] == 4) EMTMulti_InvMass_OneTwo_m4->Fill(params.fMinv);
1315 if (EMT_multi_onetwo[a] == 5) EMTMulti_InvMass_OneTwo_m5->Fill(params.fMinv);
1316 if (EMT_multi_onetwo[a] == 6) EMTMulti_InvMass_OneTwo_m6->Fill(params.fMinv);
1317 if (EMT_multi_onetwo[a] == 7) EMTMulti_InvMass_OneTwo_m7->Fill(params.fMinv);
1318 }
1319 }
1320}
1321
1322
1323void CbmKresConversionKF::Finish()
1324{
1325 gDirectory->mkdir("KF");
1326 gDirectory->cd("KF");
1327
1328
1329 gDirectory->mkdir("CheckCuts");
1330 gDirectory->cd("CheckCuts");
1331 for (UInt_t i = 0; i < fHistoList_CheckForCuts.size(); i++) {
1332 fHistoList_CheckForCuts[i]->Write();
1333 }
1334 gDirectory->cd("..");
1335
1336
1337 gDirectory->mkdir("multiplicity");
1338 gDirectory->cd("multiplicity");
1339 gDirectory->mkdir("All");
1340 gDirectory->cd("All");
1341 for (UInt_t i = 0; i < fHistoList_multiplicity_All.size(); i++) {
1342 fHistoList_multiplicity_All[i]->Write();
1343 }
1344 gDirectory->cd("..");
1345 gDirectory->mkdir("Zero");
1346 gDirectory->cd("Zero");
1347 for (UInt_t i = 0; i < fHistoList_multiplicity_Zero.size(); i++) {
1348 fHistoList_multiplicity_Zero[i]->Write();
1349 }
1350 gDirectory->cd("..");
1351 gDirectory->mkdir("One");
1352 gDirectory->cd("One");
1353 for (UInt_t i = 0; i < fHistoList_multiplicity_One.size(); i++) {
1354 fHistoList_multiplicity_One[i]->Write();
1355 }
1356 gDirectory->cd("..");
1357 gDirectory->mkdir("Two");
1358 gDirectory->cd("Two");
1359 for (UInt_t i = 0; i < fHistoList_multiplicity_Two.size(); i++) {
1360 fHistoList_multiplicity_Two[i]->Write();
1361 }
1362 gDirectory->cd("..");
1363 gDirectory->mkdir("OneTwo");
1364 gDirectory->cd("OneTwo");
1365 for (UInt_t i = 0; i < fHistoList_multiplicity_OneTwo.size(); i++) {
1366 fHistoList_multiplicity_OneTwo[i]->Write();
1367 }
1368 gDirectory->cd("..");
1369 for (UInt_t i = 0; i < fHistoList_multiplicity.size(); i++) {
1370 fHistoList_multiplicity[i]->Write();
1371 }
1372 gDirectory->cd("..");
1373
1374
1375 gDirectory->mkdir("BG");
1376 gDirectory->cd("BG");
1377 gDirectory->mkdir("BG_all");
1378 gDirectory->cd("BG_all");
1379 for (UInt_t i = 0; i < fHistoList_bg_all.size(); i++) {
1380 fHistoList_bg_all[i]->Write();
1381 }
1382 gDirectory->cd("..");
1383 gDirectory->mkdir("BG_zero");
1384 gDirectory->cd("BG_zero");
1385 for (UInt_t i = 0; i < fHistoList_bg_zero.size(); i++) {
1386 fHistoList_bg_zero[i]->Write();
1387 }
1388 gDirectory->cd("..");
1389 gDirectory->mkdir("BG_one");
1390 gDirectory->cd("BG_one");
1391 for (UInt_t i = 0; i < fHistoList_bg_one.size(); i++) {
1392 fHistoList_bg_one[i]->Write();
1393 }
1394 gDirectory->cd("..");
1395 gDirectory->mkdir("BG_two");
1396 gDirectory->cd("BG_two");
1397 for (UInt_t i = 0; i < fHistoList_bg_two.size(); i++) {
1398 fHistoList_bg_two[i]->Write();
1399 }
1400 gDirectory->cd("..");
1401 gDirectory->mkdir("BG_onetwo");
1402 gDirectory->cd("BG_onetwo");
1403 for (UInt_t i = 0; i < fHistoList_bg_onetwo.size(); i++) {
1404 fHistoList_bg_onetwo[i]->Write();
1405 }
1406 gDirectory->cd("..");
1407 gDirectory->cd("..");
1408
1409
1410 gDirectory->mkdir("g->All");
1411 gDirectory->cd("g->All");
1412 gDirectory->mkdir("target(<4cm)");
1413 gDirectory->cd("target(<4cm)");
1414 for (UInt_t i = 0; i < fHistoList_All_target.size(); i++) {
1415 fHistoList_All_target[i]->Write();
1416 }
1417 gDirectory->cd("..");
1418 gDirectory->mkdir("mvd(4cm-21cm)");
1419 gDirectory->cd("mvd(4cm-21cm)");
1420 for (UInt_t i = 0; i < fHistoList_All_mvd.size(); i++) {
1421 fHistoList_All_mvd[i]->Write();
1422 }
1423 gDirectory->cd("..");
1424 gDirectory->mkdir("sts(21cm-75cm)");
1425 gDirectory->cd("sts(21cm-75cm)");
1426 for (UInt_t i = 0; i < fHistoList_All_sts.size(); i++) {
1427 fHistoList_All_sts[i]->Write();
1428 }
1429 gDirectory->cd("..");
1430 gDirectory->mkdir("outside the target(>4cm)");
1431 gDirectory->cd("outside the target(>4cm)");
1432 for (UInt_t i = 0; i < fHistoList_All_outside.size(); i++) {
1433 fHistoList_All_outside[i]->Write();
1434 }
1435 gDirectory->cd("..");
1436 for (UInt_t i = 0; i < fHistoList_All.size(); i++) {
1437 fHistoList_All[i]->Write();
1438 }
1439 gDirectory->cd("..");
1440
1441
1442 gDirectory->mkdir("g->Zero");
1443 gDirectory->cd("g->Zero");
1444 gDirectory->mkdir("target(<4cm)");
1445 gDirectory->cd("target(<4cm)");
1446 for (UInt_t i = 0; i < fHistoList_Zero_target.size(); i++) {
1447 fHistoList_Zero_target[i]->Write();
1448 }
1449 gDirectory->cd("..");
1450 gDirectory->mkdir("mvd(4cm-21cm)");
1451 gDirectory->cd("mvd(4cm-21cm)");
1452 for (UInt_t i = 0; i < fHistoList_Zero_mvd.size(); i++) {
1453 fHistoList_Zero_mvd[i]->Write();
1454 }
1455 gDirectory->cd("..");
1456 gDirectory->mkdir("sts(21cm-75cm)");
1457 gDirectory->cd("sts(21cm-75cm)");
1458 for (UInt_t i = 0; i < fHistoList_Zero_sts.size(); i++) {
1459 fHistoList_Zero_sts[i]->Write();
1460 }
1461 gDirectory->cd("..");
1462 gDirectory->mkdir("outside the target(>4cm)");
1463 gDirectory->cd("outside the target(>4cm)");
1464 for (UInt_t i = 0; i < fHistoList_Zero_outside.size(); i++) {
1465 fHistoList_Zero_outside[i]->Write();
1466 }
1467 gDirectory->cd("..");
1468 for (UInt_t i = 0; i < fHistoList_Zero.size(); i++) {
1469 fHistoList_Zero[i]->Write();
1470 }
1471 gDirectory->cd("..");
1472
1473
1474 gDirectory->mkdir("g->One");
1475 gDirectory->cd("g->One");
1476 gDirectory->mkdir("target(<4cm)");
1477 gDirectory->cd("target(<4cm)");
1478 for (UInt_t i = 0; i < fHistoList_One_target.size(); i++) {
1479 fHistoList_One_target[i]->Write();
1480 }
1481 gDirectory->cd("..");
1482 gDirectory->mkdir("mvd(4cm-21cm)");
1483 gDirectory->cd("mvd(4cm-21cm)");
1484 for (UInt_t i = 0; i < fHistoList_One_mvd.size(); i++) {
1485 fHistoList_One_mvd[i]->Write();
1486 }
1487 gDirectory->cd("..");
1488 gDirectory->mkdir("sts(21cm-75cm)");
1489 gDirectory->cd("sts(21cm-75cm)");
1490 for (UInt_t i = 0; i < fHistoList_One_sts.size(); i++) {
1491 fHistoList_One_sts[i]->Write();
1492 }
1493 gDirectory->cd("..");
1494 gDirectory->mkdir("outside the target(>4cm)");
1495 gDirectory->cd("outside the target(>4cm)");
1496 for (UInt_t i = 0; i < fHistoList_One_outside.size(); i++) {
1497 fHistoList_One_outside[i]->Write();
1498 }
1499 gDirectory->cd("..");
1500 for (UInt_t i = 0; i < fHistoList_One.size(); i++) {
1501 fHistoList_One[i]->Write();
1502 }
1503 gDirectory->cd("..");
1504
1505
1506 gDirectory->mkdir("g->Two");
1507 gDirectory->cd("g->Two");
1508 gDirectory->mkdir("target(<4cm)");
1509 gDirectory->cd("target(<4cm)");
1510 for (UInt_t i = 0; i < fHistoList_Two_target.size(); i++) {
1511 fHistoList_Two_target[i]->Write();
1512 }
1513 gDirectory->cd("..");
1514 gDirectory->mkdir("mvd(4cm-21cm)");
1515 gDirectory->cd("mvd(4cm-21cm)");
1516 for (UInt_t i = 0; i < fHistoList_Two_mvd.size(); i++) {
1517 fHistoList_Two_mvd[i]->Write();
1518 }
1519 gDirectory->cd("..");
1520 gDirectory->mkdir("sts(21cm-75cm)");
1521 gDirectory->cd("sts(21cm-75cm)");
1522 for (UInt_t i = 0; i < fHistoList_Two_sts.size(); i++) {
1523 fHistoList_Two_sts[i]->Write();
1524 }
1525 gDirectory->cd("..");
1526 gDirectory->mkdir("outside the target(>4cm)");
1527 gDirectory->cd("outside the target(>4cm)");
1528 for (UInt_t i = 0; i < fHistoList_Two_outside.size(); i++) {
1529 fHistoList_Two_outside[i]->Write();
1530 }
1531 gDirectory->cd("..");
1532 for (UInt_t i = 0; i < fHistoList_Two.size(); i++) {
1533 fHistoList_Two[i]->Write();
1534 }
1535 gDirectory->cd("..");
1536
1537
1538 gDirectory->mkdir("g->OneTwo");
1539 gDirectory->cd("g->OneTwo");
1540 gDirectory->mkdir("target(<4cm)");
1541 gDirectory->cd("target(<4cm)");
1542 for (UInt_t i = 0; i < fHistoList_OneTwo_target.size(); i++) {
1543 fHistoList_OneTwo_target[i]->Write();
1544 }
1545 gDirectory->cd("..");
1546 gDirectory->mkdir("mvd(4cm-21cm)");
1547 gDirectory->cd("mvd(4cm-21cm)");
1548 for (UInt_t i = 0; i < fHistoList_OneTwo_mvd.size(); i++) {
1549 fHistoList_OneTwo_mvd[i]->Write();
1550 }
1551 gDirectory->cd("..");
1552 gDirectory->mkdir("sts(21cm-75cm)");
1553 gDirectory->cd("sts(21cm-75cm)");
1554 for (UInt_t i = 0; i < fHistoList_OneTwo_sts.size(); i++) {
1555 fHistoList_OneTwo_sts[i]->Write();
1556 }
1557 gDirectory->cd("..");
1558 gDirectory->mkdir("outside the target(>4cm)");
1559 gDirectory->cd("outside the target(>4cm)");
1560 for (UInt_t i = 0; i < fHistoList_OneTwo_outside.size(); i++) {
1561 fHistoList_OneTwo_outside[i]->Write();
1562 }
1563 gDirectory->cd("..");
1564 for (UInt_t i = 0; i < fHistoList_OneTwo.size(); i++) {
1565 fHistoList_OneTwo[i]->Write();
1566 }
1567 gDirectory->cd("..");
1568
1569
1570 gDirectory->cd("..");
1571}
1572
1573void CbmKresConversionKF::InitHistograms()
1574{
1576 CheckForCuts_InvMass_MC =
1577 new TH1D("CheckForCuts_InvMass_MC", "CheckForCuts_InvMass_MC; invariant mass in GeV/c^{2};#", 510, -0.01, 0.5);
1578 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_MC);
1579 CheckForCuts_InvMass_Reco =
1580 new TH1D("CheckForCuts_InvMass_Reco", "CheckForCuts_InvMass_Reco; invariant mass in GeV/c^{2};#", 510, -0.01, 0.5);
1581 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco);
1582 CheckForCuts_OA_MC = new TH1D("CheckForCuts_OA_MC", "CheckForCuts_OA_MC; #theta angle [deg];#", 300, -0.1, 29.9);
1583 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_MC);
1584 CheckForCuts_OA_Reco =
1585 new TH1D("CheckForCuts_OA_Reco", "CheckForCuts_OA_Reco; #theta angle [deg];#", 300, -0.1, 29.9);
1586 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco);
1587 CheckForCuts_InvMass_MC_from_one_pi0 =
1588 new TH1D("CheckForCuts_InvMass_MC_from_one_pi0",
1589 "CheckForCuts_InvMass_MC_from_one_pi0; invariant mass in GeV/c^{2};#", 510, -0.01, 0.5);
1590 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_MC_from_one_pi0);
1591 CheckForCuts_InvMass_Reco_from_one_pi0 =
1592 new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0",
1593 "CheckForCuts_InvMass_Reco_from_one_pi0; invariant mass in GeV/c^{2};#", 510, -0.01, 0.5);
1594 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco_from_one_pi0);
1595 CheckForCuts_OA_MC_from_one_pi0 =
1596 new TH1D("CheckForCuts_OA_MC_from_one_pi0", "CheckForCuts_OA_MC_from_one_pi0; angle [deg];#", 300, -0.1, 29.9);
1597 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_MC_from_one_pi0);
1598 CheckForCuts_OA_Reco_from_one_pi0 =
1599 new TH1D("CheckForCuts_OA_Reco_from_one_pi0", "CheckForCuts_OA_Reco_from_one_pi0; angle [deg];#", 300, -0.1, 29.9);
1600 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0);
1601 CheckForCuts_z_vs_InvMass_MC_from_one_pi0 = new TH2D("CheckForCuts_z_vs_InvMass_MC_from_one_pi0",
1602 "CheckForCuts_z_vs_InvMass_MC_from_one_pi0; Z [cm]; invariant "
1603 "mass in GeV/c^{2}; Nof",
1604 1000, -1, 99, 310, -0.01, 0.3);
1605 fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_InvMass_MC_from_one_pi0);
1606 CheckForCuts_z_vs_InvMass_Reco_from_one_pi0 =
1607 new TH2D("CheckForCuts_z_vs_InvMass_Reco_from_one_pi0",
1608 "CheckForCuts_z_vs_InvMass_Reco_from_one_pi0; Z [cm]; invariant "
1609 "mass in GeV/c^{2}; Nof",
1610 1000, -1, 99, 310, -0.01, 0.3);
1611 fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_InvMass_Reco_from_one_pi0);
1612 CheckForCuts_z_vs_OA_MC_from_one_pi0 =
1613 new TH2D("CheckForCuts_z_vs_OA_MC_from_one_pi0", "CheckForCuts_z_vs_OA_MC_from_one_pi0; Z [cm]; #theta in deg; Nof",
1614 1000, -1, 99, 300, -0.1, 29.9);
1615 fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_OA_MC_from_one_pi0);
1616 CheckForCuts_z_vs_OA_Reco_from_one_pi0 =
1617 new TH2D("CheckForCuts_z_vs_OA_Reco_from_one_pi0",
1618 "CheckForCuts_z_vs_OA_Reco_from_one_pi0; Z [cm]; #theta in deg; Nof", 1000, -1, 99, 300, -0.1, 29.9);
1619 fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_OA_Reco_from_one_pi0);
1620 CheckForCuts_InvMass_Reco_from_one_pi0_less4cm =
1621 new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0_less4cm",
1622 "CheckForCuts_InvMass_Reco_from_one_pi0_less4cm; invariant mass "
1623 "in GeV/c^{2};#",
1624 310, -0.01, 0.3);
1625 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco_from_one_pi0_less4cm);
1626 CheckForCuts_OA_Reco_from_one_pi0_less4cm =
1627 new TH1D("CheckForCuts_OA_Reco_from_one_pi0_less4cm", "CheckForCuts_OA_Reco_from_one_pi0_less4cm; angle [deg];#",
1628 300, -0.1, 29.9);
1629 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0_less4cm);
1630 CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm =
1631 new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm",
1632 "CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm; invariant mass "
1633 "in GeV/c^{2};#",
1634 310, -0.01, 0.3);
1635 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm);
1636 CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm =
1637 new TH1D("CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm", "CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm; angle [deg];#",
1638 300, -0.1, 29.9);
1639 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm);
1640 CheckForCuts_InvMass_Reco_from_one_pi0_more21cm =
1641 new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0_more21cm",
1642 "CheckForCuts_InvMass_Reco_from_one_pi0_more21cm; invariant mass "
1643 "in GeV/c^{2};#",
1644 310, -0.01, 0.3);
1645 fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco_from_one_pi0_more21cm);
1646 CheckForCuts_OA_Reco_from_one_pi0_more21cm =
1647 new TH1D("CheckForCuts_OA_Reco_from_one_pi0_more21cm", "CheckForCuts_OA_Reco_from_one_pi0_more21cm; angle [deg];#",
1648 300, -0.1, 29.9);
1649 fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0_more21cm);
1650
1651
1652 // 0-2 => All
1653 fGammaInvMassReco_All =
1654 new TH1D("fGammaInvMassReco_All", "fGammaInvMassReco_All; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1655 fHistoList_All.push_back(fGammaInvMassReco_All);
1656 fGammaOpeningAngleReco_All =
1657 new TH1D("fGammaOpeningAngleReco_All", "fGammaOpeningAngleReco_All; angle [deg];#", 200, -0.1, 19.9);
1658 fHistoList_All.push_back(fGammaOpeningAngleReco_All);
1659 fPdg_All = new TH1D("fPdg_All", "fPdg_All; Id ;#", 800, 0, 400);
1660 fHistoList_All.push_back(fPdg_All);
1661 fP_reco_All = new TH1D("fP_reco_All", "fP_reco_All; P in GeV/c^{2} ;#", 600, 0, 6);
1662 fHistoList_All.push_back(fP_reco_All);
1663 fPt_reco_All = new TH1D("fPt_reco_All", "fPt_reco_All; Pt in GeV/c^{2} ;#", 300, 0, 3);
1664 fHistoList_All.push_back(fPt_reco_All);
1665 fPi0InvMassRecoKF_All =
1666 new TH1D("fPi0InvMassRecoKF_All", "fPi0InvMassRecoKF_All; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1667 fHistoList_All.push_back(fPi0InvMassRecoKF_All);
1668 fEMT_InvMass_All = new TH1D("fEMT_InvMass_All", "fEMT_InvMass_All; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1669 fHistoList_All.push_back(fEMT_InvMass_All);
1670 fPi0_pt_vs_rap_All =
1671 new TH2D("fPi0_pt_vs_rap_All", "fPi0_pt_vs_rap_All; rapidity y; p_{t} in GeV/c ", 90, -2., 7., 60, -1., 5.);
1672 fHistoList_All.push_back(fPi0_pt_vs_rap_All);
1673 fPi0_pt_vs_rap_est_All =
1674 new TH2D("fPi0_pt_vs_rap_est_All", "fPi0_pt_vs_rap_est_All; rapidity y; p_{t} in GeV/c ", 10, 0., 4., 10, 0., 4.);
1675 fHistoList_All.push_back(fPi0_pt_vs_rap_est_All);
1676 // 0-2 => All target
1677 fGammaInvMassReco_All_target = new TH1D(
1678 "fGammaInvMassReco_All_target", "fGammaInvMassReco_All_target; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1679 fHistoList_All_target.push_back(fGammaInvMassReco_All_target);
1680 fGammaOpeningAngleReco_All_target =
1681 new TH1D("fGammaOpeningAngleReco_All_target", "fGammaOpeningAngleReco_All_target; angle [deg];#", 200, -0.1, 19.9);
1682 fHistoList_All_target.push_back(fGammaOpeningAngleReco_All_target);
1683 fPi0InvMassRecoKF_All_target = new TH1D("fPi0InvMassRecoKF_All_target",
1684 "fPi0InvMassRecoKF_All_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1685 fHistoList_All_target.push_back(fPi0InvMassRecoKF_All_target);
1686 fEMT_InvMass_All_target =
1687 new TH1D("fEMT_InvMass_All_target", "fEMT_InvMass_All_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1688 fHistoList_All_target.push_back(fEMT_InvMass_All_target);
1689 // 0-2 => All mvd
1690 fGammaInvMassReco_All_mvd =
1691 new TH1D("fGammaInvMassReco_All_mvd", "fGammaInvMassReco_All_mvd; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1692 fHistoList_All_mvd.push_back(fGammaInvMassReco_All_mvd);
1693 fGammaOpeningAngleReco_All_mvd =
1694 new TH1D("fGammaOpeningAngleReco_All_mvd", "fGammaOpeningAngleReco_All_mvd; angle [deg];#", 200, -0.1, 19.9);
1695 fHistoList_All_mvd.push_back(fGammaOpeningAngleReco_All_mvd);
1696 fPi0InvMassRecoKF_All_mvd =
1697 new TH1D("fPi0InvMassRecoKF_All_mvd", "fPi0InvMassRecoKF_All_mvd; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1698 fHistoList_All_mvd.push_back(fPi0InvMassRecoKF_All_mvd);
1699 // 0-2 => All sts
1700 fGammaInvMassReco_All_sts =
1701 new TH1D("fGammaInvMassReco_All_sts", "fGammaInvMassReco_All_sts; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1702 fHistoList_All_sts.push_back(fGammaInvMassReco_All_sts);
1703 fGammaOpeningAngleReco_All_sts =
1704 new TH1D("fGammaOpeningAngleReco_All_sts", "fGammaOpeningAngleReco_All_sts; angle [deg];#", 200, -0.1, 19.9);
1705 fHistoList_All_sts.push_back(fGammaOpeningAngleReco_All_sts);
1706 fPi0InvMassRecoKF_All_sts =
1707 new TH1D("fPi0InvMassRecoKF_All_sts", "fPi0InvMassRecoKF_All_sts; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1708 fHistoList_All_sts.push_back(fPi0InvMassRecoKF_All_sts);
1709 // 0-2 => All outside the target (mvd+sts+pipe)
1710 fGammaInvMassReco_All_outside = new TH1D(
1711 "fGammaInvMassReco_All_outside", "fGammaInvMassReco_All_outside; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1712 fHistoList_All_outside.push_back(fGammaInvMassReco_All_outside);
1713 fGammaOpeningAngleReco_All_outside = new TH1D("fGammaOpeningAngleReco_All_outside",
1714 "fGammaOpeningAngleReco_All_outside; angle [deg];#", 200, -0.1, 19.9);
1715 fHistoList_All_outside.push_back(fGammaOpeningAngleReco_All_outside);
1716 fPi0InvMassRecoKF_All_outside = new TH1D(
1717 "fPi0InvMassRecoKF_All_outside", "fPi0InvMassRecoKF_All_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1718 fHistoList_All_outside.push_back(fPi0InvMassRecoKF_All_outside);
1719 fEMT_InvMass_All_outside =
1720 new TH1D("fEMT_InvMass_All_outside", "fEMT_InvMass_All_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1721 fHistoList_All_outside.push_back(fEMT_InvMass_All_outside);
1722
1723
1724 // 0 => Zero
1725 fGammaInvMassReco_Zero =
1726 new TH1D("fGammaInvMassReco_Zero", "fGammaInvMassReco_Zero; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1727 fHistoList_Zero.push_back(fGammaInvMassReco_Zero);
1728 fGammaOpeningAngleReco_Zero =
1729 new TH1D("fGammaOpeningAngleReco_Zero", "fGammaOpeningAngleReco_Zero; angle [deg];#", 200, -0.1, 19.9);
1730 fHistoList_Zero.push_back(fGammaOpeningAngleReco_Zero);
1731 fPdg_Zero = new TH1D("fPdg_Zero", "fPdg_Zero; Id ;#", 800, 0, 400);
1732 fHistoList_Zero.push_back(fPdg_Zero);
1733 fP_reco_Zero = new TH1D("fP_reco_Zero", "fP_reco_Zero; P in GeV/c^{2} ;#", 600, 0, 6);
1734 fHistoList_Zero.push_back(fP_reco_Zero);
1735 fPt_reco_Zero = new TH1D("fPt_reco_Zero", "fPt_reco_Zero; Pt in GeV/c^{2} ;#", 300, 0, 3);
1736 fHistoList_Zero.push_back(fPt_reco_Zero);
1737 fPi0InvMassRecoKF_Zero =
1738 new TH1D("fPi0InvMassRecoKF_Zero", "fPi0InvMassRecoKF_Zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1739 fHistoList_Zero.push_back(fPi0InvMassRecoKF_Zero);
1740 fEMT_InvMass_Zero = new TH1D("fEMT_InvMass_Zero", "fEMT_InvMass_Zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1741 fHistoList_Zero.push_back(fEMT_InvMass_Zero);
1742 fPi0_pt_vs_rap_Zero =
1743 new TH2D("fPi0_pt_vs_rap_Zero", "fPi0_pt_vs_rap_Zero; rapidity y; p_{t} in GeV/c ", 90, -2., 7., 60, -1., 5.);
1744 fHistoList_Zero.push_back(fPi0_pt_vs_rap_Zero);
1745 fPi0_pt_vs_rap_est_Zero =
1746 new TH2D("fPi0_pt_vs_rap_est_Zero", "fPi0_pt_vs_rap_est_Zero; rapidity y; p_{t} in GeV/c ", 10, 0., 4., 10, 0., 4.);
1747 fHistoList_Zero.push_back(fPi0_pt_vs_rap_est_Zero);
1748 // 0 => Zero target
1749 fGammaInvMassReco_Zero_target = new TH1D(
1750 "fGammaInvMassReco_Zero_target", "fGammaInvMassReco_Zero_target; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1751 fHistoList_Zero_target.push_back(fGammaInvMassReco_Zero_target);
1752 fGammaOpeningAngleReco_Zero_target = new TH1D("fGammaOpeningAngleReco_Zero_target",
1753 "fGammaOpeningAngleReco_Zero_target; angle [deg];#", 200, -0.1, 19.9);
1754 fHistoList_Zero_target.push_back(fGammaOpeningAngleReco_Zero_target);
1755 fPi0InvMassRecoKF_Zero_target = new TH1D(
1756 "fPi0InvMassRecoKF_Zero_target", "fPi0InvMassRecoKF_Zero_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1757 fHistoList_Zero_target.push_back(fPi0InvMassRecoKF_Zero_target);
1758 fEMT_InvMass_Zero_target =
1759 new TH1D("fEMT_InvMass_Zero_target", "fEMT_InvMass_Zero_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1760 fHistoList_Zero_target.push_back(fEMT_InvMass_Zero_target);
1761 // 0 => Zero mvd
1762 fGammaInvMassReco_Zero_mvd = new TH1D("fGammaInvMassReco_Zero_mvd",
1763 "fGammaInvMassReco_Zero_mvd; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1764 fHistoList_Zero_mvd.push_back(fGammaInvMassReco_Zero_mvd);
1765 fGammaOpeningAngleReco_Zero_mvd =
1766 new TH1D("fGammaOpeningAngleReco_Zero_mvd", "fGammaOpeningAngleReco_Zero_mvd; angle [deg];#", 200, -0.1, 19.9);
1767 fHistoList_Zero_mvd.push_back(fGammaOpeningAngleReco_Zero_mvd);
1768 fPi0InvMassRecoKF_Zero_mvd =
1769 new TH1D("fPi0InvMassRecoKF_Zero_mvd", "fPi0InvMassRecoKF_Zero_mvd; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1770 fHistoList_Zero_mvd.push_back(fPi0InvMassRecoKF_Zero_mvd);
1771 // 0 => Zero sts
1772 fGammaInvMassReco_Zero_sts = new TH1D("fGammaInvMassReco_Zero_sts",
1773 "fGammaInvMassReco_Zero_sts; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1774 fHistoList_Zero_sts.push_back(fGammaInvMassReco_Zero_sts);
1775 fGammaOpeningAngleReco_Zero_sts =
1776 new TH1D("fGammaOpeningAngleReco_Zero_sts", "fGammaOpeningAngleReco_Zero_sts; angle [deg];#", 200, -0.1, 19.9);
1777 fHistoList_Zero_sts.push_back(fGammaOpeningAngleReco_Zero_sts);
1778 fPi0InvMassRecoKF_Zero_sts =
1779 new TH1D("fPi0InvMassRecoKF_Zero_sts", "fPi0InvMassRecoKF_Zero_sts; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1780 fHistoList_Zero_sts.push_back(fPi0InvMassRecoKF_Zero_sts);
1781 // 0 => Zero outside the target (mvd+sts+pipe)
1782 fGammaInvMassReco_Zero_outside = new TH1D(
1783 "fGammaInvMassReco_Zero_outside", "fGammaInvMassReco_Zero_outside; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1784 fHistoList_Zero_outside.push_back(fGammaInvMassReco_Zero_outside);
1785 fGammaOpeningAngleReco_Zero_outside = new TH1D("fGammaOpeningAngleReco_Zero_outside",
1786 "fGammaOpeningAngleReco_Zero_outside; angle [deg];#", 200, -0.1, 19.9);
1787 fHistoList_Zero_outside.push_back(fGammaOpeningAngleReco_Zero_outside);
1788 fPi0InvMassRecoKF_Zero_outside = new TH1D(
1789 "fPi0InvMassRecoKF_Zero_outside", "fPi0InvMassRecoKF_Zero_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1790 fHistoList_Zero_outside.push_back(fPi0InvMassRecoKF_Zero_outside);
1791 fEMT_InvMass_Zero_outside =
1792 new TH1D("fEMT_InvMass_Zero_outside", "fEMT_InvMass_Zero_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1793 fHistoList_Zero_outside.push_back(fEMT_InvMass_Zero_outside);
1794
1795
1796 // 1 => One
1797 fGammaInvMassReco_One =
1798 new TH1D("fGammaInvMassReco_One", "fGammaInvMassReco_One; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1799 fHistoList_One.push_back(fGammaInvMassReco_One);
1800 fGammaOpeningAngleReco_One =
1801 new TH1D("fGammaOpeningAngleReco_One", "fGammaOpeningAngleReco_One; angle [deg];#", 200, -0.1, 19.9);
1802 fHistoList_One.push_back(fGammaOpeningAngleReco_One);
1803 fPdg_One = new TH1D("fPdg_One", "fPdg_One; Id ;#", 800, 0, 400);
1804 fHistoList_One.push_back(fPdg_One);
1805 fP_reco_One = new TH1D("fP_reco_One", "fP_reco_One; P in GeV/c^{2} ;#", 600, 0, 6);
1806 fHistoList_One.push_back(fP_reco_One);
1807 fPt_reco_One = new TH1D("fPt_reco_One", "fPt_reco_One; Pt in GeV/c^{2} ;#", 300, 0, 3);
1808 fHistoList_One.push_back(fPt_reco_One);
1809 fPi0InvMassRecoKF_One =
1810 new TH1D("fPi0InvMassRecoKF_One", "fPi0InvMassRecoKF_One; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1811 fHistoList_One.push_back(fPi0InvMassRecoKF_One);
1812 fEMT_InvMass_One = new TH1D("fEMT_InvMass_One", "fEMT_InvMass_One; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1813 fHistoList_One.push_back(fEMT_InvMass_One);
1814 fPi0_pt_vs_rap_One =
1815 new TH2D("fPi0_pt_vs_rap_One", "fPi0_pt_vs_rap_One; rapidity y; p_{t} in GeV/c ", 90, -2., 7., 60, -1., 5.);
1816 fHistoList_One.push_back(fPi0_pt_vs_rap_One);
1817 fPi0_pt_vs_rap_est_One =
1818 new TH2D("fPi0_pt_vs_rap_est_One", "fPi0_pt_vs_rap_est_One; rapidity y; p_{t} in GeV/c ", 10, 0., 4., 10, 0., 4.);
1819 fHistoList_One.push_back(fPi0_pt_vs_rap_est_One);
1820 // 1 => One target
1821 fGammaInvMassReco_One_target = new TH1D(
1822 "fGammaInvMassReco_One_target", "fGammaInvMassReco_One_target; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1823 fHistoList_One_target.push_back(fGammaInvMassReco_One_target);
1824 fGammaOpeningAngleReco_One_target =
1825 new TH1D("fGammaOpeningAngleReco_One_target", "fGammaOpeningAngleReco_One_target; angle [deg];#", 200, -0.1, 19.9);
1826 fHistoList_One_target.push_back(fGammaOpeningAngleReco_One_target);
1827 fPi0InvMassRecoKF_One_target = new TH1D("fPi0InvMassRecoKF_One_target",
1828 "fPi0InvMassRecoKF_One_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1829 fHistoList_One_target.push_back(fPi0InvMassRecoKF_One_target);
1830 fEMT_InvMass_One_target =
1831 new TH1D("fEMT_InvMass_One_target", "fEMT_InvMass_One_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1832 fHistoList_One_target.push_back(fEMT_InvMass_One_target);
1833 // 1 => One mvd
1834 fGammaInvMassReco_One_mvd =
1835 new TH1D("fGammaInvMassReco_One_mvd", "fGammaInvMassReco_One_mvd; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1836 fHistoList_One_mvd.push_back(fGammaInvMassReco_One_mvd);
1837 fGammaOpeningAngleReco_One_mvd =
1838 new TH1D("fGammaOpeningAngleReco_One_mvd", "fGammaOpeningAngleReco_One_mvd; angle [deg];#", 200, -0.1, 19.9);
1839 fHistoList_One_mvd.push_back(fGammaOpeningAngleReco_One_mvd);
1840 fPi0InvMassRecoKF_One_mvd =
1841 new TH1D("fPi0InvMassRecoKF_One_mvd", "fPi0InvMassRecoKF_One_mvd; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1842 fHistoList_One_mvd.push_back(fPi0InvMassRecoKF_One_mvd);
1843 // 1 => One sts
1844 fGammaInvMassReco_One_sts =
1845 new TH1D("fGammaInvMassReco_One_sts", "fGammaInvMassReco_One_sts; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1846 fHistoList_One_sts.push_back(fGammaInvMassReco_One_sts);
1847 fGammaOpeningAngleReco_One_sts =
1848 new TH1D("fGammaOpeningAngleReco_One_sts", "fGammaOpeningAngleReco_One_sts; angle [deg];#", 200, -0.1, 19.9);
1849 fHistoList_One_sts.push_back(fGammaOpeningAngleReco_One_sts);
1850 fPi0InvMassRecoKF_One_sts =
1851 new TH1D("fPi0InvMassRecoKF_One_sts", "fPi0InvMassRecoKF_One_sts; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1852 fHistoList_One_sts.push_back(fPi0InvMassRecoKF_One_sts);
1853 // 1 => One outside the target (mvd+sts+pipe)
1854 fGammaInvMassReco_One_outside = new TH1D(
1855 "fGammaInvMassReco_One_outside", "fGammaInvMassReco_One_outside; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1856 fHistoList_One_outside.push_back(fGammaInvMassReco_One_outside);
1857 fGammaOpeningAngleReco_One_outside = new TH1D("fGammaOpeningAngleReco_One_outside",
1858 "fGammaOpeningAngleReco_One_outside; angle [deg];#", 200, -0.1, 19.9);
1859 fHistoList_One_outside.push_back(fGammaOpeningAngleReco_One_outside);
1860 fPi0InvMassRecoKF_One_outside = new TH1D(
1861 "fPi0InvMassRecoKF_One_outside", "fPi0InvMassRecoKF_One_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1862 fHistoList_One_outside.push_back(fPi0InvMassRecoKF_One_outside);
1863 fEMT_InvMass_One_outside =
1864 new TH1D("fEMT_InvMass_One_outside", "fEMT_InvMass_One_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1865 fHistoList_One_outside.push_back(fEMT_InvMass_One_outside);
1866
1867
1868 // 2 => Two
1869 fGammaInvMassReco_Two =
1870 new TH1D("fGammaInvMassReco_Two", "fGammaInvMassReco_Two; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1871 fHistoList_Two.push_back(fGammaInvMassReco_Two);
1872 fGammaOpeningAngleReco_Two =
1873 new TH1D("fGammaOpeningAngleReco_Two", "fGammaOpeningAngleReco_Two; angle [deg];#", 200, -0.1, 19.9);
1874 fHistoList_Two.push_back(fGammaOpeningAngleReco_Two);
1875 fPdg_Two = new TH1D("fPdg_Two", "fPdg_Two; Id ;#", 800, 0, 400);
1876 fHistoList_Two.push_back(fPdg_Two);
1877 fP_reco_Two = new TH1D("fP_reco_Two", "fP_reco_Two; P in GeV/c^{2} ;#", 600, 0, 6);
1878 fHistoList_Two.push_back(fP_reco_Two);
1879 fPt_reco_Two = new TH1D("fPt_reco_Two", "fPt_reco_Two; Pt in GeV/c^{2} ;#", 300, 0, 3);
1880 fHistoList_Two.push_back(fPt_reco_Two);
1881 fPi0InvMassRecoKF_Two =
1882 new TH1D("fPi0InvMassRecoKF_Two", "fPi0InvMassRecoKF_Two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1883 fHistoList_Two.push_back(fPi0InvMassRecoKF_Two);
1884 fEMT_InvMass_Two = new TH1D("fEMT_InvMass_Two", "fEMT_InvMass_Two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1885 fHistoList_Two.push_back(fEMT_InvMass_Two);
1886 fPi0_pt_vs_rap_Two =
1887 new TH2D("fPi0_pt_vs_rap_Two", "fPi0_pt_vs_rap_Two; rapidity y; p_{t} in GeV/c ", 90, -2., 7., 60, -1., 5.);
1888 fHistoList_Two.push_back(fPi0_pt_vs_rap_Two);
1889 fPi0_pt_vs_rap_est_Two =
1890 new TH2D("fPi0_pt_vs_rap_est_Two", "fPi0_pt_vs_rap_est_Two; rapidity y; p_{t} in GeV/c ", 10, 0., 4., 10, 0., 4.);
1891 fHistoList_Two.push_back(fPi0_pt_vs_rap_est_Two);
1892 // 2 => Two target
1893 fGammaInvMassReco_Two_target = new TH1D(
1894 "fGammaInvMassReco_Two_target", "fGammaInvMassReco_Two_target; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1895 fHistoList_Two_target.push_back(fGammaInvMassReco_Two_target);
1896 fGammaOpeningAngleReco_Two_target =
1897 new TH1D("fGammaOpeningAngleReco_Two_target", "fGammaOpeningAngleReco_Two_target; angle [deg];#", 200, -0.1, 19.9);
1898 fHistoList_Two_target.push_back(fGammaOpeningAngleReco_Two_target);
1899 fPi0InvMassRecoKF_Two_target = new TH1D("fPi0InvMassRecoKF_Two_target",
1900 "fPi0InvMassRecoKF_Two_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1901 fHistoList_Two_target.push_back(fPi0InvMassRecoKF_Two_target);
1902 fEMT_InvMass_Two_target =
1903 new TH1D("fEMT_InvMass_Two_target", "fEMT_InvMass_Two_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1904 fHistoList_Two_target.push_back(fEMT_InvMass_Two_target);
1905 // 2 => Two mvd
1906 fGammaInvMassReco_Two_mvd =
1907 new TH1D("fGammaInvMassReco_Two_mvd", "fGammaInvMassReco_Two_mvd; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1908 fHistoList_Two_mvd.push_back(fGammaInvMassReco_Two_mvd);
1909 fGammaOpeningAngleReco_Two_mvd =
1910 new TH1D("fGammaOpeningAngleReco_Two_mvd", "fGammaOpeningAngleReco_Two_mvd; angle [deg];#", 200, -0.1, 19.9);
1911 fHistoList_Two_mvd.push_back(fGammaOpeningAngleReco_Two_mvd);
1912 fPi0InvMassRecoKF_Two_mvd =
1913 new TH1D("fPi0InvMassRecoKF_Two_mvd", "fPi0InvMassRecoKF_Two_mvd; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1914 fHistoList_Two_mvd.push_back(fPi0InvMassRecoKF_Two_mvd);
1915 // 2 => Two sts
1916 fGammaInvMassReco_Two_sts =
1917 new TH1D("fGammaInvMassReco_Two_sts", "fGammaInvMassReco_Two_sts; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1918 fHistoList_Two_sts.push_back(fGammaInvMassReco_Two_sts);
1919 fGammaOpeningAngleReco_Two_sts =
1920 new TH1D("fGammaOpeningAngleReco_Two_sts", "fGammaOpeningAngleReco_Two_sts; angle [deg];#", 200, -0.1, 19.9);
1921 fHistoList_Two_sts.push_back(fGammaOpeningAngleReco_Two_sts);
1922 fPi0InvMassRecoKF_Two_sts =
1923 new TH1D("fPi0InvMassRecoKF_Two_sts", "fPi0InvMassRecoKF_Two_sts; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1924 fHistoList_Two_sts.push_back(fPi0InvMassRecoKF_Two_sts);
1925 // 2 => Two outside the target (mvd+sts+pipe)
1926 fGammaInvMassReco_Two_outside = new TH1D(
1927 "fGammaInvMassReco_Two_outside", "fGammaInvMassReco_Two_outside; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1928 fHistoList_Two_outside.push_back(fGammaInvMassReco_Two_outside);
1929 fGammaOpeningAngleReco_Two_outside = new TH1D("fGammaOpeningAngleReco_Two_outside",
1930 "fGammaOpeningAngleReco_Two_outside; angle [deg];#", 200, -0.1, 19.9);
1931 fHistoList_Two_outside.push_back(fGammaOpeningAngleReco_Two_outside);
1932 fPi0InvMassRecoKF_Two_outside = new TH1D(
1933 "fPi0InvMassRecoKF_Two_outside", "fPi0InvMassRecoKF_Two_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1934 fHistoList_Two_outside.push_back(fPi0InvMassRecoKF_Two_outside);
1935 fEMT_InvMass_Two_outside =
1936 new TH1D("fEMT_InvMass_Two_outside", "fEMT_InvMass_Two_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1937 fHistoList_Two_outside.push_back(fEMT_InvMass_Two_outside);
1938
1939
1940 // 1-2 => OneTwo
1941 fGammaInvMassReco_OneTwo =
1942 new TH1D("fGammaInvMassReco_OneTwo", "fGammaInvMassReco_OneTwo; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1943 fHistoList_OneTwo.push_back(fGammaInvMassReco_OneTwo);
1944 fGammaOpeningAngleReco_OneTwo =
1945 new TH1D("fGammaOpeningAngleReco_OneTwo", "fGammaOpeningAngleReco_OneTwo; angle [deg];#", 200, -0.1, 19.9);
1946 fHistoList_OneTwo.push_back(fGammaOpeningAngleReco_OneTwo);
1947 fPdg_OneTwo = new TH1D("fPdg_OneTwo", "fPdg_OneTwo; Id ;#", 800, 0, 400);
1948 fHistoList_OneTwo.push_back(fPdg_OneTwo);
1949 fP_reco_OneTwo = new TH1D("fP_reco_OneTwo", "fP_reco_OneTwo; P in GeV/c^{2} ;#", 600, 0, 6);
1950 fHistoList_OneTwo.push_back(fP_reco_OneTwo);
1951 fPt_reco_OneTwo = new TH1D("fPt_reco_OneTwo", "fPt_reco_OneTwo; Pt in GeV/c^{2} ;#", 300, 0, 3);
1952 fHistoList_OneTwo.push_back(fPt_reco_OneTwo);
1953 fPi0InvMassRecoKF_OneTwo =
1954 new TH1D("fPi0InvMassRecoKF_OneTwo", "fPi0InvMassRecoKF_OneTwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1955 fHistoList_OneTwo.push_back(fPi0InvMassRecoKF_OneTwo);
1956 fEMT_InvMass_OneTwo =
1957 new TH1D("fEMT_InvMass_OneTwo", "fEMT_InvMass_OneTwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1958 fHistoList_OneTwo.push_back(fEMT_InvMass_OneTwo);
1959 fPi0_pt_vs_rap_OneTwo =
1960 new TH2D("fPi0_pt_vs_rap_OneTwo", "fPi0_pt_vs_rap_OneTwo; rapidity y; p_{t} in GeV/c ", 90, -2., 7., 60, -1., 5.);
1961 fHistoList_OneTwo.push_back(fPi0_pt_vs_rap_OneTwo);
1962 fPi0_pt_vs_rap_est_OneTwo = new TH2D(
1963 "fPi0_pt_vs_rap_est_OneTwo", "fPi0_pt_vs_rap_est_OneTwo; rapidity y; p_{t} in GeV/c ", 10, 0., 4., 10, 0., 4.);
1964 fHistoList_OneTwo.push_back(fPi0_pt_vs_rap_est_OneTwo);
1965 // 1-2 => OneTwo target
1966 fGammaInvMassReco_OneTwo_target =
1967 new TH1D("fGammaInvMassReco_OneTwo_target", "fGammaInvMassReco_OneTwo_target; invariant mass in GeV/c^{2};#", 110,
1968 -0.01, 0.1);
1969 fHistoList_OneTwo_target.push_back(fGammaInvMassReco_OneTwo_target);
1970 fGammaOpeningAngleReco_OneTwo_target = new TH1D(
1971 "fGammaOpeningAngleReco_OneTwo_target", "fGammaOpeningAngleReco_OneTwo_target; angle [deg];#", 200, -0.1, 19.9);
1972 fHistoList_OneTwo_target.push_back(fGammaOpeningAngleReco_OneTwo_target);
1973 fPi0InvMassRecoKF_OneTwo_target = new TH1D(
1974 "fPi0InvMassRecoKF_OneTwo_target", "fPi0InvMassRecoKF_OneTwo_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1975 fHistoList_OneTwo_target.push_back(fPi0InvMassRecoKF_OneTwo_target);
1976 fEMT_InvMass_OneTwo_target =
1977 new TH1D("fEMT_InvMass_OneTwo_target", "fEMT_InvMass_OneTwo_target; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1978 fHistoList_OneTwo_target.push_back(fEMT_InvMass_OneTwo_target);
1979 // 1-2 => OneTwo mvd
1980 fGammaInvMassReco_OneTwo_mvd = new TH1D(
1981 "fGammaInvMassReco_OneTwo_mvd", "fGammaInvMassReco_OneTwo_mvd; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1982 fHistoList_OneTwo_mvd.push_back(fGammaInvMassReco_OneTwo_mvd);
1983 fGammaOpeningAngleReco_OneTwo_mvd =
1984 new TH1D("fGammaOpeningAngleReco_OneTwo_mvd", "fGammaOpeningAngleReco_OneTwo_mvd; angle [deg];#", 200, -0.1, 19.9);
1985 fHistoList_OneTwo_mvd.push_back(fGammaOpeningAngleReco_OneTwo_mvd);
1986 fPi0InvMassRecoKF_OneTwo_mvd = new TH1D("fPi0InvMassRecoKF_OneTwo_mvd",
1987 "fPi0InvMassRecoKF_OneTwo_mvd; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1988 fHistoList_OneTwo_mvd.push_back(fPi0InvMassRecoKF_OneTwo_mvd);
1989 // 1-2 => OneTwo sts
1990 fGammaInvMassReco_OneTwo_sts = new TH1D(
1991 "fGammaInvMassReco_OneTwo_sts", "fGammaInvMassReco_OneTwo_sts; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
1992 fHistoList_OneTwo_sts.push_back(fGammaInvMassReco_OneTwo_sts);
1993 fGammaOpeningAngleReco_OneTwo_sts =
1994 new TH1D("fGammaOpeningAngleReco_OneTwo_sts", "fGammaOpeningAngleReco_OneTwo_sts; angle [deg];#", 200, -0.1, 19.9);
1995 fHistoList_OneTwo_sts.push_back(fGammaOpeningAngleReco_OneTwo_sts);
1996 fPi0InvMassRecoKF_OneTwo_sts = new TH1D("fPi0InvMassRecoKF_OneTwo_sts",
1997 "fPi0InvMassRecoKF_OneTwo_sts; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
1998 fHistoList_OneTwo_sts.push_back(fPi0InvMassRecoKF_OneTwo_sts);
1999 // 1-2 => OneTwo outside the target (mvd+sts+pipe)
2000 fGammaInvMassReco_OneTwo_outside =
2001 new TH1D("fGammaInvMassReco_OneTwo_outside", "fGammaInvMassReco_OneTwo_outside; invariant mass in GeV/c^{2};#", 110,
2002 -0.01, 0.1);
2003 fHistoList_OneTwo_outside.push_back(fGammaInvMassReco_OneTwo_outside);
2004 fGammaOpeningAngleReco_OneTwo_outside = new TH1D(
2005 "fGammaOpeningAngleReco_OneTwo_outside", "fGammaOpeningAngleReco_OneTwo_outside; angle [deg];#", 200, -0.1, 19.9);
2006 fHistoList_OneTwo_outside.push_back(fGammaOpeningAngleReco_OneTwo_outside);
2007 fPi0InvMassRecoKF_OneTwo_outside =
2008 new TH1D("fPi0InvMassRecoKF_OneTwo_outside", "fPi0InvMassRecoKF_OneTwo_outside; invariant mass in GeV/c^{2};#",
2009 1000, 0, 2.0);
2010 fHistoList_OneTwo_outside.push_back(fPi0InvMassRecoKF_OneTwo_outside);
2011 fEMT_InvMass_OneTwo_outside =
2012 new TH1D("fEMT_InvMass_OneTwo_outside", "fEMT_InvMass_OneTwo_outside; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2013 fHistoList_OneTwo_outside.push_back(fEMT_InvMass_OneTwo_outside);
2014
2015
2016 // multiplicity plots: How number of gammas change EMT plot and how many gammas we have per event after our cuts
2017 MultiplicityGamma_All =
2018 new TH2D("MultiplicityGamma_All", "MultiplicityGamma_All; Nof gammas in event; invariant mass in GeV/c^{2};#", 400,
2019 0, 30, 1000, 0, 2.0);
2020 fHistoList_multiplicity.push_back(MultiplicityGamma_All);
2021 MultiplicityGamma_Zero = new TH2D("MultiplicityGamma_Zero",
2022 "MultiplicityGamma_Zero; Nof gammas in "
2023 "event; invariant mass in GeV/c^{2};#",
2024 400, 0, 30, 1000, 0, 2.0);
2025 fHistoList_multiplicity.push_back(MultiplicityGamma_Zero);
2026 MultiplicityGamma_One =
2027 new TH2D("MultiplicityGamma_One", "MultiplicityGamma_One; Nof gammas in event; invariant mass in GeV/c^{2};#", 400,
2028 0, 30, 1000, 0, 2.0);
2029 fHistoList_multiplicity.push_back(MultiplicityGamma_One);
2030 MultiplicityGamma_Two =
2031 new TH2D("MultiplicityGamma_Two", "MultiplicityGamma_Two; Nof gammas in event; invariant mass in GeV/c^{2};#", 400,
2032 0, 30, 1000, 0, 2.0);
2033 fHistoList_multiplicity.push_back(MultiplicityGamma_Two);
2034 MultiplicityGamma_OneTwo = new TH2D("MultiplicityGamma_OneTwo",
2035 "MultiplicityGamma_OneTwo; Nof gammas in "
2036 "event; invariant mass in GeV/c^{2};#",
2037 400, 0, 30, 1000, 0, 2.0);
2038 fHistoList_multiplicity.push_back(MultiplicityGamma_OneTwo);
2039
2040 MultiplicityChargedParticles_All = new TH2D("MultiplicityChargedParticles_All",
2041 "MultiplicityChargedParticles_All; Nof charged particles in "
2042 "event; invariant mass in GeV/c^{2};#",
2043 1000, 0, 1000, 1000, 0, 2.0);
2044 fHistoList_multiplicity.push_back(MultiplicityChargedParticles_All);
2045 MultiplicityChargedParticles_Zero = new TH2D("MultiplicityChargedParticles_Zero",
2046 "MultiplicityChargedParticles_Zero; Nof charged particles in "
2047 "event; invariant mass in GeV/c^{2};#",
2048 1000, 0, 1000, 1000, 0, 2.0);
2049 fHistoList_multiplicity.push_back(MultiplicityChargedParticles_Zero);
2050 MultiplicityChargedParticles_One = new TH2D("MultiplicityChargedParticles_One",
2051 "MultiplicityChargedParticles_One; Nof charged particles in "
2052 "event; invariant mass in GeV/c^{2};#",
2053 1000, 0, 1000, 1000, 0, 2.0);
2054 fHistoList_multiplicity.push_back(MultiplicityChargedParticles_One);
2055 MultiplicityChargedParticles_Two = new TH2D("MultiplicityChargedParticles_Two",
2056 "MultiplicityChargedParticles_Two; Nof charged particles in "
2057 "event; invariant mass in GeV/c^{2};#",
2058 1000, 0, 1000, 1000, 0, 2.0);
2059 fHistoList_multiplicity.push_back(MultiplicityChargedParticles_Two);
2060 MultiplicityChargedParticles_OneTwo = new TH2D("MultiplicityChargedParticles_OneTwo",
2061 "MultiplicityChargedParticles_OneTwo; Nof charged particles in "
2062 "event; invariant mass in GeV/c^{2};#",
2063 1000, 0, 1000, 1000, 0, 2.0);
2064 fHistoList_multiplicity.push_back(MultiplicityChargedParticles_OneTwo);
2065
2066
2067 // Multi EMT
2068 EMTMulti_InvMass_All_m1 =
2069 new TH1D("EMTMulti_InvMass_All_m1", "EMTMulti_InvMass_All_m1; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2070 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m1);
2071 EMTMulti_InvMass_All_m2 =
2072 new TH1D("EMTMulti_InvMass_All_m2", "EMTMulti_InvMass_All_m2; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2073 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m2);
2074 EMTMulti_InvMass_All_m3 =
2075 new TH1D("EMTMulti_InvMass_All_m3", "EMTMulti_InvMass_All_m3; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2076 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m3);
2077 EMTMulti_InvMass_All_m4 =
2078 new TH1D("EMTMulti_InvMass_All_m4", "EMTMulti_InvMass_All_m4; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2079 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m4);
2080 EMTMulti_InvMass_All_m5 =
2081 new TH1D("EMTMulti_InvMass_All_m5", "EMTMulti_InvMass_All_m5; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2082 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m5);
2083 EMTMulti_InvMass_All_m6 =
2084 new TH1D("EMTMulti_InvMass_All_m6", "EMTMulti_InvMass_All_m6; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2085 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m6);
2086 EMTMulti_InvMass_All_m7 =
2087 new TH1D("EMTMulti_InvMass_All_m7", "EMTMulti_InvMass_All_m7; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2088 fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m7);
2089
2090 EMTMulti_InvMass_Zero_m1 =
2091 new TH1D("EMTMulti_InvMass_Zero_m1", "EMTMulti_InvMass_Zero_m1; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2092 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m1);
2093 EMTMulti_InvMass_Zero_m2 =
2094 new TH1D("EMTMulti_InvMass_Zero_m2", "EMTMulti_InvMass_Zero_m2; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2095 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m2);
2096 EMTMulti_InvMass_Zero_m3 =
2097 new TH1D("EMTMulti_InvMass_Zero_m3", "EMTMulti_InvMass_Zero_m3; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2098 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m3);
2099 EMTMulti_InvMass_Zero_m4 =
2100 new TH1D("EMTMulti_InvMass_Zero_m4", "EMTMulti_InvMass_Zero_m4; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2101 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m4);
2102 EMTMulti_InvMass_Zero_m5 =
2103 new TH1D("EMTMulti_InvMass_Zero_m5", "EMTMulti_InvMass_Zero_m5; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2104 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m5);
2105 EMTMulti_InvMass_Zero_m6 =
2106 new TH1D("EMTMulti_InvMass_Zero_m6", "EMTMulti_InvMass_Zero_m6; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2107 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m6);
2108 EMTMulti_InvMass_Zero_m7 =
2109 new TH1D("EMTMulti_InvMass_Zero_m7", "EMTMulti_InvMass_Zero_m7; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2110 fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m7);
2111
2112 EMTMulti_InvMass_One_m1 =
2113 new TH1D("EMTMulti_InvMass_One_m1", "EMTMulti_InvMass_One_m1; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2114 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m1);
2115 EMTMulti_InvMass_One_m2 =
2116 new TH1D("EMTMulti_InvMass_One_m2", "EMTMulti_InvMass_One_m2; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2117 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m2);
2118 EMTMulti_InvMass_One_m3 =
2119 new TH1D("EMTMulti_InvMass_One_m3", "EMTMulti_InvMass_One_m3; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2120 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m3);
2121 EMTMulti_InvMass_One_m4 =
2122 new TH1D("EMTMulti_InvMass_One_m4", "EMTMulti_InvMass_One_m4; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2123 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m4);
2124 EMTMulti_InvMass_One_m5 =
2125 new TH1D("EMTMulti_InvMass_One_m5", "EMTMulti_InvMass_One_m5; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2126 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m5);
2127 EMTMulti_InvMass_One_m6 =
2128 new TH1D("EMTMulti_InvMass_One_m6", "EMTMulti_InvMass_One_m6; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2129 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m6);
2130 EMTMulti_InvMass_One_m7 =
2131 new TH1D("EMTMulti_InvMass_One_m7", "EMTMulti_InvMass_One_m7; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2132 fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m7);
2133
2134 EMTMulti_InvMass_Two_m1 =
2135 new TH1D("EMTMulti_InvMass_Two_m1", "EMTMulti_InvMass_Two_m1; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2136 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m1);
2137 EMTMulti_InvMass_Two_m2 =
2138 new TH1D("EMTMulti_InvMass_Two_m2", "EMTMulti_InvMass_Two_m2; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2139 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m2);
2140 EMTMulti_InvMass_Two_m3 =
2141 new TH1D("EMTMulti_InvMass_Two_m3", "EMTMulti_InvMass_Two_m3; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2142 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m3);
2143 EMTMulti_InvMass_Two_m4 =
2144 new TH1D("EMTMulti_InvMass_Two_m4", "EMTMulti_InvMass_Two_m4; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2145 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m4);
2146 EMTMulti_InvMass_Two_m5 =
2147 new TH1D("EMTMulti_InvMass_Two_m5", "EMTMulti_InvMass_Two_m5; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2148 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m5);
2149 EMTMulti_InvMass_Two_m6 =
2150 new TH1D("EMTMulti_InvMass_Two_m6", "EMTMulti_InvMass_Two_m6; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2151 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m6);
2152 EMTMulti_InvMass_Two_m7 =
2153 new TH1D("EMTMulti_InvMass_Two_m7", "EMTMulti_InvMass_Two_m7; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2154 fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m7);
2155
2156 EMTMulti_InvMass_OneTwo_m1 =
2157 new TH1D("EMTMulti_InvMass_OneTwo_m1", "EMTMulti_InvMass_OneTwo_m1; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2158 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m1);
2159 EMTMulti_InvMass_OneTwo_m2 =
2160 new TH1D("EMTMulti_InvMass_OneTwo_m2", "EMTMulti_InvMass_OneTwo_m2; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2161 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m2);
2162 EMTMulti_InvMass_OneTwo_m3 =
2163 new TH1D("EMTMulti_InvMass_OneTwo_m3", "EMTMulti_InvMass_OneTwo_m3; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2164 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m3);
2165 EMTMulti_InvMass_OneTwo_m4 =
2166 new TH1D("EMTMulti_InvMass_OneTwo_m4", "EMTMulti_InvMass_OneTwo_m4; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2167 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m4);
2168 EMTMulti_InvMass_OneTwo_m5 =
2169 new TH1D("EMTMulti_InvMass_OneTwo_m5", "EMTMulti_InvMass_OneTwo_m5; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2170 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m5);
2171 EMTMulti_InvMass_OneTwo_m6 =
2172 new TH1D("EMTMulti_InvMass_OneTwo_m6", "EMTMulti_InvMass_OneTwo_m6; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2173 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m6);
2174 EMTMulti_InvMass_OneTwo_m7 =
2175 new TH1D("EMTMulti_InvMass_OneTwo_m7", "EMTMulti_InvMass_OneTwo_m7; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2176 fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m7);
2177
2178
2179 // BG cases
2180 //Both all
2181 BG1_all = new TH1D("BG1_all", "BG1_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2182 fHistoList_bg_all.push_back(BG1_all);
2183 BG2_all = new TH1D("BG2_all", "BG2_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2184 fHistoList_bg_all.push_back(BG2_all);
2185 BG3_all = new TH1D("BG3_all", "BG3_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2186 fHistoList_bg_all.push_back(BG3_all);
2187 BG4_all = new TH1D("BG4_all", "BG4_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2188 fHistoList_bg_all.push_back(BG4_all);
2189 BG5_all = new TH1D("BG5_all", "BG5_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2190 fHistoList_bg_all.push_back(BG5_all);
2191 BG6_all = new TH1D("BG6_all", "BG6_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2192 fHistoList_bg_all.push_back(BG6_all);
2193 BG7_all = new TH1D("BG7_all", "BG7_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2194 fHistoList_bg_all.push_back(BG7_all);
2195 BG8_all = new TH1D("BG8_all", "BG8_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2196 fHistoList_bg_all.push_back(BG8_all);
2197 BG9_all = new TH1D("BG9_all", "BG9_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2198 fHistoList_bg_all.push_back(BG9_all);
2199 BG10_all = new TH1D("BG10_all", "BG10_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2200 fHistoList_bg_all.push_back(BG10_all);
2201 PdgCase8_all = new TH1D("PdgCase8_all", "PdgCase8_all; Id ;#", 5000, -2500, 2500);
2202 fHistoList_bg_all.push_back(PdgCase8_all);
2203 PdgCase8mothers_all = new TH1D("PdgCase8mothers_all", "PdgCase8mothers_all; Id ;#", 5000, -2500, 2500);
2204 fHistoList_bg_all.push_back(PdgCase8mothers_all);
2205 sameMIDcase8_all = new TH1D("sameMIDcase8_all", "sameMIDcase8_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2206 fHistoList_bg_all.push_back(sameMIDcase8_all);
2207 sameGRIDcase8_all = new TH1D("sameGRIDcase8_all", "sameGRIDcase8_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2208 fHistoList_bg_all.push_back(sameGRIDcase8_all);
2209 Case1ZYPos_all = new TH2D("Case1ZYPos_all", "Case1ZYPos_all; z[cm]; y[cm]", 400, -1, 200, 200, -50, 50);
2210 fHistoList_bg_all.push_back(Case1ZYPos_all);
2211 sameMIDcase8_mothedPDG_all =
2212 new TH1D("sameMIDcase8_mothedPDG_all", "sameMIDcase8_mothedPDG_all; Id ;#", 5000, -2500, 2500);
2213 fHistoList_bg_all.push_back(sameMIDcase8_mothedPDG_all);
2214 PdgCase8NonEComeFromTarget_all =
2215 new TH1D("PdgCase8NonEComeFromTarget_all", "PdgCase8NonEComeFromTarget_all; Id ;#", 5000, -2500, 2500);
2216 fHistoList_bg_all.push_back(PdgCase8NonEComeFromTarget_all);
2217 PdgCase8NonE_NOT_FromTarget_all =
2218 new TH1D("PdgCase8NonE_NOT_FromTarget_all", "PdgCase8NonE_NOT_FromTarget_all; Id ;#", 5000, -2500, 2500);
2219 fHistoList_bg_all.push_back(PdgCase8NonE_NOT_FromTarget_all);
2220 PdgCase8motherNonE_all = new TH1D("PdgCase8motherNonE_all", "PdgCase8motherNonE_all; Id ;#", 5000, -2500, 2500);
2221 fHistoList_bg_all.push_back(PdgCase8motherNonE_all);
2222 Case8ElFromDalitz_all =
2223 new TH1D("Case8ElFromDalitz_all", "Case8ElFromDalitz_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2224 fHistoList_bg_all.push_back(Case8ElFromDalitz_all);
2225 Case8NonElFrom_pn_all =
2226 new TH1D("Case8NonElFrom_pn_all", "Case8NonElFrom_pn_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2227 fHistoList_bg_all.push_back(Case8NonElFrom_pn_all);
2228 Case8NonElFrom_eta_all =
2229 new TH1D("Case8NonElFrom_eta_all", "Case8NonElFrom_eta_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2230 fHistoList_bg_all.push_back(Case8NonElFrom_eta_all);
2231 Case8NonElFrom_kaon_all =
2232 new TH1D("Case8NonElFrom_kaon_all", "Case8NonElFrom_kaon_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2233 fHistoList_bg_all.push_back(Case8NonElFrom_kaon_all);
2234 sameMIDcase8NonEPdg_all = new TH1D("sameMIDcase8NonEPdg_all", "sameMIDcase8NonEPdg_all; Id ;#", 5000, -2500, 2500);
2235 fHistoList_bg_all.push_back(sameMIDcase8NonEPdg_all);
2236 sameMIDcase8NonEMotherPdg_all =
2237 new TH1D("sameMIDcase8NonEMotherPdg_all", "sameMIDcase8NonEMotherPdg_all; Id ;#", 5000, -2500, 2500);
2238 fHistoList_bg_all.push_back(sameMIDcase8NonEMotherPdg_all);
2239 sameMIDcase8NonEMotherIM_all = new TH1D("sameMIDcase8NonEMotherIM_all",
2240 "sameMIDcase8NonEMotherIM_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2241 fHistoList_bg_all.push_back(sameMIDcase8NonEMotherIM_all);
2242 sameMIDcase8NonEPdgFromTarget_all =
2243 new TH1D("sameMIDcase8NonEPdgFromTarget_all", "sameMIDcase8NonEPdgFromTarget_all; Id ;#", 5000, -2500, 2500);
2244 fHistoList_bg_all.push_back(sameMIDcase8NonEPdgFromTarget_all);
2245 sameMIDcase8NonEComeFromTargetIM_all =
2246 new TH1D("sameMIDcase8NonEComeFromTargetIM_all",
2247 "sameMIDcase8NonEComeFromTargetIM_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2248 fHistoList_bg_all.push_back(sameMIDcase8NonEComeFromTargetIM_all);
2249 sameMIDcase8NonEComeFromTargetP_all = new TH1D("sameMIDcase8NonEComeFromTargetP_all",
2250 "sameMIDcase8NonEComeFromTargetP_all; P in GeV/c^{2} ;#", 200, 0, 10);
2251 fHistoList_bg_all.push_back(sameMIDcase8NonEComeFromTargetP_all);
2252 sameMIDcase8NonEComeFromTargetPt_all = new TH1D(
2253 "sameMIDcase8NonEComeFromTargetPt_all", "sameMIDcase8NonEComeFromTargetPt_all; Pt in GeV/c^{2} ;#", 200, 0, 10);
2254 fHistoList_bg_all.push_back(sameMIDcase8NonEComeFromTargetPt_all);
2255 //Both zero
2256 BG1_zero = new TH1D("BG1_zero", "BG1_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2257 fHistoList_bg_zero.push_back(BG1_zero);
2258 BG2_zero = new TH1D("BG2_zero", "BG2_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2259 fHistoList_bg_zero.push_back(BG2_zero);
2260 BG3_zero = new TH1D("BG3_zero", "BG3_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2261 fHistoList_bg_zero.push_back(BG3_zero);
2262 BG4_zero = new TH1D("BG4_zero", "BG4_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2263 fHistoList_bg_zero.push_back(BG4_zero);
2264 BG5_zero = new TH1D("BG5_zero", "BG5_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2265 fHistoList_bg_zero.push_back(BG5_zero);
2266 BG6_zero = new TH1D("BG6_zero", "BG6_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2267 fHistoList_bg_zero.push_back(BG6_zero);
2268 BG7_zero = new TH1D("BG7_zero", "BG7_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2269 fHistoList_bg_zero.push_back(BG7_zero);
2270 BG8_zero = new TH1D("BG8_zero", "BG8_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2271 fHistoList_bg_zero.push_back(BG8_zero);
2272 BG9_zero = new TH1D("BG9_zero", "BG9_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2273 fHistoList_bg_zero.push_back(BG9_zero);
2274 BG10_zero = new TH1D("BG10_zero", "BG10_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2275 fHistoList_bg_zero.push_back(BG10_zero);
2276 PdgCase8_zero = new TH1D("PdgCase8_zero", "PdgCase8_zero; Id ;#", 5000, -2500, 2500);
2277 fHistoList_bg_zero.push_back(PdgCase8_zero);
2278 PdgCase8mothers_zero = new TH1D("PdgCase8mothers_zero", "PdgCase8mothers_zero; Id ;#", 5000, -2500, 2500);
2279 fHistoList_bg_zero.push_back(PdgCase8mothers_zero);
2280 sameMIDcase8_zero = new TH1D("sameMIDcase8_zero", "sameMIDcase8_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2281 fHistoList_bg_zero.push_back(sameMIDcase8_zero);
2282 sameGRIDcase8_zero =
2283 new TH1D("sameGRIDcase8_zero", "sameGRIDcase8_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2284 fHistoList_bg_zero.push_back(sameGRIDcase8_zero);
2285 Case1ZYPos_zero = new TH2D("Case1ZYPos_zero", "Case1ZYPos_zero; z[cm]; y[cm]", 400, -1, 200, 200, -50, 50);
2286 fHistoList_bg_zero.push_back(Case1ZYPos_zero);
2287 sameMIDcase8_mothedPDG_zero =
2288 new TH1D("sameMIDcase8_mothedPDG_zero", "sameMIDcase8_mothedPDG_zero; Id ;#", 5000, -2500, 2500);
2289 fHistoList_bg_zero.push_back(sameMIDcase8_mothedPDG_zero);
2290 PdgCase8NonEComeFromTarget_zero =
2291 new TH1D("PdgCase8NonEComeFromTarget_zero", "PdgCase8NonEComeFromTarget_zero; Id ;#", 5000, -2500, 2500);
2292 fHistoList_bg_zero.push_back(PdgCase8NonEComeFromTarget_zero);
2293 PdgCase8NonE_NOT_FromTarget_zero =
2294 new TH1D("PdgCase8NonE_NOT_FromTarget_zero", "PdgCase8NonE_NOT_FromTarget_zero; Id ;#", 5000, -2500, 2500);
2295 fHistoList_bg_zero.push_back(PdgCase8NonE_NOT_FromTarget_zero);
2296 PdgCase8motherNonE_zero = new TH1D("PdgCase8motherNonE_zero", "PdgCase8motherNonE_zero; Id ;#", 5000, -2500, 2500);
2297 fHistoList_bg_zero.push_back(PdgCase8motherNonE_zero);
2298 Case8ElFromDalitz_zero =
2299 new TH1D("Case8ElFromDalitz_zero", "Case8ElFromDalitz_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2300 fHistoList_bg_zero.push_back(Case8ElFromDalitz_zero);
2301 Case8NonElFrom_pn_zero =
2302 new TH1D("Case8NonElFrom_pn_zero", "Case8NonElFrom_pn_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2303 fHistoList_bg_zero.push_back(Case8NonElFrom_pn_zero);
2304 Case8NonElFrom_eta_zero =
2305 new TH1D("Case8NonElFrom_eta_zero", "Case8NonElFrom_eta_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2306 fHistoList_bg_zero.push_back(Case8NonElFrom_eta_zero);
2307 Case8NonElFrom_kaon_zero =
2308 new TH1D("Case8NonElFrom_kaon_zero", "Case8NonElFrom_kaon_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2309 fHistoList_bg_zero.push_back(Case8NonElFrom_kaon_zero);
2310 sameMIDcase8NonEPdg_zero = new TH1D("sameMIDcase8NonEPdg_zero", "sameMIDcase8NonEPdg_zero; Id ;#", 5000, -2500, 2500);
2311 fHistoList_bg_zero.push_back(sameMIDcase8NonEPdg_zero);
2312 sameMIDcase8NonEMotherPdg_zero =
2313 new TH1D("sameMIDcase8NonEMotherPdg_zero", "sameMIDcase8NonEMotherPdg_zero; Id ;#", 5000, -2500, 2500);
2314 fHistoList_bg_zero.push_back(sameMIDcase8NonEMotherPdg_zero);
2315 sameMIDcase8NonEMotherIM_zero = new TH1D(
2316 "sameMIDcase8NonEMotherIM_zero", "sameMIDcase8NonEMotherIM_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2317 fHistoList_bg_zero.push_back(sameMIDcase8NonEMotherIM_zero);
2318 sameMIDcase8NonEPdgFromTarget_zero =
2319 new TH1D("sameMIDcase8NonEPdgFromTarget_zero", "sameMIDcase8NonEPdgFromTarget_zero; Id ;#", 5000, -2500, 2500);
2320 fHistoList_bg_zero.push_back(sameMIDcase8NonEPdgFromTarget_zero);
2321 sameMIDcase8NonEComeFromTargetIM_zero =
2322 new TH1D("sameMIDcase8NonEComeFromTargetIM_zero",
2323 "sameMIDcase8NonEComeFromTargetIM_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2324 fHistoList_bg_zero.push_back(sameMIDcase8NonEComeFromTargetIM_zero);
2325 sameMIDcase8NonEComeFromTargetP_zero = new TH1D(
2326 "sameMIDcase8NonEComeFromTargetP_zero", "sameMIDcase8NonEComeFromTargetP_zero; P in GeV/c^{2} ;#", 200, 0, 10);
2327 fHistoList_bg_zero.push_back(sameMIDcase8NonEComeFromTargetP_zero);
2328 sameMIDcase8NonEComeFromTargetPt_zero = new TH1D(
2329 "sameMIDcase8NonEComeFromTargetPt_zero", "sameMIDcase8NonEComeFromTargetPt_zero; Pt in GeV/c^{2} ;#", 200, 0, 10);
2330 fHistoList_bg_zero.push_back(sameMIDcase8NonEComeFromTargetPt_zero);
2331 //Both one
2332 BG1_one = new TH1D("BG1_one", "BG1_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2333 fHistoList_bg_one.push_back(BG1_one);
2334 BG2_one = new TH1D("BG2_one", "BG2_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2335 fHistoList_bg_one.push_back(BG2_one);
2336 BG3_one = new TH1D("BG3_one", "BG3_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2337 fHistoList_bg_one.push_back(BG3_one);
2338 BG4_one = new TH1D("BG4_one", "BG4_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2339 fHistoList_bg_one.push_back(BG4_one);
2340 BG5_one = new TH1D("BG5_one", "BG5_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2341 fHistoList_bg_one.push_back(BG5_one);
2342 BG6_one = new TH1D("BG6_one", "BG6_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2343 fHistoList_bg_one.push_back(BG6_one);
2344 BG7_one = new TH1D("BG7_one", "BG7_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2345 fHistoList_bg_one.push_back(BG7_one);
2346 BG8_one = new TH1D("BG8_one", "BG8_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2347 fHistoList_bg_one.push_back(BG8_one);
2348 BG9_one = new TH1D("BG9_one", "BG9_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2349 fHistoList_bg_one.push_back(BG9_one);
2350 BG10_one = new TH1D("BG10_one", "BG10_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2351 fHistoList_bg_one.push_back(BG10_one);
2352 PdgCase8_one = new TH1D("PdgCase8_one", "PdgCase8_one; Id ;#", 5000, -2500, 2500);
2353 fHistoList_bg_one.push_back(PdgCase8_one);
2354 PdgCase8mothers_one = new TH1D("PdgCase8mothers_one", "PdgCase8mothers_one; Id ;#", 5000, -2500, 2500);
2355 fHistoList_bg_one.push_back(PdgCase8mothers_one);
2356 sameMIDcase8_one = new TH1D("sameMIDcase8_one", "sameMIDcase8_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2357 fHistoList_bg_one.push_back(sameMIDcase8_one);
2358 sameGRIDcase8_one = new TH1D("sameGRIDcase8_one", "sameGRIDcase8_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2359 fHistoList_bg_one.push_back(sameGRIDcase8_one);
2360 Case1ZYPos_one = new TH2D("Case1ZYPos_one", "Case1ZYPos_one; z[cm]; y[cm]", 400, -1, 200, 200, -50, 50);
2361 fHistoList_bg_one.push_back(Case1ZYPos_one);
2362 sameMIDcase8_mothedPDG_one =
2363 new TH1D("sameMIDcase8_mothedPDG_one", "sameMIDcase8_mothedPDG_one; Id ;#", 5000, -2500, 2500);
2364 fHistoList_bg_one.push_back(sameMIDcase8_mothedPDG_one);
2365 PdgCase8NonEComeFromTarget_one =
2366 new TH1D("PdgCase8NonEComeFromTarget_one", "PdgCase8NonEComeFromTarget_one; Id ;#", 5000, -2500, 2500);
2367 fHistoList_bg_one.push_back(PdgCase8NonEComeFromTarget_one);
2368 PdgCase8NonE_NOT_FromTarget_one =
2369 new TH1D("PdgCase8NonE_NOT_FromTarget_one", "PdgCase8NonE_NOT_FromTarget_one; Id ;#", 5000, -2500, 2500);
2370 fHistoList_bg_one.push_back(PdgCase8NonE_NOT_FromTarget_one);
2371 PdgCase8motherNonE_one = new TH1D("PdgCase8motherNonE_one", "PdgCase8motherNonE_one; Id ;#", 5000, -2500, 2500);
2372 fHistoList_bg_one.push_back(PdgCase8motherNonE_one);
2373 Case8ElFromDalitz_one =
2374 new TH1D("Case8ElFromDalitz_one", "Case8ElFromDalitz_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2375 fHistoList_bg_one.push_back(Case8ElFromDalitz_one);
2376 Case8NonElFrom_pn_one =
2377 new TH1D("Case8NonElFrom_pn_one", "Case8NonElFrom_pn_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2378 fHistoList_bg_one.push_back(Case8NonElFrom_pn_one);
2379 Case8NonElFrom_eta_one =
2380 new TH1D("Case8NonElFrom_eta_one", "Case8NonElFrom_eta_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2381 fHistoList_bg_one.push_back(Case8NonElFrom_eta_one);
2382 Case8NonElFrom_kaon_one =
2383 new TH1D("Case8NonElFrom_kaon_one", "Case8NonElFrom_kaon_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2384 fHistoList_bg_one.push_back(Case8NonElFrom_kaon_one);
2385 sameMIDcase8NonEPdg_one = new TH1D("sameMIDcase8NonEPdg_one", "sameMIDcase8NonEPdg_one; Id ;#", 5000, -2500, 2500);
2386 fHistoList_bg_one.push_back(sameMIDcase8NonEPdg_one);
2387 sameMIDcase8NonEMotherPdg_one =
2388 new TH1D("sameMIDcase8NonEMotherPdg_one", "sameMIDcase8NonEMotherPdg_one; Id ;#", 5000, -2500, 2500);
2389 fHistoList_bg_one.push_back(sameMIDcase8NonEMotherPdg_one);
2390 sameMIDcase8NonEMotherIM_one = new TH1D("sameMIDcase8NonEMotherIM_one",
2391 "sameMIDcase8NonEMotherIM_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2392 fHistoList_bg_one.push_back(sameMIDcase8NonEMotherIM_one);
2393 sameMIDcase8NonEPdgFromTarget_one =
2394 new TH1D("sameMIDcase8NonEPdgFromTarget_one", "sameMIDcase8NonEPdgFromTarget_one; Id ;#", 5000, -2500, 2500);
2395 fHistoList_bg_one.push_back(sameMIDcase8NonEPdgFromTarget_one);
2396 sameMIDcase8NonEComeFromTargetIM_one =
2397 new TH1D("sameMIDcase8NonEComeFromTargetIM_one",
2398 "sameMIDcase8NonEComeFromTargetIM_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2399 fHistoList_bg_one.push_back(sameMIDcase8NonEComeFromTargetIM_one);
2400 sameMIDcase8NonEComeFromTargetP_one = new TH1D("sameMIDcase8NonEComeFromTargetP_one",
2401 "sameMIDcase8NonEComeFromTargetP_one; P in GeV/c^{2} ;#", 200, 0, 10);
2402 fHistoList_bg_one.push_back(sameMIDcase8NonEComeFromTargetP_one);
2403 sameMIDcase8NonEComeFromTargetPt_one = new TH1D(
2404 "sameMIDcase8NonEComeFromTargetPt_one", "sameMIDcase8NonEComeFromTargetPt_one; Pt in GeV/c^{2} ;#", 200, 0, 10);
2405 fHistoList_bg_one.push_back(sameMIDcase8NonEComeFromTargetPt_one);
2406 //Both two
2407 BG1_two = new TH1D("BG1_two", "BG1_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2408 fHistoList_bg_two.push_back(BG1_two);
2409 BG2_two = new TH1D("BG2_two", "BG2_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2410 fHistoList_bg_two.push_back(BG2_two);
2411 BG3_two = new TH1D("BG3_two", "BG3_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2412 fHistoList_bg_two.push_back(BG3_two);
2413 BG4_two = new TH1D("BG4_two", "BG4_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2414 fHistoList_bg_two.push_back(BG4_two);
2415 BG5_two = new TH1D("BG5_two", "BG5_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2416 fHistoList_bg_two.push_back(BG5_two);
2417 BG6_two = new TH1D("BG6_two", "BG6_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2418 fHistoList_bg_two.push_back(BG6_two);
2419 BG7_two = new TH1D("BG7_two", "BG7_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2420 fHistoList_bg_two.push_back(BG7_two);
2421 BG8_two = new TH1D("BG8_two", "BG8_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2422 fHistoList_bg_two.push_back(BG8_two);
2423 BG9_two = new TH1D("BG9_two", "BG9_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2424 fHistoList_bg_two.push_back(BG9_two);
2425 BG10_two = new TH1D("BG10_two", "BG10_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2426 fHistoList_bg_two.push_back(BG10_two);
2427 PdgCase8_two = new TH1D("PdgCase8_two", "PdgCase8_two; Id ;#", 5000, -2500, 2500);
2428 fHistoList_bg_two.push_back(PdgCase8_two);
2429 PdgCase8mothers_two = new TH1D("PdgCase8mothers_two", "PdgCase8mothers_two; Id ;#", 5000, -2500, 2500);
2430 fHistoList_bg_two.push_back(PdgCase8mothers_two);
2431 sameMIDcase8_two = new TH1D("sameMIDcase8_two", "sameMIDcase8_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2432 fHistoList_bg_two.push_back(sameMIDcase8_two);
2433 sameGRIDcase8_two = new TH1D("sameGRIDcase8_two", "sameGRIDcase8_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2434 fHistoList_bg_two.push_back(sameGRIDcase8_two);
2435 Case1ZYPos_two = new TH2D("Case1ZYPos_two", "Case1ZYPos_two; z[cm]; y[cm]", 400, -1, 200, 200, -50, 50);
2436 fHistoList_bg_two.push_back(Case1ZYPos_two);
2437 sameMIDcase8_mothedPDG_two =
2438 new TH1D("sameMIDcase8_mothedPDG_two", "sameMIDcase8_mothedPDG_two; Id ;#", 5000, -2500, 2500);
2439 fHistoList_bg_two.push_back(sameMIDcase8_mothedPDG_two);
2440 PdgCase8NonEComeFromTarget_two =
2441 new TH1D("PdgCase8NonEComeFromTarget_two", "PdgCase8NonEComeFromTarget_two; Id ;#", 5000, -2500, 2500);
2442 fHistoList_bg_two.push_back(PdgCase8NonEComeFromTarget_two);
2443 PdgCase8NonE_NOT_FromTarget_two =
2444 new TH1D("PdgCase8NonE_NOT_FromTarget_two", "PdgCase8NonE_NOT_FromTarget_two; Id ;#", 5000, -2500, 2500);
2445 fHistoList_bg_two.push_back(PdgCase8NonE_NOT_FromTarget_two);
2446 PdgCase8motherNonE_two = new TH1D("PdgCase8motherNonE_two", "PdgCase8motherNonE_two; Id ;#", 5000, -2500, 2500);
2447 fHistoList_bg_two.push_back(PdgCase8motherNonE_two);
2448 Case8ElFromDalitz_two =
2449 new TH1D("Case8ElFromDalitz_two", "Case8ElFromDalitz_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2450 fHistoList_bg_two.push_back(Case8ElFromDalitz_two);
2451 Case8NonElFrom_pn_two =
2452 new TH1D("Case8NonElFrom_pn_two", "Case8NonElFrom_pn_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2453 fHistoList_bg_two.push_back(Case8NonElFrom_pn_two);
2454 Case8NonElFrom_eta_two =
2455 new TH1D("Case8NonElFrom_eta_two", "Case8NonElFrom_eta_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2456 fHistoList_bg_two.push_back(Case8NonElFrom_eta_two);
2457 Case8NonElFrom_kaon_two =
2458 new TH1D("Case8NonElFrom_kaon_two", "Case8NonElFrom_kaon_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2459 fHistoList_bg_two.push_back(Case8NonElFrom_kaon_two);
2460 sameMIDcase8NonEPdg_two = new TH1D("sameMIDcase8NonEPdg_two", "sameMIDcase8NonEPdg_two; Id ;#", 5000, -2500, 2500);
2461 fHistoList_bg_two.push_back(sameMIDcase8NonEPdg_two);
2462 sameMIDcase8NonEMotherPdg_two =
2463 new TH1D("sameMIDcase8NonEMotherPdg_two", "sameMIDcase8NonEMotherPdg_two; Id ;#", 5000, -2500, 2500);
2464 fHistoList_bg_two.push_back(sameMIDcase8NonEMotherPdg_two);
2465 sameMIDcase8NonEMotherIM_two = new TH1D("sameMIDcase8NonEMotherIM_two",
2466 "sameMIDcase8NonEMotherIM_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2467 fHistoList_bg_two.push_back(sameMIDcase8NonEMotherIM_two);
2468 sameMIDcase8NonEPdgFromTarget_two =
2469 new TH1D("sameMIDcase8NonEPdgFromTarget_two", "sameMIDcase8NonEPdgFromTarget_two; Id ;#", 5000, -2500, 2500);
2470 fHistoList_bg_two.push_back(sameMIDcase8NonEPdgFromTarget_two);
2471 sameMIDcase8NonEComeFromTargetIM_two =
2472 new TH1D("sameMIDcase8NonEComeFromTargetIM_two",
2473 "sameMIDcase8NonEComeFromTargetIM_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2474 fHistoList_bg_two.push_back(sameMIDcase8NonEComeFromTargetIM_two);
2475 sameMIDcase8NonEComeFromTargetP_two = new TH1D("sameMIDcase8NonEComeFromTargetP_two",
2476 "sameMIDcase8NonEComeFromTargetP_two; P in GeV/c^{2} ;#", 200, 0, 10);
2477 fHistoList_bg_two.push_back(sameMIDcase8NonEComeFromTargetP_two);
2478 sameMIDcase8NonEComeFromTargetPt_two = new TH1D(
2479 "sameMIDcase8NonEComeFromTargetPt_two", "sameMIDcase8NonEComeFromTargetPt_two; Pt in GeV/c^{2} ;#", 200, 0, 10);
2480 fHistoList_bg_two.push_back(sameMIDcase8NonEComeFromTargetPt_two);
2481 //Both onetwo
2482 BG1_onetwo = new TH1D("BG1_onetwo", "BG1_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2483 fHistoList_bg_onetwo.push_back(BG1_onetwo);
2484 BG2_onetwo = new TH1D("BG2_onetwo", "BG2_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2485 fHistoList_bg_onetwo.push_back(BG2_onetwo);
2486 BG3_onetwo = new TH1D("BG3_onetwo", "BG3_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2487 fHistoList_bg_onetwo.push_back(BG3_onetwo);
2488 BG4_onetwo = new TH1D("BG4_onetwo", "BG4_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2489 fHistoList_bg_onetwo.push_back(BG4_onetwo);
2490 BG5_onetwo = new TH1D("BG5_onetwo", "BG5_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2491 fHistoList_bg_onetwo.push_back(BG5_onetwo);
2492 BG6_onetwo = new TH1D("BG6_onetwo", "BG6_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2493 fHistoList_bg_onetwo.push_back(BG6_onetwo);
2494 BG7_onetwo = new TH1D("BG7_onetwo", "BG7_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2495 fHistoList_bg_onetwo.push_back(BG7_onetwo);
2496 BG8_onetwo = new TH1D("BG8_onetwo", "BG8_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2497 fHistoList_bg_onetwo.push_back(BG8_onetwo);
2498 BG9_onetwo = new TH1D("BG9_onetwo", "BG9_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2499 fHistoList_bg_onetwo.push_back(BG9_onetwo);
2500 BG10_onetwo = new TH1D("BG10_onetwo", "BG10_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2501 fHistoList_bg_onetwo.push_back(BG10_onetwo);
2502 PdgCase8_onetwo = new TH1D("PdgCase8_onetwo", "PdgCase8_onetwo; Id ;#", 5000, -2500, 2500);
2503 fHistoList_bg_onetwo.push_back(PdgCase8_onetwo);
2504 PdgCase8mothers_onetwo = new TH1D("PdgCase8mothers_onetwo", "PdgCase8mothers_onetwo; Id ;#", 5000, -2500, 2500);
2505 fHistoList_bg_onetwo.push_back(PdgCase8mothers_onetwo);
2506 sameMIDcase8_onetwo =
2507 new TH1D("sameMIDcase8_onetwo", "sameMIDcase8_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2508 fHistoList_bg_onetwo.push_back(sameMIDcase8_onetwo);
2509 sameGRIDcase8_onetwo =
2510 new TH1D("sameGRIDcase8_onetwo", "sameGRIDcase8_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2511 fHistoList_bg_onetwo.push_back(sameGRIDcase8_onetwo);
2512 Case1ZYPos_onetwo = new TH2D("Case1ZYPos_onetwo", "Case1ZYPos_onetwo; z[cm]; y[cm]", 400, -1, 200, 200, -50, 50);
2513 fHistoList_bg_onetwo.push_back(Case1ZYPos_onetwo);
2514 sameMIDcase8_mothedPDG_onetwo =
2515 new TH1D("sameMIDcase8_mothedPDG_onetwo", "sameMIDcase8_mothedPDG_onetwo; Id ;#", 5000, -2500, 2500);
2516 fHistoList_bg_onetwo.push_back(sameMIDcase8_mothedPDG_onetwo);
2517 PdgCase8NonEComeFromTarget_onetwo =
2518 new TH1D("PdgCase8NonEComeFromTarget_onetwo", "PdgCase8NonEComeFromTarget_onetwo; Id ;#", 5000, -2500, 2500);
2519 fHistoList_bg_onetwo.push_back(PdgCase8NonEComeFromTarget_onetwo);
2520 PdgCase8NonE_NOT_FromTarget_onetwo =
2521 new TH1D("PdgCase8NonE_NOT_FromTarget_onetwo", "PdgCase8NonE_NOT_FromTarget_onetwo; Id ;#", 5000, -2500, 2500);
2522 fHistoList_bg_onetwo.push_back(PdgCase8NonE_NOT_FromTarget_onetwo);
2523 PdgCase8motherNonE_onetwo =
2524 new TH1D("PdgCase8motherNonE_onetwo", "PdgCase8motherNonE_onetwo; Id ;#", 5000, -2500, 2500);
2525 fHistoList_bg_onetwo.push_back(PdgCase8motherNonE_onetwo);
2526 Case8ElFromDalitz_onetwo =
2527 new TH1D("Case8ElFromDalitz_onetwo", "Case8ElFromDalitz_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2528 fHistoList_bg_onetwo.push_back(Case8ElFromDalitz_onetwo);
2529 Case8NonElFrom_pn_onetwo =
2530 new TH1D("Case8NonElFrom_pn_onetwo", "Case8NonElFrom_pn_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2531 fHistoList_bg_onetwo.push_back(Case8NonElFrom_pn_onetwo);
2532 Case8NonElFrom_eta_onetwo =
2533 new TH1D("Case8NonElFrom_eta_onetwo", "Case8NonElFrom_eta_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2534 fHistoList_bg_onetwo.push_back(Case8NonElFrom_eta_onetwo);
2535 Case8NonElFrom_kaon_onetwo =
2536 new TH1D("Case8NonElFrom_kaon_onetwo", "Case8NonElFrom_kaon_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2537 fHistoList_bg_onetwo.push_back(Case8NonElFrom_kaon_onetwo);
2538 sameMIDcase8NonEPdg_onetwo =
2539 new TH1D("sameMIDcase8NonEPdg_onetwo", "sameMIDcase8NonEPdg_onetwo; Id ;#", 5000, -2500, 2500);
2540 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEPdg_onetwo);
2541 sameMIDcase8NonEMotherPdg_onetwo =
2542 new TH1D("sameMIDcase8NonEMotherPdg_onetwo", "sameMIDcase8NonEMotherPdg_onetwo; Id ;#", 5000, -2500, 2500);
2543 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEMotherPdg_onetwo);
2544 sameMIDcase8NonEMotherIM_onetwo = new TH1D(
2545 "sameMIDcase8NonEMotherIM_onetwo", "sameMIDcase8NonEMotherIM_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2546 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEMotherIM_onetwo);
2547 sameMIDcase8NonEPdgFromTarget_onetwo =
2548 new TH1D("sameMIDcase8NonEPdgFromTarget_onetwo", "sameMIDcase8NonEPdgFromTarget_onetwo; Id ;#", 5000, -2500, 2500);
2549 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEPdgFromTarget_onetwo);
2550 sameMIDcase8NonEComeFromTargetIM_onetwo =
2551 new TH1D("sameMIDcase8NonEComeFromTargetIM_onetwo",
2552 "sameMIDcase8NonEComeFromTargetIM_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
2553 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEComeFromTargetIM_onetwo);
2554 sameMIDcase8NonEComeFromTargetP_onetwo = new TH1D(
2555 "sameMIDcase8NonEComeFromTargetP_onetwo", "sameMIDcase8NonEComeFromTargetP_onetwo; P in GeV/c^{2} ;#", 200, 0, 10);
2556 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEComeFromTargetP_onetwo);
2557 sameMIDcase8NonEComeFromTargetPt_onetwo =
2558 new TH1D("sameMIDcase8NonEComeFromTargetPt_onetwo", "sameMIDcase8NonEComeFromTargetPt_onetwo; Pt in GeV/c^{2} ;#",
2559 200, 0, 10);
2560 fHistoList_bg_onetwo.push_back(sameMIDcase8NonEComeFromTargetPt_onetwo);
2561}
CbmRichRingFitterEllipseTau.h
Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov.
CbmStsTrack.h
Data class for STS tracks.
CbmGlobalTrack::GetStsTrackIndex
int32_t GetStsTrackIndex() const
Definition CbmGlobalTrack.h:44
CbmGlobalTrack::GetRichRingIndex
int32_t GetRichRingIndex() const
Definition CbmGlobalTrack.h:47
CbmKFParticleFinder::GetTopoReconstructor
const KFParticleTopoReconstructor * GetTopoReconstructor() const
Definition CbmKFParticleFinder.h:47
CbmKresConversionBG::Exec
void Exec(CbmMCTrack *mctrack1, CbmMCTrack *mctrack2, CbmMCTrack *mctrack3, CbmMCTrack *mctrack4, Double_t invmassRecoPi0, vector< TH1 * > BGCases)
Definition CbmKresConversionBG.cxx:38
CbmKresConversionKF::EMT_Z
std::vector< Double_t > EMT_Z
Definition CbmKresConversionKF.h:107
CbmKresConversionKF::fHistoList_All_outside
vector< TH1 * > fHistoList_All_outside
Definition CbmKresConversionKF.h:182
CbmKresConversionKF::fHistoList_Two_outside
vector< TH1 * > fHistoList_Two_outside
Definition CbmKresConversionKF.h:285
CbmKresConversionKF::EMT_Event_multi_two
std::vector< int > EMT_Event_multi_two
Definition CbmKresConversionKF.h:116
CbmKresConversionKF::fHistoList_One_mvd
vector< TH1 * > fHistoList_One_mvd
Definition CbmKresConversionKF.h:240
CbmKresConversionKF::EMT_Event_multi_one
std::vector< int > EMT_Event_multi_one
Definition CbmKresConversionKF.h:113
CbmKresConversionKF::GammasZero
std::vector< std::vector< TVector3 > > GammasZero
Definition CbmKresConversionKF.h:77
CbmKresConversionKF::fHistoList_multiplicity_All
vector< TH1 * > fHistoList_multiplicity_All
Definition CbmKresConversionKF.h:342
CbmKresConversionKF::EMT_pair_momenta_multi_zero
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_zero
Definition CbmKresConversionKF.h:120
CbmKresConversionKF::EMT_pair_momenta_multi_all
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_all
Definition CbmKresConversionKF.h:111
CbmKresConversionKF::EMT_Event
std::vector< int > EMT_Event
Definition CbmKresConversionKF.h:104
CbmKresConversionKF::fRichProjections
TClonesArray * fRichProjections
Definition CbmKresConversionKF.h:71
CbmKresConversionKF::GammasOneTwoStsIndex
std::vector< std::vector< int > > GammasOneTwoStsIndex
Definition CbmKresConversionKF.h:87
CbmKresConversionKF::CheckForCuts_z_vs_OA_Reco_from_one_pi0
TH2D * CheckForCuts_z_vs_OA_Reco_from_one_pi0
Definition CbmKresConversionKF.h:146
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm
TH1D * CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm
Definition CbmKresConversionKF.h:150
CbmKresConversionKF::GammasAllStsIndex
std::vector< std::vector< int > > GammasAllStsIndex
Definition CbmKresConversionKF.h:83
CbmKresConversionKF::GammasAll
std::vector< std::vector< TVector3 > > GammasAll
Definition CbmKresConversionKF.h:76
CbmKresConversionKF::fHistoList_multiplicity_One
vector< TH1 * > fHistoList_multiplicity_One
Definition CbmKresConversionKF.h:343
CbmKresConversionKF::GammasOne
std::vector< std::vector< TVector3 > > GammasOne
Definition CbmKresConversionKF.h:78
CbmKresConversionKF::GammasZeroZ
std::vector< Double_t > GammasZeroZ
Definition CbmKresConversionKF.h:97
CbmKresConversionKF::fHistoList_OneTwo_mvd
vector< TH1 * > fHistoList_OneTwo_mvd
Definition CbmKresConversionKF.h:309
CbmKresConversionKF::fRichRingMatches
TClonesArray * fRichRingMatches
Definition CbmKresConversionKF.h:70
CbmKresConversionKF::SetKF
void SetKF(CbmKFParticleFinder *kfparticle, CbmKFParticleFinderQa *kfparticleQA)
Definition CbmKresConversionKF.cxx:473
CbmKresConversionKF::GammasTwoMC
std::vector< std::vector< CbmMCTrack * > > GammasTwoMC
Definition CbmKresConversionKF.h:93
CbmKresConversionKF::fGlobalTracks
TClonesArray * fGlobalTracks
Definition CbmKresConversionKF.h:69
CbmKresConversionKF::fHistoList_One_sts
vector< TH1 * > fHistoList_One_sts
Definition CbmKresConversionKF.h:245
CbmKresConversionKF::fHistoList_Two_sts
vector< TH1 * > fHistoList_Two_sts
Definition CbmKresConversionKF.h:280
CbmKresConversionKF::fHistoList_multiplicity_Two
vector< TH1 * > fHistoList_multiplicity_Two
Definition CbmKresConversionKF.h:344
CbmKresConversionKF::fHistoList_Zero_mvd
vector< TH1 * > fHistoList_Zero_mvd
Definition CbmKresConversionKF.h:206
CbmKresConversionKF::fHistoList_All
vector< TH1 * > fHistoList_All
Definition CbmKresConversionKF.h:155
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0
Definition CbmKresConversionKF.h:140
CbmKresConversionKF::fHistoList_bg_two
vector< TH1 * > fHistoList_bg_two
Definition CbmKresConversionKF.h:486
CbmKresConversionKF::EMT_multi_onetwo
std::vector< int > EMT_multi_onetwo
Definition CbmKresConversionKF.h:129
CbmKresConversionKF::fHistoList_OneTwo_outside
vector< TH1 * > fHistoList_OneTwo_outside
Definition CbmKresConversionKF.h:319
CbmKresConversionKF::GammasAllZ
std::vector< Double_t > GammasAllZ
Definition CbmKresConversionKF.h:96
CbmKresConversionKF::fHistoList_Zero
vector< TH1 * > fHistoList_Zero
Definition CbmKresConversionKF.h:189
CbmKresConversionKF::fHistoList_OneTwo
vector< TH1 * > fHistoList_OneTwo
Definition CbmKresConversionKF.h:292
CbmKresConversionKF::EMT_Event_multi_onetwo
std::vector< int > EMT_Event_multi_onetwo
Definition CbmKresConversionKF.h:122
CbmKresConversionKF::EMT_multi_one
std::vector< int > EMT_multi_one
Definition CbmKresConversionKF.h:126
CbmKresConversionKF::fStsInd
std::vector< int > fStsInd
Definition CbmKresConversionKF.h:82
CbmKresConversionKF::GammasTwo
std::vector< std::vector< TVector3 > > GammasTwo
Definition CbmKresConversionKF.h:79
CbmKresConversionKF::CheckForCuts_z_vs_InvMass_MC_from_one_pi0
TH2D * CheckForCuts_z_vs_InvMass_MC_from_one_pi0
Definition CbmKresConversionKF.h:143
CbmKresConversionKF::fHistoList_bg_one
vector< TH1 * > fHistoList_bg_one
Definition CbmKresConversionKF.h:454
CbmKresConversionKF::fHistoList_Two_target
vector< TH1 * > fHistoList_Two_target
Definition CbmKresConversionKF.h:269
CbmKresConversionKF::GammasOneStsIndex
std::vector< std::vector< int > > GammasOneStsIndex
Definition CbmKresConversionKF.h:85
CbmKresConversionKF::fHistoList_OneTwo_sts
vector< TH1 * > fHistoList_OneTwo_sts
Definition CbmKresConversionKF.h:314
CbmKresConversionKF::CheckIfElectron
int CheckIfElectron(CbmRichRing *ring, double momentum)
Definition CbmKresConversionKF.cxx:1130
CbmKresConversionKF::fHistoList_Zero_outside
vector< TH1 * > fHistoList_Zero_outside
Definition CbmKresConversionKF.h:216
CbmKresConversionKF::EMT_multi_two
std::vector< int > EMT_multi_two
Definition CbmKresConversionKF.h:127
CbmKresConversionKF::EMT_NofRings
std::vector< int > EMT_NofRings
Definition CbmKresConversionKF.h:106
CbmKresConversionKF::EMT_pair_momenta_multi_one
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_one
Definition CbmKresConversionKF.h:114
CbmKresConversionKF::fHistoList_All_target
vector< TH1 * > fHistoList_All_target
Definition CbmKresConversionKF.h:166
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0_less4cm
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0_less4cm
Definition CbmKresConversionKF.h:147
CbmKresConversionKF::fHistoList_Zero_sts
vector< TH1 * > fHistoList_Zero_sts
Definition CbmKresConversionKF.h:211
CbmKresConversionKF::fKFparticleFinderQA
CbmKFParticleFinderQa * fKFparticleFinderQA
Definition CbmKresConversionKF.h:59
CbmKresConversionKF::fmcvector
std::vector< CbmMCTrack * > fmcvector
Definition CbmKresConversionKF.h:89
CbmKresConversionKF::fHistoList_multiplicity_Zero
vector< TH1 * > fHistoList_multiplicity_Zero
Definition CbmKresConversionKF.h:345
CbmKresConversionKF::GammasOneMC
std::vector< std::vector< CbmMCTrack * > > GammasOneMC
Definition CbmKresConversionKF.h:92
CbmKresConversionKF::EMT_multi_all
std::vector< int > EMT_multi_all
Definition CbmKresConversionKF.h:125
CbmKresConversionKF::fHistoList_bg_onetwo
vector< TH1 * > fHistoList_bg_onetwo
Definition CbmKresConversionKF.h:518
CbmKresConversionKF::fHistoList_bg_all
vector< TH1 * > fHistoList_bg_all
Definition CbmKresConversionKF.h:390
CbmKresConversionKF::EMT_pair_momenta
std::vector< std::vector< TVector3 > > EMT_pair_momenta
Definition CbmKresConversionKF.h:105
CbmKresConversionKF::fHistoList_One_outside
vector< TH1 * > fHistoList_One_outside
Definition CbmKresConversionKF.h:250
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0_more21cm
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0_more21cm
Definition CbmKresConversionKF.h:151
CbmKresConversionKF::fTauFit
CbmRichRingFitterEllipseTau * fTauFit
Definition CbmKresConversionKF.h:62
CbmKresConversionKF::fAnaBG
CbmKresConversionBG * fAnaBG
Definition CbmKresConversionKF.h:64
CbmKresConversionKF::EMT_multi_zero
std::vector< int > EMT_multi_zero
Definition CbmKresConversionKF.h:128
CbmKresConversionKF::GammasZeroStsIndex
std::vector< std::vector< int > > GammasZeroStsIndex
Definition CbmKresConversionKF.h:84
CbmKresConversionKF::GammasAllMC
std::vector< std::vector< CbmMCTrack * > > GammasAllMC
Definition CbmKresConversionKF.h:90
CbmKresConversionKF::EMT_Event_multi_all
std::vector< int > EMT_Event_multi_all
Definition CbmKresConversionKF.h:110
CbmKresConversionKF::fHistoList_All_mvd
vector< TH1 * > fHistoList_All_mvd
Definition CbmKresConversionKF.h:172
CbmKresConversionKF::fStsTrackMatches
TClonesArray * fStsTrackMatches
Definition CbmKresConversionKF.h:68
CbmKresConversionKF::GammasTwoStsIndex
std::vector< std::vector< int > > GammasTwoStsIndex
Definition CbmKresConversionKF.h:86
CbmKresConversionKF::FindGammas
void FindGammas(vector< KFParticle > allgammas, vector< KFParticle > particlevector, int Event, double AngleCut, double InvMassCut, int RealPID)
Definition CbmKresConversionKF.cxx:633
CbmKresConversionKF::GammasOneTwo
std::vector< std::vector< TVector3 > > GammasOneTwo
Definition CbmKresConversionKF.h:80
CbmKresConversionKF::GammasOneTwoZ
std::vector< Double_t > GammasOneTwoZ
Definition CbmKresConversionKF.h:100
CbmKresConversionKF::EMT_pair_momenta_multi_two
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_two
Definition CbmKresConversionKF.h:117
CbmKresConversionKF::FindPi0
void FindPi0(TString mod, vector< vector< TVector3 > > Gammas, vector< vector< int > > StsIndex, vector< vector< CbmMCTrack * > > GammasMC, vector< Double_t > GammasZ, TH1D *Pi0InvMassRecoKF, TH2D *Pi0_pt_vs_rap, TH2D *Pi0_pt_vs_rap_est, TH1D *Pi0InvMassRecoKF_target, TH1D *Pi0InvMassRecoKF_mvd, TH1D *Pi0InvMassRecoKF_sts, TH1D *Pi0InvMassRecoKF_outside, TH2D *MultiplicityGamma, TH2D *MultiplicityChargedParticles, vector< TH1 * > BGCases)
Definition CbmKresConversionKF.cxx:1026
CbmKresConversionKF::fHistoList_bg_zero
vector< TH1 * > fHistoList_bg_zero
Definition CbmKresConversionKF.h:422
CbmKresConversionKF::fHistoList_CheckForCuts
vector< TH1 * > fHistoList_CheckForCuts
Definition CbmKresConversionKF.h:133
CbmKresConversionKF::fKFparticle
CbmKFParticleFinder * fKFparticle
Definition CbmKresConversionKF.h:58
CbmKresConversionKF::fHistoList_multiplicity
vector< TH1 * > fHistoList_multiplicity
Definition CbmKresConversionKF.h:327
CbmKresConversionKF::CheckForCuts_z_vs_InvMass_Reco_from_one_pi0
TH2D * CheckForCuts_z_vs_InvMass_Reco_from_one_pi0
Definition CbmKresConversionKF.h:144
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetIM_onetwo
TH1D * sameMIDcase8NonEComeFromTargetIM_onetwo
Definition CbmKresConversionKF.h:546
CbmKresConversionKF::fHistoList_Zero_target
vector< TH1 * > fHistoList_Zero_target
Definition CbmKresConversionKF.h:200
CbmKresConversionKF::fHistoList_Two_mvd
vector< TH1 * > fHistoList_Two_mvd
Definition CbmKresConversionKF.h:275
CbmKresConversionKF::GammasZeroMC
std::vector< std::vector< CbmMCTrack * > > GammasZeroMC
Definition CbmKresConversionKF.h:91
CbmKresConversionKF::fHistoList_All_sts
vector< TH1 * > fHistoList_All_sts
Definition CbmKresConversionKF.h:177
CbmKresConversionKF::fKFtopo
const KFParticleTopoReconstructor * fKFtopo
Definition CbmKresConversionKF.h:60
CbmKresConversionKF::EMT_pair_momenta_multi_onetwo
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_onetwo
Definition CbmKresConversionKF.h:123
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetPt_onetwo
TH1D * sameMIDcase8NonEComeFromTargetPt_onetwo
Definition CbmKresConversionKF.h:548
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetP_onetwo
TH1D * sameMIDcase8NonEComeFromTargetP_onetwo
Definition CbmKresConversionKF.h:547
CbmKresConversionKF::GammasOneTwoMC
std::vector< std::vector< CbmMCTrack * > > GammasOneTwoMC
Definition CbmKresConversionKF.h:94
CbmKresConversionKF::GammasTwoZ
std::vector< Double_t > GammasTwoZ
Definition CbmKresConversionKF.h:99
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0_less4cm
TH1D * CheckForCuts_OA_Reco_from_one_pi0_less4cm
Definition CbmKresConversionKF.h:148
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm
Definition CbmKresConversionKF.h:149
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0_more21cm
TH1D * CheckForCuts_OA_Reco_from_one_pi0_more21cm
Definition CbmKresConversionKF.h:152
CbmKresConversionKF::frefmomentum
std::vector< TVector3 > frefmomentum
Definition CbmKresConversionKF.h:75
CbmKresConversionKF::fHistoList_Two
vector< TH1 * > fHistoList_Two
Definition CbmKresConversionKF.h:258
CbmKresConversionKF::Exec
void Exec(int fEventNumKF, double OpeningAngleCut, double GammaInvMassCut, int RealPID)
Definition CbmKresConversionKF.cxx:523
CbmKresConversionKF::fHistoList_multiplicity_OneTwo
vector< TH1 * > fHistoList_multiplicity_OneTwo
Definition CbmKresConversionKF.h:346
CbmKresConversionKF::EMT_Event_multi_zero
std::vector< int > EMT_Event_multi_zero
Definition CbmKresConversionKF.h:119
CbmKresConversionKF::fHistoList_One_target
vector< TH1 * > fHistoList_One_target
Definition CbmKresConversionKF.h:234
CbmKresConversionKF::GammasOneZ
std::vector< Double_t > GammasOneZ
Definition CbmKresConversionKF.h:98
CbmKresConversionKF::fHistoList_OneTwo_target
vector< TH1 * > fHistoList_OneTwo_target
Definition CbmKresConversionKF.h:303
CbmKresConversionKF::fHistoList_One
vector< TH1 * > fHistoList_One
Definition CbmKresConversionKF.h:223
CbmKresFunctions::CalculateOpeningAngle_Reco
static Double_t CalculateOpeningAngle_Reco(TVector3 electron1, TVector3 electron2)
Definition CbmKresFunctions.h:247
CbmKresFunctions::Invmass_2particles_MC
static double Invmass_2particles_MC(const CbmMCTrack *mctrack1, const CbmMCTrack *mctrack2)
Definition CbmKresFunctions.h:95
CbmKresFunctions::CalculateOpeningAngle_MC
static Double_t CalculateOpeningAngle_MC(CbmMCTrack *mctrack1, CbmMCTrack *mctrack2)
Definition CbmKresFunctions.h:263
CbmKresFunctions::CalculateKinematicParams_4particles
static LmvmKinePar CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2, const TVector3 part3, const TVector3 part4)
Definition CbmKresFunctions.h:210
CbmKresFunctions::Invmass_2particles_RECO
static double Invmass_2particles_RECO(const TVector3 part1, const TVector3 part2)
Definition CbmKresFunctions.h:110
CbmKresFunctions::FitToVertex
static TVector3 FitToVertex(CbmStsTrack *stsTrack, double x, double y, double z)
Definition CbmKresFunctions.h:34
CbmMCTrack::GetStartZ
double GetStartZ() const
Definition CbmMCTrack.h:75
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
CbmPixelHit::GetY
double GetY() const
Definition CbmPixelHit.h:74
CbmPixelHit::GetX
double GetX() const
Definition CbmPixelHit.h:73
CbmRichRingFitterEllipseTau
Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov.
Definition CbmRichRingFitterEllipseTau.h:39
CbmRichRingFitterEllipseTau::DoFit
virtual void DoFit(CbmRichRingLight *ring)
Inherited from CbmRichRingFitterBase.
Definition CbmRichRingFitterEllipseTau.cxx:98
CbmRichRingLight::GetAaxis
float GetAaxis() const
Definition CbmRichRingLight.h:169
CbmRichRingLight::GetBaxis
float GetBaxis() const
Definition CbmRichRingLight.h:170
CbmRichRingLight::AddHit
void AddHit(CbmRichHitLight hit)
Add new hit to the ring.
Definition CbmRichRingLight.h:90
CbmRichRing::GetHit
uint32_t GetHit(int32_t i) const
Definition CbmRichRing.h:39
CbmRichRing::GetNofHits
int32_t GetNofHits() const
Definition CbmRichRing.h:37
LmvmKinePar::fMinv
Double_t fMinv
Definition LmvmKinePar.h:22
LmvmKinePar::fPt
Double_t fPt
Definition LmvmKinePar.h:20
LmvmKinePar::fRapidity
Double_t fRapidity
Definition LmvmKinePar.h:21
std
Hash for CbmL1LinkKey.
Definition algo/base/Options.cxx:21