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