CbmRoot
CbmKresConversionKF.cxx
Go to the documentation of this file.
1 
18 #include "CbmKresConversionKF.h"
19 #include "CbmKresConversionBG.h"
20 #include "CbmKresFunctions.h"
21 
22 #include "CbmKFParticleFinder.h"
23 #include "CbmKFParticleFinderQA.h"
24 
25 #include "KFParticle.h"
26 #include "KFParticleTopoReconstructor.h"
27 
28 #include "CbmRichRingFitterEllipseTau.h"
29 
30 #include "CbmGlobalTrack.h"
31 #include "CbmLmvmKinematicParams.h"
32 #include "CbmMCTrack.h"
33 #include "CbmRichHit.h"
34 #include "CbmRichRing.h"
35 #include "CbmRichRingLight.h"
36 #include "CbmStsTrack.h"
37 #include "CbmTrackMatchNew.h"
38 
39 
40 using namespace std;
41 
42 CbmKresConversionKF::CbmKresConversionKF()
43  : fKFparticle(nullptr)
44  , fKFparticleFinderQA(nullptr)
45  , fKFtopo(nullptr)
46  , fTauFit(nullptr)
47  , fAnaBG(nullptr)
48  , fMcTracks(nullptr)
49  , fStsTracks(nullptr)
50  , fStsTrackMatches(nullptr)
51  , fGlobalTracks(nullptr)
52  , fRichRingMatches(nullptr)
53  , fRichProjections(nullptr)
54  , fRichRings(nullptr)
55  , fRichHits(nullptr)
56  , frefmomentum()
57  , GammasAll()
58  , GammasZero()
59  , GammasOne()
60  , GammasTwo()
61  , GammasOneTwo()
62  , fStsInd()
63  , GammasAllStsIndex()
64  , GammasZeroStsIndex()
65  , GammasOneStsIndex()
66  , GammasTwoStsIndex()
67  , GammasOneTwoStsIndex()
68  , fmcvector()
69  , GammasAllMC()
70  , GammasZeroMC()
71  , GammasOneMC()
72  , GammasTwoMC()
73  , GammasOneTwoMC()
74  , GammasAllZ()
75  , GammasZeroZ()
76  , GammasOneZ()
77  , GammasTwoZ()
78  , GammasOneTwoZ()
79  , EMT_Event()
80  , EMT_pair_momenta()
81  , EMT_NofRings()
82  , EMT_Z()
83  , EMT_Event_multi_all()
84  , EMT_pair_momenta_multi_all()
85  , EMT_Event_multi_one()
86  , EMT_pair_momenta_multi_one()
87  , EMT_Event_multi_two()
88  , EMT_pair_momenta_multi_two()
89  , EMT_Event_multi_zero()
90  , EMT_pair_momenta_multi_zero()
91  , EMT_Event_multi_onetwo()
92  , EMT_pair_momenta_multi_onetwo()
93  , EMT_multi_all()
94  , EMT_multi_one()
95  , EMT_multi_two()
96  , EMT_multi_zero()
97  , EMT_multi_onetwo()
98  , fHistoList_CheckForCuts()
99  , CheckForCuts_InvMass_MC(nullptr)
100  , CheckForCuts_InvMass_Reco(nullptr)
101  , CheckForCuts_OA_MC(nullptr)
102  , CheckForCuts_OA_Reco(nullptr)
103  , CheckForCuts_InvMass_MC_from_one_pi0(nullptr)
104  , CheckForCuts_InvMass_Reco_from_one_pi0(nullptr)
105  , CheckForCuts_OA_MC_from_one_pi0(nullptr)
106  , CheckForCuts_OA_Reco_from_one_pi0(nullptr)
107  , CheckForCuts_z_vs_InvMass_MC_from_one_pi0(nullptr)
108  , CheckForCuts_z_vs_InvMass_Reco_from_one_pi0(nullptr)
109  , CheckForCuts_z_vs_OA_MC_from_one_pi0(nullptr)
110  , CheckForCuts_z_vs_OA_Reco_from_one_pi0(nullptr)
111  , CheckForCuts_InvMass_Reco_from_one_pi0_less4cm(nullptr)
112  , CheckForCuts_OA_Reco_from_one_pi0_less4cm(nullptr)
113  , CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm(nullptr)
114  , CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm(nullptr)
115  , CheckForCuts_InvMass_Reco_from_one_pi0_more21cm(nullptr)
116  , CheckForCuts_OA_Reco_from_one_pi0_more21cm(nullptr)
117  , fHistoList_All()
118  , fGammaInvMassReco_All(nullptr)
119  , fGammaOpeningAngleReco_All(nullptr)
120  , fPdg_All(nullptr)
121  , fP_reco_All(nullptr)
122  , fPt_reco_All(nullptr)
123  , fPi0InvMassRecoKF_All(nullptr)
124  , fEMT_InvMass_All(nullptr)
125  , fPi0_pt_vs_rap_All(nullptr)
126  , fPi0_pt_vs_rap_est_All(nullptr)
127  , fHistoList_All_target()
128  , fGammaInvMassReco_All_target(nullptr)
129  , fGammaOpeningAngleReco_All_target(nullptr)
130  , fPi0InvMassRecoKF_All_target(nullptr)
131  , fEMT_InvMass_All_target(nullptr)
132  , fHistoList_All_mvd()
133  , fGammaInvMassReco_All_mvd(nullptr)
134  , fGammaOpeningAngleReco_All_mvd(nullptr)
135  , fPi0InvMassRecoKF_All_mvd(nullptr)
136  , fHistoList_All_sts()
137  , fGammaInvMassReco_All_sts(nullptr)
138  , fGammaOpeningAngleReco_All_sts(nullptr)
139  , fPi0InvMassRecoKF_All_sts(nullptr)
140  , fHistoList_All_outside()
141  , fGammaInvMassReco_All_outside(nullptr)
142  , fGammaOpeningAngleReco_All_outside(nullptr)
143  , fPi0InvMassRecoKF_All_outside(nullptr)
144  , fEMT_InvMass_All_outside(nullptr)
145  , fHistoList_Zero()
146  , fGammaInvMassReco_Zero(nullptr)
147  , fGammaOpeningAngleReco_Zero(nullptr)
148  , fPdg_Zero(nullptr)
149  , fP_reco_Zero(nullptr)
150  , fPt_reco_Zero(nullptr)
151  , fPi0InvMassRecoKF_Zero(nullptr)
152  , fEMT_InvMass_Zero(nullptr)
153  , fPi0_pt_vs_rap_Zero(nullptr)
154  , fPi0_pt_vs_rap_est_Zero(nullptr)
155  , fHistoList_Zero_target()
156  , fGammaInvMassReco_Zero_target(nullptr)
157  , fGammaOpeningAngleReco_Zero_target(nullptr)
158  , fPi0InvMassRecoKF_Zero_target(nullptr)
159  , fEMT_InvMass_Zero_target(nullptr)
160  , fHistoList_Zero_mvd()
161  , fGammaInvMassReco_Zero_mvd(nullptr)
162  , fGammaOpeningAngleReco_Zero_mvd(nullptr)
163  , fPi0InvMassRecoKF_Zero_mvd(nullptr)
164  , fHistoList_Zero_sts()
165  , fGammaInvMassReco_Zero_sts(nullptr)
166  , fGammaOpeningAngleReco_Zero_sts(nullptr)
167  , fPi0InvMassRecoKF_Zero_sts(nullptr)
168  , fHistoList_Zero_outside()
169  , fGammaInvMassReco_Zero_outside(nullptr)
170  , fGammaOpeningAngleReco_Zero_outside(nullptr)
171  , fPi0InvMassRecoKF_Zero_outside(nullptr)
172  , fEMT_InvMass_Zero_outside(nullptr)
173  , fHistoList_One()
174  , fGammaInvMassReco_One(nullptr)
175  , fGammaOpeningAngleReco_One(nullptr)
176  , fPdg_One(nullptr)
177  , fP_reco_One(nullptr)
178  , fPt_reco_One(nullptr)
179  , fPi0InvMassRecoKF_One(nullptr)
180  , fEMT_InvMass_One(nullptr)
181  , fPi0_pt_vs_rap_One(nullptr)
182  , fPi0_pt_vs_rap_est_One(nullptr)
183  , fHistoList_One_target()
184  , fGammaInvMassReco_One_target(nullptr)
185  , fGammaOpeningAngleReco_One_target(nullptr)
186  , fPi0InvMassRecoKF_One_target(nullptr)
187  , fEMT_InvMass_One_target(nullptr)
188  , fHistoList_One_mvd()
189  , fGammaInvMassReco_One_mvd(nullptr)
190  , fGammaOpeningAngleReco_One_mvd(nullptr)
191  , fPi0InvMassRecoKF_One_mvd(nullptr)
192  , fHistoList_One_sts()
193  , fGammaInvMassReco_One_sts(nullptr)
194  , fGammaOpeningAngleReco_One_sts(nullptr)
195  , fPi0InvMassRecoKF_One_sts(nullptr)
196  , fHistoList_One_outside()
197  , fGammaInvMassReco_One_outside(nullptr)
198  , fGammaOpeningAngleReco_One_outside(nullptr)
199  , fPi0InvMassRecoKF_One_outside(nullptr)
200  , fEMT_InvMass_One_outside(nullptr)
201  , fHistoList_Two()
202  , fGammaInvMassReco_Two(nullptr)
203  , fGammaOpeningAngleReco_Two(nullptr)
204  , fPdg_Two(nullptr)
205  , fP_reco_Two(nullptr)
206  , fPt_reco_Two(nullptr)
207  , fPi0InvMassRecoKF_Two(nullptr)
208  , fEMT_InvMass_Two(nullptr)
209  , fPi0_pt_vs_rap_Two(nullptr)
210  , fPi0_pt_vs_rap_est_Two(nullptr)
211  , fHistoList_Two_target()
212  , fGammaInvMassReco_Two_target(nullptr)
213  , fGammaOpeningAngleReco_Two_target(nullptr)
214  , fPi0InvMassRecoKF_Two_target(nullptr)
215  , fEMT_InvMass_Two_target(nullptr)
216  , fHistoList_Two_mvd()
217  , fGammaInvMassReco_Two_mvd(nullptr)
218  , fGammaOpeningAngleReco_Two_mvd(nullptr)
219  , fPi0InvMassRecoKF_Two_mvd(nullptr)
220  , fHistoList_Two_sts()
221  , fGammaInvMassReco_Two_sts(nullptr)
222  , fGammaOpeningAngleReco_Two_sts(nullptr)
223  , fPi0InvMassRecoKF_Two_sts(nullptr)
224  , fHistoList_Two_outside()
225  , fGammaInvMassReco_Two_outside(nullptr)
226  , fGammaOpeningAngleReco_Two_outside(nullptr)
227  , fPi0InvMassRecoKF_Two_outside(nullptr)
228  , fEMT_InvMass_Two_outside(nullptr)
229  , fHistoList_OneTwo()
230  , fGammaInvMassReco_OneTwo(nullptr)
231  , fGammaOpeningAngleReco_OneTwo(nullptr)
232  , fPdg_OneTwo(nullptr)
233  , fP_reco_OneTwo(nullptr)
234  , fPt_reco_OneTwo(nullptr)
235  , fPi0InvMassRecoKF_OneTwo(nullptr)
236  , fEMT_InvMass_OneTwo(nullptr)
237  , fPi0_pt_vs_rap_OneTwo(nullptr)
238  , fPi0_pt_vs_rap_est_OneTwo(nullptr)
239  , fHistoList_OneTwo_target()
240  , fGammaInvMassReco_OneTwo_target(nullptr)
241  , fGammaOpeningAngleReco_OneTwo_target(nullptr)
242  , fPi0InvMassRecoKF_OneTwo_target(nullptr)
243  , fEMT_InvMass_OneTwo_target(nullptr)
244  , fHistoList_OneTwo_mvd()
245  , fGammaInvMassReco_OneTwo_mvd(nullptr)
246  , fGammaOpeningAngleReco_OneTwo_mvd(nullptr)
247  , fPi0InvMassRecoKF_OneTwo_mvd(nullptr)
248  , fHistoList_OneTwo_sts()
249  , fGammaInvMassReco_OneTwo_sts(nullptr)
250  , fGammaOpeningAngleReco_OneTwo_sts(nullptr)
251  , fPi0InvMassRecoKF_OneTwo_sts(nullptr)
252  , fHistoList_OneTwo_outside()
253  , fGammaInvMassReco_OneTwo_outside(nullptr)
254  , fGammaOpeningAngleReco_OneTwo_outside(nullptr)
255  , fPi0InvMassRecoKF_OneTwo_outside(nullptr)
256  , fEMT_InvMass_OneTwo_outside(nullptr)
257  , fHistoList_multiplicity()
258  , MultiplicityGamma_All(nullptr)
259  , MultiplicityGamma_Zero(nullptr)
260  , MultiplicityGamma_One(nullptr)
261  , MultiplicityGamma_Two(nullptr)
262  , MultiplicityGamma_OneTwo(nullptr)
263  , MultiplicityChargedParticles_All(nullptr)
264  , MultiplicityChargedParticles_Zero(nullptr)
265  , MultiplicityChargedParticles_One(nullptr)
266  , MultiplicityChargedParticles_Two(nullptr)
267  , MultiplicityChargedParticles_OneTwo(nullptr)
268  , fHistoList_multiplicity_All()
269  , fHistoList_multiplicity_One()
270  , fHistoList_multiplicity_Two()
271  , fHistoList_multiplicity_Zero()
272  , fHistoList_multiplicity_OneTwo()
273  , EMTMulti_InvMass_All_m1(nullptr)
274  , EMTMulti_InvMass_All_m2(nullptr)
275  , EMTMulti_InvMass_All_m3(nullptr)
276  , EMTMulti_InvMass_All_m4(nullptr)
277  , EMTMulti_InvMass_All_m5(nullptr)
278  , EMTMulti_InvMass_All_m6(nullptr)
279  , EMTMulti_InvMass_All_m7(nullptr)
280  , EMTMulti_InvMass_Zero_m1(nullptr)
281  , EMTMulti_InvMass_Zero_m2(nullptr)
282  , EMTMulti_InvMass_Zero_m3(nullptr)
283  , EMTMulti_InvMass_Zero_m4(nullptr)
284  , EMTMulti_InvMass_Zero_m5(nullptr)
285  , EMTMulti_InvMass_Zero_m6(nullptr)
286  , EMTMulti_InvMass_Zero_m7(nullptr)
287  , EMTMulti_InvMass_One_m1(nullptr)
288  , EMTMulti_InvMass_One_m2(nullptr)
289  , EMTMulti_InvMass_One_m3(nullptr)
290  , EMTMulti_InvMass_One_m4(nullptr)
291  , EMTMulti_InvMass_One_m5(nullptr)
292  , EMTMulti_InvMass_One_m6(nullptr)
293  , EMTMulti_InvMass_One_m7(nullptr)
294  , EMTMulti_InvMass_Two_m1(nullptr)
295  , EMTMulti_InvMass_Two_m2(nullptr)
296  , EMTMulti_InvMass_Two_m3(nullptr)
297  , EMTMulti_InvMass_Two_m4(nullptr)
298  , EMTMulti_InvMass_Two_m5(nullptr)
299  , EMTMulti_InvMass_Two_m6(nullptr)
300  , EMTMulti_InvMass_Two_m7(nullptr)
301  , EMTMulti_InvMass_OneTwo_m1(nullptr)
302  , EMTMulti_InvMass_OneTwo_m2(nullptr)
303  , EMTMulti_InvMass_OneTwo_m3(nullptr)
304  , EMTMulti_InvMass_OneTwo_m4(nullptr)
305  , EMTMulti_InvMass_OneTwo_m5(nullptr)
306  , EMTMulti_InvMass_OneTwo_m6(nullptr)
307  , EMTMulti_InvMass_OneTwo_m7(nullptr)
308  , fHistoList_bg_all()
309  , BG1_all(nullptr)
310  , BG2_all(nullptr)
311  , BG3_all(nullptr)
312  , BG4_all(nullptr)
313  , BG5_all(nullptr)
314  , BG6_all(nullptr)
315  , BG7_all(nullptr)
316  , BG8_all(nullptr)
317  , BG9_all(nullptr)
318  , BG10_all(nullptr)
319  , PdgCase8_all(nullptr)
320  , PdgCase8mothers_all(nullptr)
321  , sameMIDcase8_all(nullptr)
322  , sameGRIDcase8_all(nullptr)
323  , Case1ZYPos_all(nullptr)
324  , sameMIDcase8_mothedPDG_all(nullptr)
325  , PdgCase8NonEComeFromTarget_all(nullptr)
326  , PdgCase8NonE_NOT_FromTarget_all(nullptr)
327  , PdgCase8motherNonE_all(nullptr)
328  , Case8ElFromDalitz_all(nullptr)
329  , Case8NonElFrom_pn_all(nullptr)
330  , Case8NonElFrom_eta_all(nullptr)
331  , Case8NonElFrom_kaon_all(nullptr)
332  , sameMIDcase8NonEPdg_all(nullptr)
333  , sameMIDcase8NonEMotherPdg_all(nullptr)
334  , sameMIDcase8NonEMotherIM_all(nullptr)
335  , sameMIDcase8NonEPdgFromTarget_all(nullptr)
336  , sameMIDcase8NonEComeFromTargetIM_all(nullptr)
337  , sameMIDcase8NonEComeFromTargetP_all(nullptr)
338  , sameMIDcase8NonEComeFromTargetPt_all(nullptr)
339  , fHistoList_bg_zero()
340  , BG1_zero(nullptr)
341  , BG2_zero(nullptr)
342  , BG3_zero(nullptr)
343  , BG4_zero(nullptr)
344  , BG5_zero(nullptr)
345  , BG6_zero(nullptr)
346  , BG7_zero(nullptr)
347  , BG8_zero(nullptr)
348  , BG9_zero(nullptr)
349  , BG10_zero(nullptr)
350  , PdgCase8_zero(nullptr)
351  , PdgCase8mothers_zero(nullptr)
352  , sameMIDcase8_zero(nullptr)
353  , sameGRIDcase8_zero(nullptr)
354  , Case1ZYPos_zero(nullptr)
355  , sameMIDcase8_mothedPDG_zero(nullptr)
356  , PdgCase8NonEComeFromTarget_zero(nullptr)
357  , PdgCase8NonE_NOT_FromTarget_zero(nullptr)
358  , PdgCase8motherNonE_zero(nullptr)
359  , Case8ElFromDalitz_zero(nullptr)
360  , Case8NonElFrom_pn_zero(nullptr)
361  , Case8NonElFrom_eta_zero(nullptr)
362  , Case8NonElFrom_kaon_zero(nullptr)
363  , sameMIDcase8NonEPdg_zero(nullptr)
364  , sameMIDcase8NonEMotherPdg_zero(nullptr)
365  , sameMIDcase8NonEMotherIM_zero(nullptr)
366  , sameMIDcase8NonEPdgFromTarget_zero(nullptr)
367  , sameMIDcase8NonEComeFromTargetIM_zero(nullptr)
368  , sameMIDcase8NonEComeFromTargetP_zero(nullptr)
369  , sameMIDcase8NonEComeFromTargetPt_zero(nullptr)
370  , fHistoList_bg_one()
371  , BG1_one(nullptr)
372  , BG2_one(nullptr)
373  , BG3_one(nullptr)
374  , BG4_one(nullptr)
375  , BG5_one(nullptr)
376  , BG6_one(nullptr)
377  , BG7_one(nullptr)
378  , BG8_one(nullptr)
379  , BG9_one(nullptr)
380  , BG10_one(nullptr)
381  , PdgCase8_one(nullptr)
382  , PdgCase8mothers_one(nullptr)
383  , sameMIDcase8_one(nullptr)
384  , sameGRIDcase8_one(nullptr)
385  , Case1ZYPos_one(nullptr)
386  , sameMIDcase8_mothedPDG_one(nullptr)
387  , PdgCase8NonEComeFromTarget_one(nullptr)
388  , PdgCase8NonE_NOT_FromTarget_one(nullptr)
389  , PdgCase8motherNonE_one(nullptr)
390  , Case8ElFromDalitz_one(nullptr)
391  , Case8NonElFrom_pn_one(nullptr)
392  , Case8NonElFrom_eta_one(nullptr)
393  , Case8NonElFrom_kaon_one(nullptr)
394  , sameMIDcase8NonEPdg_one(nullptr)
395  , sameMIDcase8NonEMotherPdg_one(nullptr)
396  , sameMIDcase8NonEMotherIM_one(nullptr)
397  , sameMIDcase8NonEPdgFromTarget_one(nullptr)
398  , sameMIDcase8NonEComeFromTargetIM_one(nullptr)
399  , sameMIDcase8NonEComeFromTargetP_one(nullptr)
400  , sameMIDcase8NonEComeFromTargetPt_one(nullptr)
401  , fHistoList_bg_two()
402  , BG1_two(nullptr)
403  , BG2_two(nullptr)
404  , BG3_two(nullptr)
405  , BG4_two(nullptr)
406  , BG5_two(nullptr)
407  , BG6_two(nullptr)
408  , BG7_two(nullptr)
409  , BG8_two(nullptr)
410  , BG9_two(nullptr)
411  , BG10_two(nullptr)
412  , PdgCase8_two(nullptr)
413  , PdgCase8mothers_two(nullptr)
414  , sameMIDcase8_two(nullptr)
415  , sameGRIDcase8_two(nullptr)
416  , Case1ZYPos_two(nullptr)
417  , sameMIDcase8_mothedPDG_two(nullptr)
418  , PdgCase8NonEComeFromTarget_two(nullptr)
419  , PdgCase8NonE_NOT_FromTarget_two(nullptr)
420  , PdgCase8motherNonE_two(nullptr)
421  , Case8ElFromDalitz_two(nullptr)
422  , Case8NonElFrom_pn_two(nullptr)
423  , Case8NonElFrom_eta_two(nullptr)
424  , Case8NonElFrom_kaon_two(nullptr)
425  , sameMIDcase8NonEPdg_two(nullptr)
426  , sameMIDcase8NonEMotherPdg_two(nullptr)
427  , sameMIDcase8NonEMotherIM_two(nullptr)
428  , sameMIDcase8NonEPdgFromTarget_two(nullptr)
429  , sameMIDcase8NonEComeFromTargetIM_two(nullptr)
430  , sameMIDcase8NonEComeFromTargetP_two(nullptr)
431  , sameMIDcase8NonEComeFromTargetPt_two(nullptr)
432  , fHistoList_bg_onetwo()
433  , BG1_onetwo(nullptr)
434  , BG2_onetwo(nullptr)
435  , BG3_onetwo(nullptr)
436  , BG4_onetwo(nullptr)
437  , BG5_onetwo(nullptr)
438  , BG6_onetwo(nullptr)
439  , BG7_onetwo(nullptr)
440  , BG8_onetwo(nullptr)
441  , BG9_onetwo(nullptr)
442  , BG10_onetwo(nullptr)
443  , PdgCase8_onetwo(nullptr)
444  , PdgCase8mothers_onetwo(nullptr)
445  , sameMIDcase8_onetwo(nullptr)
446  , sameGRIDcase8_onetwo(nullptr)
447  , Case1ZYPos_onetwo(nullptr)
448  , sameMIDcase8_mothedPDG_onetwo(nullptr)
449  , PdgCase8NonEComeFromTarget_onetwo(nullptr)
450  , PdgCase8NonE_NOT_FromTarget_onetwo(nullptr)
451  , PdgCase8motherNonE_onetwo(nullptr)
452  , Case8ElFromDalitz_onetwo(nullptr)
453  , Case8NonElFrom_pn_onetwo(nullptr)
454  , Case8NonElFrom_eta_onetwo(nullptr)
455  , Case8NonElFrom_kaon_onetwo(nullptr)
456  , sameMIDcase8NonEPdg_onetwo(nullptr)
457  , sameMIDcase8NonEMotherPdg_onetwo(nullptr)
458  , sameMIDcase8NonEMotherIM_onetwo(nullptr)
459  , sameMIDcase8NonEPdgFromTarget_onetwo(nullptr)
460  , sameMIDcase8NonEComeFromTargetIM_onetwo(nullptr)
461  , sameMIDcase8NonEComeFromTargetP_onetwo(nullptr)
462  , sameMIDcase8NonEComeFromTargetPt_onetwo(nullptr) {}
463 
464 CbmKresConversionKF::~CbmKresConversionKF() {}
465 
466 void CbmKresConversionKF::SetKF(CbmKFParticleFinder* kfparticle,
467  CbmKFParticleFinderQA* kfparticleQA) {
468  fKFparticle = kfparticle;
469  fKFparticleFinderQA = kfparticleQA;
470  if (fKFparticle) {
471  cout << "CbmKresConversionKF: kf works" << endl;
472  } else {
473  cout << "CbmKresConversionKF: kf does not work" << endl;
474  }
475 }
476 
477 void CbmKresConversionKF::Init() {
478  fKFtopo = fKFparticle->GetTopoReconstructor();
479 
480  fTauFit = new CbmRichRingFitterEllipseTau();
481 
482  FairRootManager* ioman = FairRootManager::Instance();
483  if (nullptr == ioman) {
484  Fatal("CbmKresConversionKF::Init", "RootManager not instantised!");
485  }
486 
487  fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
488  if (nullptr == fMcTracks) {
489  Fatal("CbmKresConversionKF::Init", "No MCTrack array!");
490  }
491 
492  fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
493  if (nullptr == fStsTracks) {
494  Fatal("CbmKresConversionKF::Init", "No StsTrack array!");
495  }
496 
497  fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
498  if (nullptr == fStsTrackMatches) {
499  Fatal("CbmKresConversionKF::Init", "No StsTrackMatch array!");
500  }
501 
502  fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
503  if (nullptr == fGlobalTracks) {
504  Fatal("CbmKresConversionKF::Init", "No GlobalTrack array!");
505  }
506 
507  fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
508  if (nullptr == fRichRingMatches) {
509  Fatal("CbmKresConversionKF::Init", "No RichRingMatch array!");
510  }
511 
512  fRichProjections = (TClonesArray*) ioman->GetObject("RichProjection");
513  if (nullptr == fRichProjections) {
514  Fatal("CbmKresConversionKF::Init", "No RichProjection array!");
515  }
516 
517  fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
518  if (nullptr == fRichRings) {
519  Fatal("CbmKresConversionKF::Init", "No RichRing array!");
520  }
521 
522  fRichHits = (TClonesArray*) ioman->GetObject("RichHit");
523  if (nullptr == fRichHits) {
524  Fatal("CbmKresConversionKF::Init", "No RichHit array!");
525  }
526 
527  InitHistograms();
528 
529  fAnaBG = new CbmKresConversionBG();
530  fAnaBG->Init();
531 }
532 
533 
534 void CbmKresConversionKF::Exec(int fEventNumKF,
535  double OpeningAngleCut,
536  double GammaInvMassCut,
537  int RealPID) {
538  cout << "CbmKresConversionKF, event No. " << fEventNumKF << endl;
539 
540  //***** extract all particles from KFParticleFinder
541  vector<KFParticle> particlevector;
542  particlevector = fKFtopo->GetParticles();
543 
544  //***** extract from all particles in KFParticleFinder only gammas
545  vector<KFParticle> allgammas;
546  allgammas.clear();
547  for (size_t vv = 0; vv < particlevector.size(); vv++) {
548  if (particlevector[vv].KFParticleBase::GetPDG()
549  == 22) { // particle is gamma
550  if (particlevector[vv].KFParticleBase::NDaughters() != 2)
551  continue; // check - if gamma has two particles
552  allgammas.push_back(particlevector[vv]);
553  }
554  }
555  cout << "number of all gammas from KFParticleFinder before any cuts = "
556  << allgammas.size() << endl;
557 
558  //***** sort gammas via number of identified leptons in RICH
559  GammasAll.clear();
560  GammasZero.clear();
561  GammasOne.clear();
562  GammasTwo.clear();
563  GammasOneTwo.clear();
564  GammasAllStsIndex.clear();
565  GammasZeroStsIndex.clear();
566  GammasOneStsIndex.clear();
567  GammasTwoStsIndex.clear();
568  GammasOneTwoStsIndex.clear();
569  GammasAllMC.clear();
570  GammasZeroMC.clear();
571  GammasOneMC.clear();
572  GammasTwoMC.clear();
573  GammasOneTwoMC.clear();
574  GammasAllZ.clear();
575  GammasZeroZ.clear();
576  GammasOneZ.clear();
577  GammasTwoZ.clear();
578  GammasOneTwoZ.clear();
579 
580 
581  FindGammas(allgammas,
582  particlevector,
583  fEventNumKF,
584  OpeningAngleCut,
585  GammaInvMassCut,
586  RealPID);
587 
588 
589  FindPi0("All",
590  GammasAll,
591  GammasAllStsIndex,
592  GammasAllMC,
593  GammasAllZ,
594  fPi0InvMassRecoKF_All,
595  fPi0_pt_vs_rap_All,
596  fPi0_pt_vs_rap_est_All,
597  fPi0InvMassRecoKF_All_target,
598  fPi0InvMassRecoKF_All_mvd,
599  fPi0InvMassRecoKF_All_sts,
600  fPi0InvMassRecoKF_All_outside,
601  MultiplicityGamma_All,
602  MultiplicityChargedParticles_All,
603  fHistoList_bg_all);
604 
605  FindPi0("Zero",
606  GammasZero,
607  GammasZeroStsIndex,
608  GammasZeroMC,
609  GammasZeroZ,
610  fPi0InvMassRecoKF_Zero,
611  fPi0_pt_vs_rap_Zero,
612  fPi0_pt_vs_rap_est_Zero,
613  fPi0InvMassRecoKF_Zero_target,
614  fPi0InvMassRecoKF_Zero_mvd,
615  fPi0InvMassRecoKF_Zero_sts,
616  fPi0InvMassRecoKF_Zero_outside,
617  MultiplicityGamma_Zero,
618  MultiplicityChargedParticles_Zero,
619  fHistoList_bg_zero);
620 
621  FindPi0("One",
622  GammasOne,
623  GammasOneStsIndex,
624  GammasOneMC,
625  GammasOneZ,
626  fPi0InvMassRecoKF_One,
627  fPi0_pt_vs_rap_One,
628  fPi0_pt_vs_rap_est_One,
629  fPi0InvMassRecoKF_One_target,
630  fPi0InvMassRecoKF_One_mvd,
631  fPi0InvMassRecoKF_One_sts,
632  fPi0InvMassRecoKF_One_outside,
633  MultiplicityGamma_One,
634  MultiplicityChargedParticles_One,
635  fHistoList_bg_one);
636 
637  FindPi0("Two",
638  GammasTwo,
639  GammasTwoStsIndex,
640  GammasTwoMC,
641  GammasTwoZ,
642  fPi0InvMassRecoKF_Two,
643  fPi0_pt_vs_rap_Two,
644  fPi0_pt_vs_rap_est_Two,
645  fPi0InvMassRecoKF_Two_target,
646  fPi0InvMassRecoKF_Two_mvd,
647  fPi0InvMassRecoKF_Two_sts,
648  fPi0InvMassRecoKF_Two_outside,
649  MultiplicityGamma_Two,
650  MultiplicityChargedParticles_Two,
651  fHistoList_bg_two);
652 
653  FindPi0("OneTwo",
654  GammasOneTwo,
655  GammasOneTwoStsIndex,
656  GammasOneTwoMC,
657  GammasOneTwoZ,
658  fPi0InvMassRecoKF_OneTwo,
659  fPi0_pt_vs_rap_OneTwo,
660  fPi0_pt_vs_rap_est_OneTwo,
661  fPi0InvMassRecoKF_OneTwo_target,
662  fPi0InvMassRecoKF_OneTwo_mvd,
663  fPi0InvMassRecoKF_OneTwo_sts,
664  fPi0InvMassRecoKF_OneTwo_outside,
665  MultiplicityGamma_OneTwo,
666  MultiplicityChargedParticles_OneTwo,
667  fHistoList_bg_onetwo);
668 
669 
670  if (fEventNumKF % 500 == 0) {
671  MixedEvent();
672  EMT_Event.clear();
673  EMT_pair_momenta.clear();
674  EMT_NofRings.clear();
675  EMT_Z.clear();
676  }
677 
678  if (fEventNumKF % 1000 == 0) {
679  MixedEventMulti();
680  EMT_Event_multi_all.clear();
681  EMT_pair_momenta_multi_all.clear();
682  EMT_Event_multi_zero.clear();
683  EMT_pair_momenta_multi_zero.clear();
684  EMT_Event_multi_one.clear();
685  EMT_pair_momenta_multi_one.clear();
686  EMT_Event_multi_two.clear();
687  EMT_pair_momenta_multi_two.clear();
688  EMT_Event_multi_onetwo.clear();
689  EMT_pair_momenta_multi_onetwo.clear();
690  EMT_multi_all.clear();
691  EMT_multi_one.clear();
692  EMT_multi_two.clear();
693  EMT_multi_zero.clear();
694  EMT_multi_onetwo.clear();
695  }
696 
697 
698  // pi0, which maksym accept
699  vector<vector<KFParticle>> primpi0;
700  primpi0 = fKFtopo->GetKFParticleFinder()->GetPrimaryPi0();
701  vector<KFParticle> primpi0inside;
702  primpi0inside = primpi0.at(0);
703  for (size_t tt = 0; tt < primpi0inside.size(); tt++) {
704  cout << "\t *********** primpi0->GetPt = " << primpi0inside[tt].GetPt()
705  << "; ->GetMass = " << primpi0inside[tt].GetMass()
706  << "; ->GetX = " << primpi0inside[tt].GetX()
707  << "; ->GetY = " << primpi0inside[tt].GetY()
708  << "; ->GetZ = " << primpi0inside[tt].GetZ()
709  << "; ->GetE = " << primpi0inside[tt].GetE() << endl;
710  }
711 }
712 
713 
714 void CbmKresConversionKF::FindGammas(vector<KFParticle> allgammas,
715  vector<KFParticle> particlevector,
716  int Event,
717  double AngleCut,
718  double InvMassCut,
719  int RealPID) {
720  for (size_t tt = 0; tt < allgammas.size(); tt++) {
721  if (allgammas[tt].GetZ() > 75 || allgammas[tt].GetZ() < -5) continue;
722  std::vector<int> electronIds = allgammas[tt].KFParticleBase::DaughterIds();
723  std::vector<int> grDaughter0 =
724  particlevector[electronIds.at(0)].KFParticleBase::DaughterIds();
725  std::vector<int> grDaughter1 =
726  particlevector[electronIds.at(1)].KFParticleBase::DaughterIds();
727  if (grDaughter0.size() != 1 || grDaughter1.size() != 1)
728  continue; // check that it made only two particles
729 
730  // STS ind
731  CbmStsTrack* stsTrack0 = (CbmStsTrack*) fStsTracks->At(grDaughter0.at(0));
732  CbmStsTrack* stsTrack1 = (CbmStsTrack*) fStsTracks->At(grDaughter1.at(0));
733  if (stsTrack0 == nullptr || stsTrack1 == nullptr) continue;
734  CbmTrackMatchNew* stsMatch0 =
735  (CbmTrackMatchNew*) fStsTrackMatches->At(grDaughter0.at(0));
736  CbmTrackMatchNew* stsMatch1 =
737  (CbmTrackMatchNew*) fStsTrackMatches->At(grDaughter1.at(0));
738  if (stsMatch0 == nullptr || stsMatch1 == nullptr) continue;
739  if (stsMatch0->GetNofLinks() <= 0 || stsMatch1->GetNofLinks() <= 0)
740  continue;
741  int stsMcTrackId0 = stsMatch0->GetMatchedLink().GetIndex();
742  int stsMcTrackId1 = stsMatch1->GetMatchedLink().GetIndex();
743  if (stsMcTrackId0 < 0 || stsMcTrackId1 < 0) continue;
744  CbmMCTrack* mcTrack0 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId0);
745  CbmMCTrack* mcTrack1 = (CbmMCTrack*) fMcTracks->At(stsMcTrackId1);
746  if (mcTrack0 == nullptr || mcTrack1 == nullptr) continue;
747 
748  TVector3 refmomentum0 = CbmKresFunctions::FitToVertex(stsTrack0,
749  allgammas[tt].GetX(),
750  allgammas[tt].GetY(),
751  allgammas[tt].GetZ());
752  TVector3 refmomentum1 = CbmKresFunctions::FitToVertex(stsTrack1,
753  allgammas[tt].GetX(),
754  allgammas[tt].GetY(),
755  allgammas[tt].GetZ());
756 
757  // RICH ind
758  Int_t ngTracks = fGlobalTracks->GetEntriesFast();
759  int richInd0 = 99999;
760  int richInd1 = 99999;
761  for (Int_t iTr = 0; iTr < ngTracks; iTr++) {
762  CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iTr);
763  if (nullptr == gTrack) continue;
764  int stsInd = gTrack->GetStsTrackIndex();
765  if (stsInd < 0) continue;
766  if (stsInd == grDaughter0.at(0)) {
767  if (gTrack->GetRichRingIndex() > -1)
768  richInd0 = gTrack->GetRichRingIndex();
769  }
770  if (stsInd == grDaughter1.at(0)) {
771  if (gTrack->GetRichRingIndex() > -1)
772  richInd1 = gTrack->GetRichRingIndex();
773  }
774  }
775 
776  int richcheck_0 = 0;
777  int richcheck_1 = 0;
778  //***** MCPID for RICH identification
779  if (RealPID != 1) {
780  if (richInd0 != 99999) {
781  CbmTrackMatchNew* richMatch =
782  (CbmTrackMatchNew*) fRichRingMatches->At(richInd0);
783  if (richMatch == nullptr) continue;
784  if (richMatch->GetNofLinks() <= 0) continue;
785  int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
786  if (richMcTrackId < 0) continue;
787  if (stsMcTrackId0 != richMcTrackId)
788  continue; // check that global track was matched correctly for STS and RICH together
789  CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
790  if (mcTrack2 == nullptr) continue;
791  int pdgRICH = mcTrack2->GetPdgCode();
792  if (TMath::Abs(pdgRICH) == 11) richcheck_0++;
793  }
794  if (richInd1 != 99999) {
795  CbmTrackMatchNew* richMatch =
796  (CbmTrackMatchNew*) fRichRingMatches->At(richInd1);
797  if (richMatch == nullptr) continue;
798  if (richMatch->GetNofLinks() <= 0) continue;
799  int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
800  if (richMcTrackId < 0) continue;
801  if (stsMcTrackId1 != richMcTrackId)
802  continue; // check that global track was matched correctly for STS and RICH together
803  CbmMCTrack* mcTrack2 = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
804  if (mcTrack2 == nullptr) continue;
805  int pdgRICH = mcTrack2->GetPdgCode();
806  if (TMath::Abs(pdgRICH) == 11) richcheck_1++;
807  }
808  }
809 
810  // Real PID for RICH identification
811  if (RealPID == 1) {
812  if (richInd0 != 99999) {
813  CbmRichRing* richRing =
814  static_cast<CbmRichRing*>(fRichRings->At(richInd0));
815  richcheck_0 = CheckIfElectron(richRing, refmomentum0.Mag());
816  }
817  if (richInd1 != 99999) {
818  CbmRichRing* richRing =
819  static_cast<CbmRichRing*>(fRichRings->At(richInd1));
820  richcheck_1 = CheckIfElectron(richRing, refmomentum1.Mag());
821  }
822  }
823  // Real RICH PID (END).
824 
825  int richcheck = richcheck_0 + richcheck_1;
826 
827 
828  FairTrackParam* proj =
829  (FairTrackParam*) fRichProjections->At(grDaughter0.at(0));
830  if (richcheck_0 == 0 && proj->GetX() > -115 && proj->GetX() < 115
831  && ((proj->GetY() < -120 && proj->GetY() > -200)
832  || (proj->GetY() > 120 && proj->GetY() < 200)))
833  continue;
834  FairTrackParam* proj2 =
835  (FairTrackParam*) fRichProjections->At(grDaughter1.at(0));
836  if (richcheck_1 == 0 && proj2->GetX() > -115 && proj2->GetX() < 115
837  && ((proj2->GetY() < -120 && proj2->GetY() > -200)
838  || (proj2->GetY() > 120 && proj2->GetY() < 200)))
839  continue;
840 
841 
842  //cout << "=================" << endl;
843  //cout << "FitToVertex part1: px = " << refmomentum0.X() << "; \t py = " << refmomentum0.Y() << "; \t pz = " << refmomentum0.Z() << endl;
844  //cout << "FitToVertex part2: px = " << refmomentum1.X() << "; \t py = " << refmomentum1.Y() << "; \t pz = " << refmomentum1.Z() << endl;
845  //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;
846  //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;
847  //TVector3 refmomentum0(particlevector[electronIds.at(0)].KFParticleBase::Px(), particlevector[electronIds.at(0)].KFParticleBase::Py(), particlevector[electronIds.at(0)].KFParticleBase::Pz());
848  //TVector3 refmomentum1(particlevector[electronIds.at(1)].KFParticleBase::Px(), particlevector[electronIds.at(1)].KFParticleBase::Py(), particlevector[electronIds.at(1)].KFParticleBase::Pz());
849 
850 
851  frefmomentum.clear();
852  frefmomentum.push_back(refmomentum0);
853  frefmomentum.push_back(refmomentum1);
854  fmcvector.clear();
855  fmcvector.push_back(mcTrack0);
856  fmcvector.push_back(mcTrack1);
857  fStsInd.clear();
858  fStsInd.push_back(grDaughter0.at(0));
859  fStsInd.push_back(grDaughter1.at(0));
860 
861  Double_t invmassTrue =
862  CbmKresFunctions::Invmass_2particles_MC(fmcvector.at(0), fmcvector.at(1));
863  Double_t invmassReco = CbmKresFunctions::Invmass_2particles_RECO(
864  frefmomentum.at(0), frefmomentum.at(1));
865  Double_t opening_angle_mc = CbmKresFunctions::CalculateOpeningAngle_MC(
866  fmcvector.at(0), fmcvector.at(1));
867  Double_t opening_angle_refitted =
868  CbmKresFunctions::CalculateOpeningAngle_Reco(frefmomentum.at(0),
869  frefmomentum.at(1));
870 
871 
872  // graphs for understanding cuts:
873  CheckForCuts_InvMass_MC->Fill(invmassTrue);
874  CheckForCuts_InvMass_Reco->Fill(invmassReco);
875  CheckForCuts_OA_MC->Fill(opening_angle_mc);
876  CheckForCuts_OA_Reco->Fill(opening_angle_refitted);
877 
878 
879  if (TMath::Abs(mcTrack0->GetPdgCode()) == 11
880  && (mcTrack0->GetPdgCode() + mcTrack1->GetPdgCode()) == 0
881  && (mcTrack0->GetMotherId() == mcTrack1->GetMotherId())
882  && mcTrack0->GetMotherId() != -1) {
883  CbmMCTrack* mcTrackMother =
884  (CbmMCTrack*) fMcTracks->At(mcTrack0->GetMotherId());
885  if (mcTrackMother != nullptr && mcTrackMother->GetPdgCode() == 22
886  && mcTrackMother->GetMotherId()
887  != -1) { // electrons/positrons from gamma
888  CbmMCTrack* mcTrackMotherOfGamma =
889  (CbmMCTrack*) fMcTracks->At(mcTrackMother->GetMotherId()); // pi0
890  if (mcTrackMotherOfGamma->GetPdgCode() == 111) {
891  CheckForCuts_OA_MC_from_one_pi0->Fill(opening_angle_mc);
892  CheckForCuts_OA_Reco_from_one_pi0->Fill(opening_angle_refitted);
893  CheckForCuts_InvMass_MC_from_one_pi0->Fill(invmassTrue);
894  CheckForCuts_InvMass_Reco_from_one_pi0->Fill(invmassReco);
895  CheckForCuts_z_vs_InvMass_MC_from_one_pi0->Fill(mcTrack0->GetStartZ(),
896  invmassTrue);
897  CheckForCuts_z_vs_OA_MC_from_one_pi0->Fill(mcTrack0->GetStartZ(),
898  opening_angle_mc);
899  CheckForCuts_z_vs_InvMass_Reco_from_one_pi0->Fill(
900  allgammas[tt].GetZ(), invmassReco);
901  CheckForCuts_z_vs_OA_Reco_from_one_pi0->Fill(allgammas[tt].GetZ(),
902  opening_angle_refitted);
903  if (allgammas[tt].GetZ() <= 4) {
904  CheckForCuts_InvMass_Reco_from_one_pi0_less4cm->Fill(invmassReco);
905  CheckForCuts_OA_Reco_from_one_pi0_less4cm->Fill(
906  opening_angle_refitted);
907  }
908  if (allgammas[tt].GetZ() <= 21 && allgammas[tt].GetZ() > 4) {
909  CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm->Fill(invmassReco);
910  CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm->Fill(
911  opening_angle_refitted);
912  }
913  if (allgammas[tt].GetZ() > 21) {
914  CheckForCuts_InvMass_Reco_from_one_pi0_more21cm->Fill(invmassReco);
915  CheckForCuts_OA_Reco_from_one_pi0_more21cm->Fill(
916  opening_angle_refitted);
917  }
918  }
919  }
920  }
921 
922 
923  // cuts
924  if (TMath::Abs(opening_angle_refitted) > AngleCut) continue;
925  if (TMath::Abs(invmassReco) > InvMassCut) continue;
926 
927 
928  // for event mixing
929  EMT_Event.push_back(Event);
930  EMT_pair_momenta.push_back(frefmomentum);
931  EMT_NofRings.push_back(richcheck);
932  EMT_Z.push_back(allgammas[tt].GetZ());
933 
934 
935  // everything (RICH == 0, RICH == 1, RICH == 2) together
936  if (richcheck == 0 || richcheck == 1 || richcheck == 2) {
937  // for event mixing multi
938  EMT_Event_multi_all.push_back(Event);
939  EMT_pair_momenta_multi_all.push_back(frefmomentum);
940 
941  GammasAll.push_back(frefmomentum);
942  GammasAllStsIndex.push_back(fStsInd);
943  GammasAllMC.push_back(fmcvector);
944  GammasAllZ.push_back(allgammas[tt].GetZ());
945 
946  fGammaInvMassReco_All->Fill(invmassReco);
947  fGammaOpeningAngleReco_All->Fill(opening_angle_refitted);
948  fPdg_All->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
949  fPdg_All->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
950  fP_reco_All->Fill(refmomentum0.Mag());
951  fP_reco_All->Fill(refmomentum1.Mag());
952  fPt_reco_All->Fill(refmomentum0.Perp());
953  fPt_reco_All->Fill(refmomentum1.Perp());
954  if (allgammas[tt].GetZ() < 4) {
955  fGammaInvMassReco_All_target->Fill(invmassReco);
956  fGammaOpeningAngleReco_All_target->Fill(opening_angle_refitted);
957  }
958  if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
959  fGammaInvMassReco_All_mvd->Fill(invmassReco);
960  fGammaOpeningAngleReco_All_mvd->Fill(opening_angle_refitted);
961  }
962  if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
963  fGammaInvMassReco_All_sts->Fill(invmassReco);
964  fGammaOpeningAngleReco_All_sts->Fill(opening_angle_refitted);
965  }
966  if (allgammas[tt].GetZ() > 4) {
967  fGammaInvMassReco_All_outside->Fill(invmassReco);
968  fGammaOpeningAngleReco_All_outside->Fill(opening_angle_refitted);
969  }
970  }
971 
972 
973  // only cases, when RICH == 0
974  if (richcheck == 0) {
975  // for event mixing multi
976  EMT_Event_multi_zero.push_back(Event);
977  EMT_pair_momenta_multi_zero.push_back(frefmomentum);
978 
979  GammasZero.push_back(frefmomentum);
980  GammasZeroStsIndex.push_back(fStsInd);
981  GammasZeroMC.push_back(fmcvector);
982  GammasZeroZ.push_back(allgammas[tt].GetZ());
983 
984  fGammaInvMassReco_Zero->Fill(invmassReco);
985  fGammaOpeningAngleReco_Zero->Fill(opening_angle_refitted);
986  fPdg_Zero->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
987  fPdg_Zero->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
988  fP_reco_Zero->Fill(refmomentum0.Mag());
989  fP_reco_Zero->Fill(refmomentum1.Mag());
990  fPt_reco_Zero->Fill(refmomentum0.Perp());
991  fPt_reco_Zero->Fill(refmomentum1.Perp());
992  if (allgammas[tt].GetZ() < 4) {
993  fGammaInvMassReco_Zero_target->Fill(invmassReco);
994  fGammaOpeningAngleReco_Zero_target->Fill(opening_angle_refitted);
995  }
996  if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
997  fGammaInvMassReco_Zero_mvd->Fill(invmassReco);
998  fGammaOpeningAngleReco_Zero_mvd->Fill(opening_angle_refitted);
999  }
1000  if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
1001  fGammaInvMassReco_Zero_sts->Fill(invmassReco);
1002  fGammaOpeningAngleReco_Zero_sts->Fill(opening_angle_refitted);
1003  }
1004  if (allgammas[tt].GetZ() > 4) {
1005  fGammaInvMassReco_Zero_outside->Fill(invmassReco);
1006  fGammaOpeningAngleReco_Zero_outside->Fill(opening_angle_refitted);
1007  }
1008  }
1009 
1010  // only cases, when RICH == 1
1011  if (richcheck == 1) {
1012  // for event mixing multi
1013  EMT_Event_multi_one.push_back(Event);
1014  EMT_pair_momenta_multi_one.push_back(frefmomentum);
1015 
1016  GammasOne.push_back(frefmomentum);
1017  GammasOneStsIndex.push_back(fStsInd);
1018  GammasOneMC.push_back(fmcvector);
1019  GammasOneZ.push_back(allgammas[tt].GetZ());
1020 
1021  fGammaInvMassReco_One->Fill(invmassReco);
1022  fGammaOpeningAngleReco_One->Fill(opening_angle_refitted);
1023  fPdg_One->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
1024  fPdg_One->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
1025  fP_reco_One->Fill(refmomentum0.Mag());
1026  fP_reco_One->Fill(refmomentum1.Mag());
1027  fPt_reco_One->Fill(refmomentum0.Perp());
1028  fPt_reco_One->Fill(refmomentum1.Perp());
1029  if (allgammas[tt].GetZ() < 4) {
1030  fGammaInvMassReco_One_target->Fill(invmassReco);
1031  fGammaOpeningAngleReco_One_target->Fill(opening_angle_refitted);
1032  }
1033  if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
1034  fGammaInvMassReco_One_mvd->Fill(invmassReco);
1035  fGammaOpeningAngleReco_One_mvd->Fill(opening_angle_refitted);
1036  }
1037  if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
1038  fGammaInvMassReco_One_sts->Fill(invmassReco);
1039  fGammaOpeningAngleReco_One_sts->Fill(opening_angle_refitted);
1040  }
1041  if (allgammas[tt].GetZ() > 4) {
1042  fGammaInvMassReco_One_outside->Fill(invmassReco);
1043  fGammaOpeningAngleReco_One_outside->Fill(opening_angle_refitted);
1044  }
1045  }
1046 
1047  // only cases, when RICH == 2
1048  if (richcheck == 2) {
1049  // for event mixing multi
1050  EMT_Event_multi_two.push_back(Event);
1051  EMT_pair_momenta_multi_two.push_back(frefmomentum);
1052 
1053  GammasTwo.push_back(frefmomentum);
1054  GammasTwoStsIndex.push_back(fStsInd);
1055  GammasTwoMC.push_back(fmcvector);
1056  GammasTwoZ.push_back(allgammas[tt].GetZ());
1057 
1058  fGammaInvMassReco_Two->Fill(invmassReco);
1059  fGammaOpeningAngleReco_Two->Fill(opening_angle_refitted);
1060  fPdg_Two->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
1061  fPdg_Two->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
1062  fP_reco_Two->Fill(refmomentum0.Mag());
1063  fP_reco_Two->Fill(refmomentum1.Mag());
1064  fPt_reco_Two->Fill(refmomentum0.Perp());
1065  fPt_reco_Two->Fill(refmomentum1.Perp());
1066  if (allgammas[tt].GetZ() < 4) {
1067  fGammaInvMassReco_Two_target->Fill(invmassReco);
1068  fGammaOpeningAngleReco_Two_target->Fill(opening_angle_refitted);
1069  }
1070  if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
1071  fGammaInvMassReco_Two_mvd->Fill(invmassReco);
1072  fGammaOpeningAngleReco_Two_mvd->Fill(opening_angle_refitted);
1073  }
1074  if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
1075  fGammaInvMassReco_Two_sts->Fill(invmassReco);
1076  fGammaOpeningAngleReco_Two_sts->Fill(opening_angle_refitted);
1077  }
1078  if (allgammas[tt].GetZ() > 4) {
1079  fGammaInvMassReco_Two_outside->Fill(invmassReco);
1080  fGammaOpeningAngleReco_Two_outside->Fill(opening_angle_refitted);
1081  }
1082  }
1083 
1084  // cases, when RICH == 1 or RICH == 2 together
1085  if (richcheck == 1 || richcheck == 2) {
1086  // for event mixing multi
1087  EMT_Event_multi_onetwo.push_back(Event);
1088  EMT_pair_momenta_multi_onetwo.push_back(frefmomentum);
1089 
1090  GammasOneTwo.push_back(frefmomentum);
1091  GammasOneTwoStsIndex.push_back(fStsInd);
1092  GammasOneTwoMC.push_back(fmcvector);
1093  GammasOneTwoZ.push_back(allgammas[tt].GetZ());
1094 
1095  fGammaInvMassReco_OneTwo->Fill(invmassReco);
1096  fGammaOpeningAngleReco_OneTwo->Fill(opening_angle_refitted);
1097  fPdg_OneTwo->Fill(TMath::Abs(mcTrack0->GetPdgCode()));
1098  fPdg_OneTwo->Fill(TMath::Abs(mcTrack1->GetPdgCode()));
1099  fP_reco_OneTwo->Fill(refmomentum0.Mag());
1100  fP_reco_OneTwo->Fill(refmomentum1.Mag());
1101  fPt_reco_OneTwo->Fill(refmomentum0.Perp());
1102  fPt_reco_OneTwo->Fill(refmomentum1.Perp());
1103  if (allgammas[tt].GetZ() < 4) {
1104  fGammaInvMassReco_OneTwo_target->Fill(invmassReco);
1105  fGammaOpeningAngleReco_OneTwo_target->Fill(opening_angle_refitted);
1106  }
1107  if (allgammas[tt].GetZ() > 4 && allgammas[tt].GetZ() < 21) {
1108  fGammaInvMassReco_OneTwo_mvd->Fill(invmassReco);
1109  fGammaOpeningAngleReco_OneTwo_mvd->Fill(opening_angle_refitted);
1110  }
1111  if (allgammas[tt].GetZ() > 21 && allgammas[tt].GetZ() < 75) {
1112  fGammaInvMassReco_OneTwo_sts->Fill(invmassReco);
1113  fGammaOpeningAngleReco_OneTwo_sts->Fill(opening_angle_refitted);
1114  }
1115  if (allgammas[tt].GetZ() > 4) {
1116  fGammaInvMassReco_OneTwo_outside->Fill(invmassReco);
1117  fGammaOpeningAngleReco_OneTwo_outside->Fill(opening_angle_refitted);
1118  }
1119  }
1120  }
1121 
1122  //cout << "number of gammas with 0-2 electron identified in RICH = " << GammasAll.size() << endl;
1123  //cout << "number of gammas with 0 electron identified in RICH = " << GammasZero.size() << endl;
1124  //cout << "number of gammas with 1 electron identified in RICH = " << GammasOne.size() << endl;
1125  //cout << "number of gammas with 2 electron identified in RICH = " << GammasTwo.size() << endl;
1126  //cout << "number of gammas with 1-2 electron identified in RICH = " << GammasOneTwo.size() << endl;
1127 
1128  for (size_t kk = 0; kk < GammasAll.size(); kk++) {
1129  EMT_multi_all.push_back(GammasAll.size());
1130  }
1131  for (size_t kk = 0; kk < GammasZero.size(); kk++) {
1132  EMT_multi_zero.push_back(GammasZero.size());
1133  }
1134  for (size_t kk = 0; kk < GammasOne.size(); kk++) {
1135  EMT_multi_one.push_back(GammasOne.size());
1136  }
1137  for (size_t kk = 0; kk < GammasTwo.size(); kk++) {
1138  EMT_multi_two.push_back(GammasTwo.size());
1139  }
1140  for (size_t kk = 0; kk < GammasOneTwo.size(); kk++) {
1141  EMT_multi_onetwo.push_back(GammasOneTwo.size());
1142  }
1143 }
1144 
1145 
1146 void CbmKresConversionKF::FindPi0(TString /*mod*/,
1147  vector<vector<TVector3>> Gammas,
1148  vector<vector<int>> StsIndex,
1149  vector<vector<CbmMCTrack*>> GammasMC,
1150  vector<Double_t> GammasZ,
1151  TH1D* Pi0InvMassRecoKF,
1152  TH2D* Pi0_pt_vs_rap,
1153  TH2D* Pi0_pt_vs_rap_est,
1154  TH1D* Pi0InvMassRecoKF_target,
1155  TH1D* Pi0InvMassRecoKF_mvd,
1156  TH1D* Pi0InvMassRecoKF_sts,
1157  TH1D* Pi0InvMassRecoKF_outside,
1158  TH2D* MultiplicityGamma,
1159  TH2D* MultiplicityChargedParticles,
1160  vector<TH1*> BGCases)
1161 
1162 {
1163  // combine all gamma in pi0 --> calculate inv mass for pi0 // not the case, when one particle used twice for different gammas
1164  if (Gammas.size() < 2) return; // min 2 gammas to form pi0 are required
1165 
1166  for (size_t gamma1 = 0; gamma1 < Gammas.size() - 1; gamma1++) {
1167  for (size_t gamma2 = gamma1 + 1; gamma2 < Gammas.size(); gamma2++) {
1168 
1169  if (StsIndex[gamma1][0] == StsIndex[gamma2][0]
1170  || StsIndex[gamma1][0] == StsIndex[gamma2][1]
1171  || StsIndex[gamma1][1] == StsIndex[gamma2][0]
1172  || StsIndex[gamma1][1] == StsIndex[gamma2][1])
1173  continue; // particles not used twice --> different
1174 
1175  // 4 reconstructed particles from gammas
1176  TVector3 e1 = Gammas[gamma1][0];
1177  TVector3 e2 = Gammas[gamma1][1];
1178  TVector3 e3 = Gammas[gamma2][0];
1179  TVector3 e4 = Gammas[gamma2][1];
1180 
1181  // MC true data for this particles
1182  CbmMCTrack* mcTrack1 = GammasMC[gamma1][0];
1183  CbmMCTrack* mcTrack2 = GammasMC[gamma1][1];
1184  CbmMCTrack* mcTrack3 = GammasMC[gamma2][0];
1185  CbmMCTrack* mcTrack4 = GammasMC[gamma2][1];
1186 
1187  CbmLmvmKinematicParams params =
1188  CbmKresFunctions::CalculateKinematicParams_4particles(e1, e2, e3, e4);
1189 
1190  Pi0InvMassRecoKF->Fill(params.fMinv);
1191 
1192  MultiplicityGamma->Fill(Gammas.size(), params.fMinv);
1193  MultiplicityChargedParticles->Fill(fGlobalTracks->GetEntriesFast(),
1194  params.fMinv);
1195 
1196  // check reconsrtucted z position of conversion
1197  if (GammasZ[gamma1] < 4 && GammasZ[gamma2] < 4) {
1198  Pi0InvMassRecoKF_target->Fill(params.fMinv);
1199  }
1200  if (GammasZ[gamma1] > 4 && GammasZ[gamma1] < 21 && GammasZ[gamma2] > 4
1201  && GammasZ[gamma2] < 21) {
1202  Pi0InvMassRecoKF_mvd->Fill(params.fMinv);
1203  }
1204  if (GammasZ[gamma1] > 21 && GammasZ[gamma1] < 75 && GammasZ[gamma2] > 21
1205  && GammasZ[gamma2] < 75) {
1206  Pi0InvMassRecoKF_sts->Fill(params.fMinv);
1207  }
1208  if (GammasZ[gamma1] > 4 && GammasZ[gamma2] > 4) {
1209  Pi0InvMassRecoKF_outside->Fill(params.fMinv);
1210  }
1211 
1212  fAnaBG->Exec(
1213  mcTrack1, mcTrack2, mcTrack3, mcTrack4, params.fMinv, BGCases);
1214 
1215  // fill histos with rapidity and Pt for correctly reconstructed pi0(dalitz) and pi0(g+g)
1216  if (nullptr == mcTrack1 || nullptr == mcTrack2 || nullptr == mcTrack3
1217  || nullptr == mcTrack4)
1218  continue;
1219  if (TMath::Abs(mcTrack1->GetPdgCode()) != 11
1220  || TMath::Abs(mcTrack2->GetPdgCode()) != 11
1221  || TMath::Abs(mcTrack3->GetPdgCode()) != 11
1222  || TMath::Abs(mcTrack4->GetPdgCode()) != 11)
1223  continue;
1224  if (mcTrack1->GetPdgCode() + mcTrack2->GetPdgCode() != 0) continue;
1225  if (mcTrack3->GetPdgCode() + mcTrack4->GetPdgCode() != 0) continue;
1226  int motherId1 = mcTrack1->GetMotherId();
1227  int motherId2 = mcTrack2->GetMotherId();
1228  int motherId3 = mcTrack3->GetMotherId();
1229  int motherId4 = mcTrack4->GetMotherId();
1230  if (motherId1 == -1 || motherId2 == -1 || motherId3 == -1
1231  || motherId4 == -1)
1232  continue;
1233  if (motherId1 != motherId2 || motherId3 != motherId4) continue;
1234  CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(motherId1);
1235  CbmMCTrack* mother2 = (CbmMCTrack*) fMcTracks->At(motherId2);
1236  CbmMCTrack* mother3 = (CbmMCTrack*) fMcTracks->At(motherId3);
1237  CbmMCTrack* mother4 = (CbmMCTrack*) fMcTracks->At(motherId4);
1238  if (nullptr == mother1 || nullptr == mother2 || nullptr == mother3
1239  || nullptr == mother4)
1240  continue;
1241  int mcMotherPdg1 = mother1->GetPdgCode();
1242  int mcMotherPdg2 = mother2->GetPdgCode();
1243  int mcMotherPdg3 = mother3->GetPdgCode();
1244  int mcMotherPdg4 = mother4->GetPdgCode();
1245  int grandmotherId1 = mother1->GetMotherId();
1246  int grandmotherId2 = mother2->GetMotherId();
1247  int grandmotherId3 = mother3->GetMotherId();
1248  int grandmotherId4 = mother4->GetMotherId();
1249 
1250  if (mcMotherPdg1 == 22 && mcMotherPdg2 == 22 && mcMotherPdg3 == 111
1251  && mcMotherPdg4 == 111) {
1252  if (grandmotherId1 != motherId3) continue;
1253  Pi0_pt_vs_rap->Fill(params.fRapidity, params.fPt);
1254  Pi0_pt_vs_rap_est->Fill(params.fRapidity, params.fPt);
1255  }
1256 
1257  if (mcMotherPdg1 == 111 && mcMotherPdg2 == 111 && mcMotherPdg3 == 22
1258  && mcMotherPdg4 == 22) {
1259  if (grandmotherId3 != motherId1) continue;
1260  Pi0_pt_vs_rap->Fill(params.fRapidity, params.fPt);
1261  Pi0_pt_vs_rap_est->Fill(params.fRapidity, params.fPt);
1262  }
1263 
1264  if (mcMotherPdg1 == 22 && mcMotherPdg2 == 22 && mcMotherPdg3 == 22
1265  && mcMotherPdg4 == 22) {
1266  if (grandmotherId1 != grandmotherId2 || grandmotherId3 != grandmotherId4
1267  || grandmotherId1 != grandmotherId3)
1268  continue;
1269  if (grandmotherId1 == -1) continue;
1270  CbmMCTrack* grandmother1 = (CbmMCTrack*) fMcTracks->At(grandmotherId1);
1271  if (nullptr == grandmother1) continue;
1272  int mcGrandMotherPdg1 = grandmother1->GetPdgCode();
1273  if (mcGrandMotherPdg1 != 111) continue;
1274  Pi0_pt_vs_rap->Fill(params.fRapidity, params.fPt);
1275  Pi0_pt_vs_rap_est->Fill(params.fRapidity, params.fPt);
1276  }
1277  }
1278  }
1279 }
1280 
1281 
1282 int CbmKresConversionKF::CheckIfElectron(CbmRichRing* ring, double momentum) {
1283  int identified = 0;
1284 
1285  if (nullptr != ring) {
1286  CbmRichRingLight ringHit;
1287  int nofHits = ring->GetNofHits();
1288  for (int i = 0; i < nofHits; i++) {
1289  Int_t hitInd = ring->GetHit(i);
1290  CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
1291  if (nullptr == hit) continue;
1292  CbmRichHitLight hl(hit->GetX(), hit->GetY());
1293  ringHit.AddHit(hl);
1294  }
1295  fTauFit->DoFit(&ringHit);
1296  if (ringHit.GetAaxis() > 4 && ringHit.GetAaxis() < 6
1297  && ringHit.GetBaxis() > 4 && ringHit.GetBaxis() < 6 && momentum > 0.2
1298  && momentum < 4.)
1299  identified++;
1300  //if (ring->GetDistance() < 2 && ringHit.GetAaxis() > 4 && ringHit.GetAaxis() < 6 && ringHit.GetBaxis() > 4 && ringHit.GetBaxis() < 6 && momentum > 0.2 && momentum < 4.) identified ++;
1301  }
1302 
1303  return identified;
1304 }
1305 
1306 
1307 void CbmKresConversionKF::MixedEvent()
1308 // combines photons from two different events, taken from each time N events
1309 {
1310  Int_t nof = EMT_Event.size();
1311  cout << "MixedEvent CbmKresConversionKF - nof entries " << nof << endl;
1312  for (Int_t a = 0; a < nof - 1; a++) {
1313  for (Int_t b = a + 1; b < nof; b++) {
1314  if (EMT_Event[a] == EMT_Event[b])
1315  continue; // to make sure that the photons are from two different events
1316  TVector3 e11 = EMT_pair_momenta[a][0];
1317  TVector3 e12 = EMT_pair_momenta[a][1];
1318  TVector3 e21 = EMT_pair_momenta[b][0];
1319  TVector3 e22 = EMT_pair_momenta[b][1];
1320  CbmLmvmKinematicParams params =
1321  CbmKresFunctions::CalculateKinematicParams_4particles(
1322  e11, e12, e21, e22);
1323 
1324  fEMT_InvMass_All->Fill(params.fMinv);
1325  if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0)
1326  fEMT_InvMass_Zero->Fill(params.fMinv);
1327  if (EMT_NofRings[a] == 1 && EMT_NofRings[b] == 1)
1328  fEMT_InvMass_One->Fill(params.fMinv);
1329  if (EMT_NofRings[a] == 2 && EMT_NofRings[b] == 2)
1330  fEMT_InvMass_Two->Fill(params.fMinv);
1331  if ((EMT_NofRings[a] == 1 || EMT_NofRings[a] == 2)
1332  && (EMT_NofRings[b] == 1 || EMT_NofRings[b] == 2))
1333  fEMT_InvMass_OneTwo->Fill(params.fMinv);
1334 
1335  // for inside the targte and outside the target
1336  if (EMT_Z[a] < 4 && EMT_Z[b] < 4) {
1337  fEMT_InvMass_All_target->Fill(params.fMinv);
1338  if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0)
1339  fEMT_InvMass_Zero_target->Fill(params.fMinv);
1340  if (EMT_NofRings[a] == 1 && EMT_NofRings[b] == 1)
1341  fEMT_InvMass_One_target->Fill(params.fMinv);
1342  if (EMT_NofRings[a] == 2 && EMT_NofRings[b] == 2)
1343  fEMT_InvMass_Two_target->Fill(params.fMinv);
1344  if ((EMT_NofRings[a] == 1 || EMT_NofRings[a] == 2)
1345  && (EMT_NofRings[b] == 1 || EMT_NofRings[b] == 2))
1346  fEMT_InvMass_OneTwo_target->Fill(params.fMinv);
1347  }
1348  if (EMT_Z[a] > 4 && EMT_Z[b] > 4) {
1349  fEMT_InvMass_All_outside->Fill(params.fMinv);
1350  if (EMT_NofRings[a] == 0 && EMT_NofRings[b] == 0)
1351  fEMT_InvMass_Zero_outside->Fill(params.fMinv);
1352  if (EMT_NofRings[a] == 1 && EMT_NofRings[b] == 1)
1353  fEMT_InvMass_One_outside->Fill(params.fMinv);
1354  if (EMT_NofRings[a] == 2 && EMT_NofRings[b] == 2)
1355  fEMT_InvMass_Two_outside->Fill(params.fMinv);
1356  if ((EMT_NofRings[a] == 1 || EMT_NofRings[a] == 2)
1357  && (EMT_NofRings[b] == 1 || EMT_NofRings[b] == 2))
1358  fEMT_InvMass_OneTwo_outside->Fill(params.fMinv);
1359  }
1360  }
1361  }
1362 }
1363 
1364 
1365 void CbmKresConversionKF::MixedEventMulti()
1366 // combines photons from two different events, taken from each time N events
1367 {
1368  // all
1369  Int_t nof_all = EMT_Event_multi_all.size();
1370  cout << "MixedEventMulti CbmKresConversionKF - nof entries all " << nof_all
1371  << endl;
1372  for (Int_t a = 0; a < nof_all - 1; a++) {
1373  for (Int_t b = a + 1; b < nof_all; b++) {
1374  if (EMT_Event_multi_all[a] == EMT_Event_multi_all[b])
1375  continue; // to make sure that the photons are from two different events
1376  if (EMT_multi_all[a] != EMT_multi_all[b])
1377  continue; // check same multiplicity
1378  TVector3 e11 = EMT_pair_momenta_multi_all[a][0];
1379  TVector3 e12 = EMT_pair_momenta_multi_all[a][1];
1380  TVector3 e21 = EMT_pair_momenta_multi_all[b][0];
1381  TVector3 e22 = EMT_pair_momenta_multi_all[b][1];
1382  CbmLmvmKinematicParams params =
1383  CbmKresFunctions::CalculateKinematicParams_4particles(
1384  e11, e12, e21, e22);
1385 
1386  if (EMT_multi_all[a] == 1) EMTMulti_InvMass_All_m1->Fill(params.fMinv);
1387  if (EMT_multi_all[a] == 2) EMTMulti_InvMass_All_m2->Fill(params.fMinv);
1388  if (EMT_multi_all[a] == 3) EMTMulti_InvMass_All_m3->Fill(params.fMinv);
1389  if (EMT_multi_all[a] == 4) EMTMulti_InvMass_All_m4->Fill(params.fMinv);
1390  if (EMT_multi_all[a] == 5) EMTMulti_InvMass_All_m5->Fill(params.fMinv);
1391  if (EMT_multi_all[a] == 6) EMTMulti_InvMass_All_m6->Fill(params.fMinv);
1392  if (EMT_multi_all[a] == 7) EMTMulti_InvMass_All_m7->Fill(params.fMinv);
1393  }
1394  }
1395 
1396  // zero
1397  Int_t nof_zero = EMT_Event_multi_zero.size();
1398  cout << "MixedEvent - nof entries zero " << nof_zero << endl;
1399  for (Int_t a = 0; a < nof_zero - 1; a++) {
1400  for (Int_t b = a + 1; b < nof_zero; b++) {
1401  if (EMT_Event_multi_zero[a] == EMT_Event_multi_zero[b])
1402  continue; // to make sure that the photons are from two different events
1403  if (EMT_multi_zero[a] != EMT_multi_zero[b])
1404  continue; // check same multiplicity
1405  TVector3 e11 = EMT_pair_momenta_multi_zero[a][0];
1406  TVector3 e12 = EMT_pair_momenta_multi_zero[a][1];
1407  TVector3 e21 = EMT_pair_momenta_multi_zero[b][0];
1408  TVector3 e22 = EMT_pair_momenta_multi_zero[b][1];
1409  CbmLmvmKinematicParams params =
1410  CbmKresFunctions::CalculateKinematicParams_4particles(
1411  e11, e12, e21, e22);
1412 
1413  if (EMT_multi_zero[a] == 1) EMTMulti_InvMass_Zero_m1->Fill(params.fMinv);
1414  if (EMT_multi_zero[a] == 2) EMTMulti_InvMass_Zero_m2->Fill(params.fMinv);
1415  if (EMT_multi_zero[a] == 3) EMTMulti_InvMass_Zero_m3->Fill(params.fMinv);
1416  if (EMT_multi_zero[a] == 4) EMTMulti_InvMass_Zero_m4->Fill(params.fMinv);
1417  if (EMT_multi_zero[a] == 5) EMTMulti_InvMass_Zero_m5->Fill(params.fMinv);
1418  if (EMT_multi_zero[a] == 6) EMTMulti_InvMass_Zero_m6->Fill(params.fMinv);
1419  if (EMT_multi_zero[a] == 7) EMTMulti_InvMass_Zero_m7->Fill(params.fMinv);
1420  }
1421  }
1422 
1423  // one
1424  Int_t nof_one = EMT_Event_multi_one.size();
1425  cout << "MixedEvent - nof entries one " << nof_one << endl;
1426  for (Int_t a = 0; a < nof_one - 1; a++) {
1427  for (Int_t b = a + 1; b < nof_one; b++) {
1428  if (EMT_Event_multi_one[a] == EMT_Event_multi_one[b])
1429  continue; // to make sure that the photons are from two different events
1430  if (EMT_multi_one[a] != EMT_multi_one[b])
1431  continue; // check same multiplicity
1432  TVector3 e11 = EMT_pair_momenta_multi_one[a][0];
1433  TVector3 e12 = EMT_pair_momenta_multi_one[a][1];
1434  TVector3 e21 = EMT_pair_momenta_multi_one[b][0];
1435  TVector3 e22 = EMT_pair_momenta_multi_one[b][1];
1436  CbmLmvmKinematicParams params =
1437  CbmKresFunctions::CalculateKinematicParams_4particles(
1438  e11, e12, e21, e22);
1439 
1440  if (EMT_multi_one[a] == 1) EMTMulti_InvMass_One_m1->Fill(params.fMinv);
1441  if (EMT_multi_one[a] == 2) EMTMulti_InvMass_One_m2->Fill(params.fMinv);
1442  if (EMT_multi_one[a] == 3) EMTMulti_InvMass_One_m3->Fill(params.fMinv);
1443  if (EMT_multi_one[a] == 4) EMTMulti_InvMass_One_m4->Fill(params.fMinv);
1444  if (EMT_multi_one[a] == 5) EMTMulti_InvMass_One_m5->Fill(params.fMinv);
1445  if (EMT_multi_one[a] == 6) EMTMulti_InvMass_One_m6->Fill(params.fMinv);
1446  if (EMT_multi_one[a] == 7) EMTMulti_InvMass_One_m7->Fill(params.fMinv);
1447  }
1448  }
1449 
1450  // two
1451  Int_t nof_two = EMT_Event_multi_two.size();
1452  cout << "MixedEvent - nof entries two " << nof_two << endl;
1453  for (Int_t a = 0; a < nof_two - 1; a++) {
1454  for (Int_t b = a + 1; b < nof_two; b++) {
1455  if (EMT_Event_multi_two[a] == EMT_Event_multi_two[b])
1456  continue; // to make sure that the photons are from two different events
1457  if (EMT_multi_two[a] != EMT_multi_two[b])
1458  continue; // check same multiplicity
1459  TVector3 e11 = EMT_pair_momenta_multi_two[a][0];
1460  TVector3 e12 = EMT_pair_momenta_multi_two[a][1];
1461  TVector3 e21 = EMT_pair_momenta_multi_two[b][0];
1462  TVector3 e22 = EMT_pair_momenta_multi_two[b][1];
1463  CbmLmvmKinematicParams params =
1464  CbmKresFunctions::CalculateKinematicParams_4particles(
1465  e11, e12, e21, e22);
1466 
1467  if (EMT_multi_two[a] == 1) EMTMulti_InvMass_Two_m1->Fill(params.fMinv);
1468  if (EMT_multi_two[a] == 2) EMTMulti_InvMass_Two_m2->Fill(params.fMinv);
1469  if (EMT_multi_two[a] == 3) EMTMulti_InvMass_Two_m3->Fill(params.fMinv);
1470  if (EMT_multi_two[a] == 4) EMTMulti_InvMass_Two_m4->Fill(params.fMinv);
1471  if (EMT_multi_two[a] == 5) EMTMulti_InvMass_Two_m5->Fill(params.fMinv);
1472  if (EMT_multi_two[a] == 6) EMTMulti_InvMass_Two_m6->Fill(params.fMinv);
1473  if (EMT_multi_two[a] == 7) EMTMulti_InvMass_Two_m7->Fill(params.fMinv);
1474  }
1475  }
1476 
1477  // onetwo
1478  Int_t nof_onetwo = EMT_Event_multi_onetwo.size();
1479  cout << "MixedEvent - nof entries onetwo " << nof_onetwo << endl;
1480  for (Int_t a = 0; a < nof_onetwo - 1; a++) {
1481  for (Int_t b = a + 1; b < nof_onetwo; b++) {
1482  if (EMT_Event_multi_onetwo[a] == EMT_Event_multi_onetwo[b])
1483  continue; // to make sure that the photons are from two different events
1484  if (EMT_multi_onetwo[a] != EMT_multi_onetwo[b])
1485  continue; // check same multiplicity
1486  TVector3 e11 = EMT_pair_momenta_multi_onetwo[a][0];
1487  TVector3 e12 = EMT_pair_momenta_multi_onetwo[a][1];
1488  TVector3 e21 = EMT_pair_momenta_multi_onetwo[b][0];
1489  TVector3 e22 = EMT_pair_momenta_multi_onetwo[b][1];
1490  CbmLmvmKinematicParams params =
1491  CbmKresFunctions::CalculateKinematicParams_4particles(
1492  e11, e12, e21, e22);
1493 
1494  if (EMT_multi_onetwo[a] == 1)
1495  EMTMulti_InvMass_OneTwo_m1->Fill(params.fMinv);
1496  if (EMT_multi_onetwo[a] == 2)
1497  EMTMulti_InvMass_OneTwo_m2->Fill(params.fMinv);
1498  if (EMT_multi_onetwo[a] == 3)
1499  EMTMulti_InvMass_OneTwo_m3->Fill(params.fMinv);
1500  if (EMT_multi_onetwo[a] == 4)
1501  EMTMulti_InvMass_OneTwo_m4->Fill(params.fMinv);
1502  if (EMT_multi_onetwo[a] == 5)
1503  EMTMulti_InvMass_OneTwo_m5->Fill(params.fMinv);
1504  if (EMT_multi_onetwo[a] == 6)
1505  EMTMulti_InvMass_OneTwo_m6->Fill(params.fMinv);
1506  if (EMT_multi_onetwo[a] == 7)
1507  EMTMulti_InvMass_OneTwo_m7->Fill(params.fMinv);
1508  }
1509  }
1510 }
1511 
1512 
1513 void CbmKresConversionKF::Finish() {
1514  gDirectory->mkdir("KF");
1515  gDirectory->cd("KF");
1516 
1517 
1518  gDirectory->mkdir("CheckCuts");
1519  gDirectory->cd("CheckCuts");
1520  for (UInt_t i = 0; i < fHistoList_CheckForCuts.size(); i++) {
1521  fHistoList_CheckForCuts[i]->Write();
1522  }
1523  gDirectory->cd("..");
1524 
1525 
1526  gDirectory->mkdir("multiplicity");
1527  gDirectory->cd("multiplicity");
1528  gDirectory->mkdir("All");
1529  gDirectory->cd("All");
1530  for (UInt_t i = 0; i < fHistoList_multiplicity_All.size(); i++) {
1531  fHistoList_multiplicity_All[i]->Write();
1532  }
1533  gDirectory->cd("..");
1534  gDirectory->mkdir("Zero");
1535  gDirectory->cd("Zero");
1536  for (UInt_t i = 0; i < fHistoList_multiplicity_Zero.size(); i++) {
1537  fHistoList_multiplicity_Zero[i]->Write();
1538  }
1539  gDirectory->cd("..");
1540  gDirectory->mkdir("One");
1541  gDirectory->cd("One");
1542  for (UInt_t i = 0; i < fHistoList_multiplicity_One.size(); i++) {
1543  fHistoList_multiplicity_One[i]->Write();
1544  }
1545  gDirectory->cd("..");
1546  gDirectory->mkdir("Two");
1547  gDirectory->cd("Two");
1548  for (UInt_t i = 0; i < fHistoList_multiplicity_Two.size(); i++) {
1549  fHistoList_multiplicity_Two[i]->Write();
1550  }
1551  gDirectory->cd("..");
1552  gDirectory->mkdir("OneTwo");
1553  gDirectory->cd("OneTwo");
1554  for (UInt_t i = 0; i < fHistoList_multiplicity_OneTwo.size(); i++) {
1555  fHistoList_multiplicity_OneTwo[i]->Write();
1556  }
1557  gDirectory->cd("..");
1558  for (UInt_t i = 0; i < fHistoList_multiplicity.size(); i++) {
1559  fHistoList_multiplicity[i]->Write();
1560  }
1561  gDirectory->cd("..");
1562 
1563 
1564  gDirectory->mkdir("BG");
1565  gDirectory->cd("BG");
1566  gDirectory->mkdir("BG_all");
1567  gDirectory->cd("BG_all");
1568  for (UInt_t i = 0; i < fHistoList_bg_all.size(); i++) {
1569  fHistoList_bg_all[i]->Write();
1570  }
1571  gDirectory->cd("..");
1572  gDirectory->mkdir("BG_zero");
1573  gDirectory->cd("BG_zero");
1574  for (UInt_t i = 0; i < fHistoList_bg_zero.size(); i++) {
1575  fHistoList_bg_zero[i]->Write();
1576  }
1577  gDirectory->cd("..");
1578  gDirectory->mkdir("BG_one");
1579  gDirectory->cd("BG_one");
1580  for (UInt_t i = 0; i < fHistoList_bg_one.size(); i++) {
1581  fHistoList_bg_one[i]->Write();
1582  }
1583  gDirectory->cd("..");
1584  gDirectory->mkdir("BG_two");
1585  gDirectory->cd("BG_two");
1586  for (UInt_t i = 0; i < fHistoList_bg_two.size(); i++) {
1587  fHistoList_bg_two[i]->Write();
1588  }
1589  gDirectory->cd("..");
1590  gDirectory->mkdir("BG_onetwo");
1591  gDirectory->cd("BG_onetwo");
1592  for (UInt_t i = 0; i < fHistoList_bg_onetwo.size(); i++) {
1593  fHistoList_bg_onetwo[i]->Write();
1594  }
1595  gDirectory->cd("..");
1596  gDirectory->cd("..");
1597 
1598 
1599  gDirectory->mkdir("g->All");
1600  gDirectory->cd("g->All");
1601  gDirectory->mkdir("target(<4cm)");
1602  gDirectory->cd("target(<4cm)");
1603  for (UInt_t i = 0; i < fHistoList_All_target.size(); i++) {
1604  fHistoList_All_target[i]->Write();
1605  }
1606  gDirectory->cd("..");
1607  gDirectory->mkdir("mvd(4cm-21cm)");
1608  gDirectory->cd("mvd(4cm-21cm)");
1609  for (UInt_t i = 0; i < fHistoList_All_mvd.size(); i++) {
1610  fHistoList_All_mvd[i]->Write();
1611  }
1612  gDirectory->cd("..");
1613  gDirectory->mkdir("sts(21cm-75cm)");
1614  gDirectory->cd("sts(21cm-75cm)");
1615  for (UInt_t i = 0; i < fHistoList_All_sts.size(); i++) {
1616  fHistoList_All_sts[i]->Write();
1617  }
1618  gDirectory->cd("..");
1619  gDirectory->mkdir("outside the target(>4cm)");
1620  gDirectory->cd("outside the target(>4cm)");
1621  for (UInt_t i = 0; i < fHistoList_All_outside.size(); i++) {
1622  fHistoList_All_outside[i]->Write();
1623  }
1624  gDirectory->cd("..");
1625  for (UInt_t i = 0; i < fHistoList_All.size(); i++) {
1626  fHistoList_All[i]->Write();
1627  }
1628  gDirectory->cd("..");
1629 
1630 
1631  gDirectory->mkdir("g->Zero");
1632  gDirectory->cd("g->Zero");
1633  gDirectory->mkdir("target(<4cm)");
1634  gDirectory->cd("target(<4cm)");
1635  for (UInt_t i = 0; i < fHistoList_Zero_target.size(); i++) {
1636  fHistoList_Zero_target[i]->Write();
1637  }
1638  gDirectory->cd("..");
1639  gDirectory->mkdir("mvd(4cm-21cm)");
1640  gDirectory->cd("mvd(4cm-21cm)");
1641  for (UInt_t i = 0; i < fHistoList_Zero_mvd.size(); i++) {
1642  fHistoList_Zero_mvd[i]->Write();
1643  }
1644  gDirectory->cd("..");
1645  gDirectory->mkdir("sts(21cm-75cm)");
1646  gDirectory->cd("sts(21cm-75cm)");
1647  for (UInt_t i = 0; i < fHistoList_Zero_sts.size(); i++) {
1648  fHistoList_Zero_sts[i]->Write();
1649  }
1650  gDirectory->cd("..");
1651  gDirectory->mkdir("outside the target(>4cm)");
1652  gDirectory->cd("outside the target(>4cm)");
1653  for (UInt_t i = 0; i < fHistoList_Zero_outside.size(); i++) {
1654  fHistoList_Zero_outside[i]->Write();
1655  }
1656  gDirectory->cd("..");
1657  for (UInt_t i = 0; i < fHistoList_Zero.size(); i++) {
1658  fHistoList_Zero[i]->Write();
1659  }
1660  gDirectory->cd("..");
1661 
1662 
1663  gDirectory->mkdir("g->One");
1664  gDirectory->cd("g->One");
1665  gDirectory->mkdir("target(<4cm)");
1666  gDirectory->cd("target(<4cm)");
1667  for (UInt_t i = 0; i < fHistoList_One_target.size(); i++) {
1668  fHistoList_One_target[i]->Write();
1669  }
1670  gDirectory->cd("..");
1671  gDirectory->mkdir("mvd(4cm-21cm)");
1672  gDirectory->cd("mvd(4cm-21cm)");
1673  for (UInt_t i = 0; i < fHistoList_One_mvd.size(); i++) {
1674  fHistoList_One_mvd[i]->Write();
1675  }
1676  gDirectory->cd("..");
1677  gDirectory->mkdir("sts(21cm-75cm)");
1678  gDirectory->cd("sts(21cm-75cm)");
1679  for (UInt_t i = 0; i < fHistoList_One_sts.size(); i++) {
1680  fHistoList_One_sts[i]->Write();
1681  }
1682  gDirectory->cd("..");
1683  gDirectory->mkdir("outside the target(>4cm)");
1684  gDirectory->cd("outside the target(>4cm)");
1685  for (UInt_t i = 0; i < fHistoList_One_outside.size(); i++) {
1686  fHistoList_One_outside[i]->Write();
1687  }
1688  gDirectory->cd("..");
1689  for (UInt_t i = 0; i < fHistoList_One.size(); i++) {
1690  fHistoList_One[i]->Write();
1691  }
1692  gDirectory->cd("..");
1693 
1694 
1695  gDirectory->mkdir("g->Two");
1696  gDirectory->cd("g->Two");
1697  gDirectory->mkdir("target(<4cm)");
1698  gDirectory->cd("target(<4cm)");
1699  for (UInt_t i = 0; i < fHistoList_Two_target.size(); i++) {
1700  fHistoList_Two_target[i]->Write();
1701  }
1702  gDirectory->cd("..");
1703  gDirectory->mkdir("mvd(4cm-21cm)");
1704  gDirectory->cd("mvd(4cm-21cm)");
1705  for (UInt_t i = 0; i < fHistoList_Two_mvd.size(); i++) {
1706  fHistoList_Two_mvd[i]->Write();
1707  }
1708  gDirectory->cd("..");
1709  gDirectory->mkdir("sts(21cm-75cm)");
1710  gDirectory->cd("sts(21cm-75cm)");
1711  for (UInt_t i = 0; i < fHistoList_Two_sts.size(); i++) {
1712  fHistoList_Two_sts[i]->Write();
1713  }
1714  gDirectory->cd("..");
1715  gDirectory->mkdir("outside the target(>4cm)");
1716  gDirectory->cd("outside the target(>4cm)");
1717  for (UInt_t i = 0; i < fHistoList_Two_outside.size(); i++) {
1718  fHistoList_Two_outside[i]->Write();
1719  }
1720  gDirectory->cd("..");
1721  for (UInt_t i = 0; i < fHistoList_Two.size(); i++) {
1722  fHistoList_Two[i]->Write();
1723  }
1724  gDirectory->cd("..");
1725 
1726 
1727  gDirectory->mkdir("g->OneTwo");
1728  gDirectory->cd("g->OneTwo");
1729  gDirectory->mkdir("target(<4cm)");
1730  gDirectory->cd("target(<4cm)");
1731  for (UInt_t i = 0; i < fHistoList_OneTwo_target.size(); i++) {
1732  fHistoList_OneTwo_target[i]->Write();
1733  }
1734  gDirectory->cd("..");
1735  gDirectory->mkdir("mvd(4cm-21cm)");
1736  gDirectory->cd("mvd(4cm-21cm)");
1737  for (UInt_t i = 0; i < fHistoList_OneTwo_mvd.size(); i++) {
1738  fHistoList_OneTwo_mvd[i]->Write();
1739  }
1740  gDirectory->cd("..");
1741  gDirectory->mkdir("sts(21cm-75cm)");
1742  gDirectory->cd("sts(21cm-75cm)");
1743  for (UInt_t i = 0; i < fHistoList_OneTwo_sts.size(); i++) {
1744  fHistoList_OneTwo_sts[i]->Write();
1745  }
1746  gDirectory->cd("..");
1747  gDirectory->mkdir("outside the target(>4cm)");
1748  gDirectory->cd("outside the target(>4cm)");
1749  for (UInt_t i = 0; i < fHistoList_OneTwo_outside.size(); i++) {
1750  fHistoList_OneTwo_outside[i]->Write();
1751  }
1752  gDirectory->cd("..");
1753  for (UInt_t i = 0; i < fHistoList_OneTwo.size(); i++) {
1754  fHistoList_OneTwo[i]->Write();
1755  }
1756  gDirectory->cd("..");
1757 
1758 
1759  gDirectory->cd("..");
1760 }
1761 
1762 void CbmKresConversionKF::InitHistograms() {
1764  CheckForCuts_InvMass_MC =
1765  new TH1D("CheckForCuts_InvMass_MC",
1766  "CheckForCuts_InvMass_MC; invariant mass in GeV/c^{2};#",
1767  510,
1768  -0.01,
1769  0.5);
1770  fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_MC);
1771  CheckForCuts_InvMass_Reco =
1772  new TH1D("CheckForCuts_InvMass_Reco",
1773  "CheckForCuts_InvMass_Reco; invariant mass in GeV/c^{2};#",
1774  510,
1775  -0.01,
1776  0.5);
1777  fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco);
1778  CheckForCuts_OA_MC = new TH1D("CheckForCuts_OA_MC",
1779  "CheckForCuts_OA_MC; #theta angle [deg];#",
1780  300,
1781  -0.1,
1782  29.9);
1783  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_MC);
1784  CheckForCuts_OA_Reco = new TH1D("CheckForCuts_OA_Reco",
1785  "CheckForCuts_OA_Reco; #theta angle [deg];#",
1786  300,
1787  -0.1,
1788  29.9);
1789  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco);
1790  CheckForCuts_InvMass_MC_from_one_pi0 = new TH1D(
1791  "CheckForCuts_InvMass_MC_from_one_pi0",
1792  "CheckForCuts_InvMass_MC_from_one_pi0; invariant mass in GeV/c^{2};#",
1793  510,
1794  -0.01,
1795  0.5);
1796  fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_MC_from_one_pi0);
1797  CheckForCuts_InvMass_Reco_from_one_pi0 = new TH1D(
1798  "CheckForCuts_InvMass_Reco_from_one_pi0",
1799  "CheckForCuts_InvMass_Reco_from_one_pi0; invariant mass in GeV/c^{2};#",
1800  510,
1801  -0.01,
1802  0.5);
1803  fHistoList_CheckForCuts.push_back(CheckForCuts_InvMass_Reco_from_one_pi0);
1804  CheckForCuts_OA_MC_from_one_pi0 =
1805  new TH1D("CheckForCuts_OA_MC_from_one_pi0",
1806  "CheckForCuts_OA_MC_from_one_pi0; angle [deg];#",
1807  300,
1808  -0.1,
1809  29.9);
1810  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_MC_from_one_pi0);
1811  CheckForCuts_OA_Reco_from_one_pi0 =
1812  new TH1D("CheckForCuts_OA_Reco_from_one_pi0",
1813  "CheckForCuts_OA_Reco_from_one_pi0; angle [deg];#",
1814  300,
1815  -0.1,
1816  29.9);
1817  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0);
1818  CheckForCuts_z_vs_InvMass_MC_from_one_pi0 =
1819  new TH2D("CheckForCuts_z_vs_InvMass_MC_from_one_pi0",
1820  "CheckForCuts_z_vs_InvMass_MC_from_one_pi0; Z [cm]; invariant "
1821  "mass in GeV/c^{2}; Nof",
1822  1000,
1823  -1,
1824  99,
1825  310,
1826  -0.01,
1827  0.3);
1828  fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_InvMass_MC_from_one_pi0);
1829  CheckForCuts_z_vs_InvMass_Reco_from_one_pi0 =
1830  new TH2D("CheckForCuts_z_vs_InvMass_Reco_from_one_pi0",
1831  "CheckForCuts_z_vs_InvMass_Reco_from_one_pi0; Z [cm]; invariant "
1832  "mass in GeV/c^{2}; Nof",
1833  1000,
1834  -1,
1835  99,
1836  310,
1837  -0.01,
1838  0.3);
1839  fHistoList_CheckForCuts.push_back(
1840  CheckForCuts_z_vs_InvMass_Reco_from_one_pi0);
1841  CheckForCuts_z_vs_OA_MC_from_one_pi0 =
1842  new TH2D("CheckForCuts_z_vs_OA_MC_from_one_pi0",
1843  "CheckForCuts_z_vs_OA_MC_from_one_pi0; Z [cm]; #theta in deg; Nof",
1844  1000,
1845  -1,
1846  99,
1847  300,
1848  -0.1,
1849  29.9);
1850  fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_OA_MC_from_one_pi0);
1851  CheckForCuts_z_vs_OA_Reco_from_one_pi0 = new TH2D(
1852  "CheckForCuts_z_vs_OA_Reco_from_one_pi0",
1853  "CheckForCuts_z_vs_OA_Reco_from_one_pi0; Z [cm]; #theta in deg; Nof",
1854  1000,
1855  -1,
1856  99,
1857  300,
1858  -0.1,
1859  29.9);
1860  fHistoList_CheckForCuts.push_back(CheckForCuts_z_vs_OA_Reco_from_one_pi0);
1861  CheckForCuts_InvMass_Reco_from_one_pi0_less4cm =
1862  new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0_less4cm",
1863  "CheckForCuts_InvMass_Reco_from_one_pi0_less4cm; invariant mass "
1864  "in GeV/c^{2};#",
1865  310,
1866  -0.01,
1867  0.3);
1868  fHistoList_CheckForCuts.push_back(
1869  CheckForCuts_InvMass_Reco_from_one_pi0_less4cm);
1870  CheckForCuts_OA_Reco_from_one_pi0_less4cm =
1871  new TH1D("CheckForCuts_OA_Reco_from_one_pi0_less4cm",
1872  "CheckForCuts_OA_Reco_from_one_pi0_less4cm; angle [deg];#",
1873  300,
1874  -0.1,
1875  29.9);
1876  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0_less4cm);
1877  CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm =
1878  new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm",
1879  "CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm; invariant mass "
1880  "in GeV/c^{2};#",
1881  310,
1882  -0.01,
1883  0.3);
1884  fHistoList_CheckForCuts.push_back(
1885  CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm);
1886  CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm =
1887  new TH1D("CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm",
1888  "CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm; angle [deg];#",
1889  300,
1890  -0.1,
1891  29.9);
1892  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm);
1893  CheckForCuts_InvMass_Reco_from_one_pi0_more21cm =
1894  new TH1D("CheckForCuts_InvMass_Reco_from_one_pi0_more21cm",
1895  "CheckForCuts_InvMass_Reco_from_one_pi0_more21cm; invariant mass "
1896  "in GeV/c^{2};#",
1897  310,
1898  -0.01,
1899  0.3);
1900  fHistoList_CheckForCuts.push_back(
1901  CheckForCuts_InvMass_Reco_from_one_pi0_more21cm);
1902  CheckForCuts_OA_Reco_from_one_pi0_more21cm =
1903  new TH1D("CheckForCuts_OA_Reco_from_one_pi0_more21cm",
1904  "CheckForCuts_OA_Reco_from_one_pi0_more21cm; angle [deg];#",
1905  300,
1906  -0.1,
1907  29.9);
1908  fHistoList_CheckForCuts.push_back(CheckForCuts_OA_Reco_from_one_pi0_more21cm);
1909 
1910 
1911  // 0-2 => All
1912  fGammaInvMassReco_All =
1913  new TH1D("fGammaInvMassReco_All",
1914  "fGammaInvMassReco_All; invariant mass in GeV/c^{2};#",
1915  110,
1916  -0.01,
1917  0.1);
1918  fHistoList_All.push_back(fGammaInvMassReco_All);
1919  fGammaOpeningAngleReco_All =
1920  new TH1D("fGammaOpeningAngleReco_All",
1921  "fGammaOpeningAngleReco_All; angle [deg];#",
1922  200,
1923  -0.1,
1924  19.9);
1925  fHistoList_All.push_back(fGammaOpeningAngleReco_All);
1926  fPdg_All = new TH1D("fPdg_All", "fPdg_All; Id ;#", 800, 0, 400);
1927  fHistoList_All.push_back(fPdg_All);
1928  fP_reco_All =
1929  new TH1D("fP_reco_All", "fP_reco_All; P in GeV/c^{2} ;#", 600, 0, 6);
1930  fHistoList_All.push_back(fP_reco_All);
1931  fPt_reco_All =
1932  new TH1D("fPt_reco_All", "fPt_reco_All; Pt in GeV/c^{2} ;#", 300, 0, 3);
1933  fHistoList_All.push_back(fPt_reco_All);
1934  fPi0InvMassRecoKF_All =
1935  new TH1D("fPi0InvMassRecoKF_All",
1936  "fPi0InvMassRecoKF_All; invariant mass in GeV/c^{2};#",
1937  1000,
1938  0,
1939  2.0);
1940  fHistoList_All.push_back(fPi0InvMassRecoKF_All);
1941  fEMT_InvMass_All = new TH1D("fEMT_InvMass_All",
1942  "fEMT_InvMass_All; invariant mass in GeV/c^{2};#",
1943  1000,
1944  0,
1945  2.0);
1946  fHistoList_All.push_back(fEMT_InvMass_All);
1947  fPi0_pt_vs_rap_All =
1948  new TH2D("fPi0_pt_vs_rap_All",
1949  "fPi0_pt_vs_rap_All; rapidity y; p_{t} in GeV/c ",
1950  90,
1951  -2.,
1952  7.,
1953  60,
1954  -1.,
1955  5.);
1956  fHistoList_All.push_back(fPi0_pt_vs_rap_All);
1957  fPi0_pt_vs_rap_est_All =
1958  new TH2D("fPi0_pt_vs_rap_est_All",
1959  "fPi0_pt_vs_rap_est_All; rapidity y; p_{t} in GeV/c ",
1960  10,
1961  0.,
1962  4.,
1963  10,
1964  0.,
1965  4.);
1966  fHistoList_All.push_back(fPi0_pt_vs_rap_est_All);
1967  // 0-2 => All target
1968  fGammaInvMassReco_All_target =
1969  new TH1D("fGammaInvMassReco_All_target",
1970  "fGammaInvMassReco_All_target; invariant mass in GeV/c^{2};#",
1971  110,
1972  -0.01,
1973  0.1);
1974  fHistoList_All_target.push_back(fGammaInvMassReco_All_target);
1975  fGammaOpeningAngleReco_All_target =
1976  new TH1D("fGammaOpeningAngleReco_All_target",
1977  "fGammaOpeningAngleReco_All_target; angle [deg];#",
1978  200,
1979  -0.1,
1980  19.9);
1981  fHistoList_All_target.push_back(fGammaOpeningAngleReco_All_target);
1982  fPi0InvMassRecoKF_All_target =
1983  new TH1D("fPi0InvMassRecoKF_All_target",
1984  "fPi0InvMassRecoKF_All_target; invariant mass in GeV/c^{2};#",
1985  1000,
1986  0,
1987  2.0);
1988  fHistoList_All_target.push_back(fPi0InvMassRecoKF_All_target);
1989  fEMT_InvMass_All_target =
1990  new TH1D("fEMT_InvMass_All_target",
1991  "fEMT_InvMass_All_target; invariant mass in GeV/c^{2};#",
1992  1000,
1993  0,
1994  2.0);
1995  fHistoList_All_target.push_back(fEMT_InvMass_All_target);
1996  // 0-2 => All mvd
1997  fGammaInvMassReco_All_mvd =
1998  new TH1D("fGammaInvMassReco_All_mvd",
1999  "fGammaInvMassReco_All_mvd; invariant mass in GeV/c^{2};#",
2000  110,
2001  -0.01,
2002  0.1);
2003  fHistoList_All_mvd.push_back(fGammaInvMassReco_All_mvd);
2004  fGammaOpeningAngleReco_All_mvd =
2005  new TH1D("fGammaOpeningAngleReco_All_mvd",
2006  "fGammaOpeningAngleReco_All_mvd; angle [deg];#",
2007  200,
2008  -0.1,
2009  19.9);
2010  fHistoList_All_mvd.push_back(fGammaOpeningAngleReco_All_mvd);
2011  fPi0InvMassRecoKF_All_mvd =
2012  new TH1D("fPi0InvMassRecoKF_All_mvd",
2013  "fPi0InvMassRecoKF_All_mvd; invariant mass in GeV/c^{2};#",
2014  1000,
2015  0,
2016  2.0);
2017  fHistoList_All_mvd.push_back(fPi0InvMassRecoKF_All_mvd);
2018  // 0-2 => All sts
2019  fGammaInvMassReco_All_sts =
2020  new TH1D("fGammaInvMassReco_All_sts",
2021  "fGammaInvMassReco_All_sts; invariant mass in GeV/c^{2};#",
2022  110,
2023  -0.01,
2024  0.1);
2025  fHistoList_All_sts.push_back(fGammaInvMassReco_All_sts);
2026  fGammaOpeningAngleReco_All_sts =
2027  new TH1D("fGammaOpeningAngleReco_All_sts",
2028  "fGammaOpeningAngleReco_All_sts; angle [deg];#",
2029  200,
2030  -0.1,
2031  19.9);
2032  fHistoList_All_sts.push_back(fGammaOpeningAngleReco_All_sts);
2033  fPi0InvMassRecoKF_All_sts =
2034  new TH1D("fPi0InvMassRecoKF_All_sts",
2035  "fPi0InvMassRecoKF_All_sts; invariant mass in GeV/c^{2};#",
2036  1000,
2037  0,
2038  2.0);
2039  fHistoList_All_sts.push_back(fPi0InvMassRecoKF_All_sts);
2040  // 0-2 => All outside the target (mvd+sts+pipe)
2041  fGammaInvMassReco_All_outside =
2042  new TH1D("fGammaInvMassReco_All_outside",
2043  "fGammaInvMassReco_All_outside; invariant mass in GeV/c^{2};#",
2044  110,
2045  -0.01,
2046  0.1);
2047  fHistoList_All_outside.push_back(fGammaInvMassReco_All_outside);
2048  fGammaOpeningAngleReco_All_outside =
2049  new TH1D("fGammaOpeningAngleReco_All_outside",
2050  "fGammaOpeningAngleReco_All_outside; angle [deg];#",
2051  200,
2052  -0.1,
2053  19.9);
2054  fHistoList_All_outside.push_back(fGammaOpeningAngleReco_All_outside);
2055  fPi0InvMassRecoKF_All_outside =
2056  new TH1D("fPi0InvMassRecoKF_All_outside",
2057  "fPi0InvMassRecoKF_All_outside; invariant mass in GeV/c^{2};#",
2058  1000,
2059  0,
2060  2.0);
2061  fHistoList_All_outside.push_back(fPi0InvMassRecoKF_All_outside);
2062  fEMT_InvMass_All_outside =
2063  new TH1D("fEMT_InvMass_All_outside",
2064  "fEMT_InvMass_All_outside; invariant mass in GeV/c^{2};#",
2065  1000,
2066  0,
2067  2.0);
2068  fHistoList_All_outside.push_back(fEMT_InvMass_All_outside);
2069 
2070 
2071  // 0 => Zero
2072  fGammaInvMassReco_Zero =
2073  new TH1D("fGammaInvMassReco_Zero",
2074  "fGammaInvMassReco_Zero; invariant mass in GeV/c^{2};#",
2075  110,
2076  -0.01,
2077  0.1);
2078  fHistoList_Zero.push_back(fGammaInvMassReco_Zero);
2079  fGammaOpeningAngleReco_Zero =
2080  new TH1D("fGammaOpeningAngleReco_Zero",
2081  "fGammaOpeningAngleReco_Zero; angle [deg];#",
2082  200,
2083  -0.1,
2084  19.9);
2085  fHistoList_Zero.push_back(fGammaOpeningAngleReco_Zero);
2086  fPdg_Zero = new TH1D("fPdg_Zero", "fPdg_Zero; Id ;#", 800, 0, 400);
2087  fHistoList_Zero.push_back(fPdg_Zero);
2088  fP_reco_Zero =
2089  new TH1D("fP_reco_Zero", "fP_reco_Zero; P in GeV/c^{2} ;#", 600, 0, 6);
2090  fHistoList_Zero.push_back(fP_reco_Zero);
2091  fPt_reco_Zero =
2092  new TH1D("fPt_reco_Zero", "fPt_reco_Zero; Pt in GeV/c^{2} ;#", 300, 0, 3);
2093  fHistoList_Zero.push_back(fPt_reco_Zero);
2094  fPi0InvMassRecoKF_Zero =
2095  new TH1D("fPi0InvMassRecoKF_Zero",
2096  "fPi0InvMassRecoKF_Zero; invariant mass in GeV/c^{2};#",
2097  1000,
2098  0,
2099  2.0);
2100  fHistoList_Zero.push_back(fPi0InvMassRecoKF_Zero);
2101  fEMT_InvMass_Zero =
2102  new TH1D("fEMT_InvMass_Zero",
2103  "fEMT_InvMass_Zero; invariant mass in GeV/c^{2};#",
2104  1000,
2105  0,
2106  2.0);
2107  fHistoList_Zero.push_back(fEMT_InvMass_Zero);
2108  fPi0_pt_vs_rap_Zero =
2109  new TH2D("fPi0_pt_vs_rap_Zero",
2110  "fPi0_pt_vs_rap_Zero; rapidity y; p_{t} in GeV/c ",
2111  90,
2112  -2.,
2113  7.,
2114  60,
2115  -1.,
2116  5.);
2117  fHistoList_Zero.push_back(fPi0_pt_vs_rap_Zero);
2118  fPi0_pt_vs_rap_est_Zero =
2119  new TH2D("fPi0_pt_vs_rap_est_Zero",
2120  "fPi0_pt_vs_rap_est_Zero; rapidity y; p_{t} in GeV/c ",
2121  10,
2122  0.,
2123  4.,
2124  10,
2125  0.,
2126  4.);
2127  fHistoList_Zero.push_back(fPi0_pt_vs_rap_est_Zero);
2128  // 0 => Zero target
2129  fGammaInvMassReco_Zero_target =
2130  new TH1D("fGammaInvMassReco_Zero_target",
2131  "fGammaInvMassReco_Zero_target; invariant mass in GeV/c^{2};#",
2132  110,
2133  -0.01,
2134  0.1);
2135  fHistoList_Zero_target.push_back(fGammaInvMassReco_Zero_target);
2136  fGammaOpeningAngleReco_Zero_target =
2137  new TH1D("fGammaOpeningAngleReco_Zero_target",
2138  "fGammaOpeningAngleReco_Zero_target; angle [deg];#",
2139  200,
2140  -0.1,
2141  19.9);
2142  fHistoList_Zero_target.push_back(fGammaOpeningAngleReco_Zero_target);
2143  fPi0InvMassRecoKF_Zero_target =
2144  new TH1D("fPi0InvMassRecoKF_Zero_target",
2145  "fPi0InvMassRecoKF_Zero_target; invariant mass in GeV/c^{2};#",
2146  1000,
2147  0,
2148  2.0);
2149  fHistoList_Zero_target.push_back(fPi0InvMassRecoKF_Zero_target);
2150  fEMT_InvMass_Zero_target =
2151  new TH1D("fEMT_InvMass_Zero_target",
2152  "fEMT_InvMass_Zero_target; invariant mass in GeV/c^{2};#",
2153  1000,
2154  0,
2155  2.0);
2156  fHistoList_Zero_target.push_back(fEMT_InvMass_Zero_target);
2157  // 0 => Zero mvd
2158  fGammaInvMassReco_Zero_mvd =
2159  new TH1D("fGammaInvMassReco_Zero_mvd",
2160  "fGammaInvMassReco_Zero_mvd; invariant mass in GeV/c^{2};#",
2161  110,
2162  -0.01,
2163  0.1);
2164  fHistoList_Zero_mvd.push_back(fGammaInvMassReco_Zero_mvd);
2165  fGammaOpeningAngleReco_Zero_mvd =
2166  new TH1D("fGammaOpeningAngleReco_Zero_mvd",
2167  "fGammaOpeningAngleReco_Zero_mvd; angle [deg];#",
2168  200,
2169  -0.1,
2170  19.9);
2171  fHistoList_Zero_mvd.push_back(fGammaOpeningAngleReco_Zero_mvd);
2172  fPi0InvMassRecoKF_Zero_mvd =
2173  new TH1D("fPi0InvMassRecoKF_Zero_mvd",
2174  "fPi0InvMassRecoKF_Zero_mvd; invariant mass in GeV/c^{2};#",
2175  1000,
2176  0,
2177  2.0);
2178  fHistoList_Zero_mvd.push_back(fPi0InvMassRecoKF_Zero_mvd);
2179  // 0 => Zero sts
2180  fGammaInvMassReco_Zero_sts =
2181  new TH1D("fGammaInvMassReco_Zero_sts",
2182  "fGammaInvMassReco_Zero_sts; invariant mass in GeV/c^{2};#",
2183  110,
2184  -0.01,
2185  0.1);
2186  fHistoList_Zero_sts.push_back(fGammaInvMassReco_Zero_sts);
2187  fGammaOpeningAngleReco_Zero_sts =
2188  new TH1D("fGammaOpeningAngleReco_Zero_sts",
2189  "fGammaOpeningAngleReco_Zero_sts; angle [deg];#",
2190  200,
2191  -0.1,
2192  19.9);
2193  fHistoList_Zero_sts.push_back(fGammaOpeningAngleReco_Zero_sts);
2194  fPi0InvMassRecoKF_Zero_sts =
2195  new TH1D("fPi0InvMassRecoKF_Zero_sts",
2196  "fPi0InvMassRecoKF_Zero_sts; invariant mass in GeV/c^{2};#",
2197  1000,
2198  0,
2199  2.0);
2200  fHistoList_Zero_sts.push_back(fPi0InvMassRecoKF_Zero_sts);
2201  // 0 => Zero outside the target (mvd+sts+pipe)
2202  fGammaInvMassReco_Zero_outside =
2203  new TH1D("fGammaInvMassReco_Zero_outside",
2204  "fGammaInvMassReco_Zero_outside; invariant mass in GeV/c^{2};#",
2205  110,
2206  -0.01,
2207  0.1);
2208  fHistoList_Zero_outside.push_back(fGammaInvMassReco_Zero_outside);
2209  fGammaOpeningAngleReco_Zero_outside =
2210  new TH1D("fGammaOpeningAngleReco_Zero_outside",
2211  "fGammaOpeningAngleReco_Zero_outside; angle [deg];#",
2212  200,
2213  -0.1,
2214  19.9);
2215  fHistoList_Zero_outside.push_back(fGammaOpeningAngleReco_Zero_outside);
2216  fPi0InvMassRecoKF_Zero_outside =
2217  new TH1D("fPi0InvMassRecoKF_Zero_outside",
2218  "fPi0InvMassRecoKF_Zero_outside; invariant mass in GeV/c^{2};#",
2219  1000,
2220  0,
2221  2.0);
2222  fHistoList_Zero_outside.push_back(fPi0InvMassRecoKF_Zero_outside);
2223  fEMT_InvMass_Zero_outside =
2224  new TH1D("fEMT_InvMass_Zero_outside",
2225  "fEMT_InvMass_Zero_outside; invariant mass in GeV/c^{2};#",
2226  1000,
2227  0,
2228  2.0);
2229  fHistoList_Zero_outside.push_back(fEMT_InvMass_Zero_outside);
2230 
2231 
2232  // 1 => One
2233  fGammaInvMassReco_One =
2234  new TH1D("fGammaInvMassReco_One",
2235  "fGammaInvMassReco_One; invariant mass in GeV/c^{2};#",
2236  110,
2237  -0.01,
2238  0.1);
2239  fHistoList_One.push_back(fGammaInvMassReco_One);
2240  fGammaOpeningAngleReco_One =
2241  new TH1D("fGammaOpeningAngleReco_One",
2242  "fGammaOpeningAngleReco_One; angle [deg];#",
2243  200,
2244  -0.1,
2245  19.9);
2246  fHistoList_One.push_back(fGammaOpeningAngleReco_One);
2247  fPdg_One = new TH1D("fPdg_One", "fPdg_One; Id ;#", 800, 0, 400);
2248  fHistoList_One.push_back(fPdg_One);
2249  fP_reco_One =
2250  new TH1D("fP_reco_One", "fP_reco_One; P in GeV/c^{2} ;#", 600, 0, 6);
2251  fHistoList_One.push_back(fP_reco_One);
2252  fPt_reco_One =
2253  new TH1D("fPt_reco_One", "fPt_reco_One; Pt in GeV/c^{2} ;#", 300, 0, 3);
2254  fHistoList_One.push_back(fPt_reco_One);
2255  fPi0InvMassRecoKF_One =
2256  new TH1D("fPi0InvMassRecoKF_One",
2257  "fPi0InvMassRecoKF_One; invariant mass in GeV/c^{2};#",
2258  1000,
2259  0,
2260  2.0);
2261  fHistoList_One.push_back(fPi0InvMassRecoKF_One);
2262  fEMT_InvMass_One = new TH1D("fEMT_InvMass_One",
2263  "fEMT_InvMass_One; invariant mass in GeV/c^{2};#",
2264  1000,
2265  0,
2266  2.0);
2267  fHistoList_One.push_back(fEMT_InvMass_One);
2268  fPi0_pt_vs_rap_One =
2269  new TH2D("fPi0_pt_vs_rap_One",
2270  "fPi0_pt_vs_rap_One; rapidity y; p_{t} in GeV/c ",
2271  90,
2272  -2.,
2273  7.,
2274  60,
2275  -1.,
2276  5.);
2277  fHistoList_One.push_back(fPi0_pt_vs_rap_One);
2278  fPi0_pt_vs_rap_est_One =
2279  new TH2D("fPi0_pt_vs_rap_est_One",
2280  "fPi0_pt_vs_rap_est_One; rapidity y; p_{t} in GeV/c ",
2281  10,
2282  0.,
2283  4.,
2284  10,
2285  0.,
2286  4.);
2287  fHistoList_One.push_back(fPi0_pt_vs_rap_est_One);
2288  // 1 => One target
2289  fGammaInvMassReco_One_target =
2290  new TH1D("fGammaInvMassReco_One_target",
2291  "fGammaInvMassReco_One_target; invariant mass in GeV/c^{2};#",
2292  110,
2293  -0.01,
2294  0.1);
2295  fHistoList_One_target.push_back(fGammaInvMassReco_One_target);
2296  fGammaOpeningAngleReco_One_target =
2297  new TH1D("fGammaOpeningAngleReco_One_target",
2298  "fGammaOpeningAngleReco_One_target; angle [deg];#",
2299  200,
2300  -0.1,
2301  19.9);
2302  fHistoList_One_target.push_back(fGammaOpeningAngleReco_One_target);
2303  fPi0InvMassRecoKF_One_target =
2304  new TH1D("fPi0InvMassRecoKF_One_target",
2305  "fPi0InvMassRecoKF_One_target; invariant mass in GeV/c^{2};#",
2306  1000,
2307  0,
2308  2.0);
2309  fHistoList_One_target.push_back(fPi0InvMassRecoKF_One_target);
2310  fEMT_InvMass_One_target =
2311  new TH1D("fEMT_InvMass_One_target",
2312  "fEMT_InvMass_One_target; invariant mass in GeV/c^{2};#",
2313  1000,
2314  0,
2315  2.0);
2316  fHistoList_One_target.push_back(fEMT_InvMass_One_target);
2317  // 1 => One mvd
2318  fGammaInvMassReco_One_mvd =
2319  new TH1D("fGammaInvMassReco_One_mvd",
2320  "fGammaInvMassReco_One_mvd; invariant mass in GeV/c^{2};#",
2321  110,
2322  -0.01,
2323  0.1);
2324  fHistoList_One_mvd.push_back(fGammaInvMassReco_One_mvd);
2325  fGammaOpeningAngleReco_One_mvd =
2326  new TH1D("fGammaOpeningAngleReco_One_mvd",
2327  "fGammaOpeningAngleReco_One_mvd; angle [deg];#",
2328  200,
2329  -0.1,
2330  19.9);
2331  fHistoList_One_mvd.push_back(fGammaOpeningAngleReco_One_mvd);
2332  fPi0InvMassRecoKF_One_mvd =
2333  new TH1D("fPi0InvMassRecoKF_One_mvd",
2334  "fPi0InvMassRecoKF_One_mvd; invariant mass in GeV/c^{2};#",
2335  1000,
2336  0,
2337  2.0);
2338  fHistoList_One_mvd.push_back(fPi0InvMassRecoKF_One_mvd);
2339  // 1 => One sts
2340  fGammaInvMassReco_One_sts =
2341  new TH1D("fGammaInvMassReco_One_sts",
2342  "fGammaInvMassReco_One_sts; invariant mass in GeV/c^{2};#",
2343  110,
2344  -0.01,
2345  0.1);
2346  fHistoList_One_sts.push_back(fGammaInvMassReco_One_sts);
2347  fGammaOpeningAngleReco_One_sts =
2348  new TH1D("fGammaOpeningAngleReco_One_sts",
2349  "fGammaOpeningAngleReco_One_sts; angle [deg];#",
2350  200,
2351  -0.1,
2352  19.9);
2353  fHistoList_One_sts.push_back(fGammaOpeningAngleReco_One_sts);
2354  fPi0InvMassRecoKF_One_sts =
2355  new TH1D("fPi0InvMassRecoKF_One_sts",
2356  "fPi0InvMassRecoKF_One_sts; invariant mass in GeV/c^{2};#",
2357  1000,
2358  0,
2359  2.0);
2360  fHistoList_One_sts.push_back(fPi0InvMassRecoKF_One_sts);
2361  // 1 => One outside the target (mvd+sts+pipe)
2362  fGammaInvMassReco_One_outside =
2363  new TH1D("fGammaInvMassReco_One_outside",
2364  "fGammaInvMassReco_One_outside; invariant mass in GeV/c^{2};#",
2365  110,
2366  -0.01,
2367  0.1);
2368  fHistoList_One_outside.push_back(fGammaInvMassReco_One_outside);
2369  fGammaOpeningAngleReco_One_outside =
2370  new TH1D("fGammaOpeningAngleReco_One_outside",
2371  "fGammaOpeningAngleReco_One_outside; angle [deg];#",
2372  200,
2373  -0.1,
2374  19.9);
2375  fHistoList_One_outside.push_back(fGammaOpeningAngleReco_One_outside);
2376  fPi0InvMassRecoKF_One_outside =
2377  new TH1D("fPi0InvMassRecoKF_One_outside",
2378  "fPi0InvMassRecoKF_One_outside; invariant mass in GeV/c^{2};#",
2379  1000,
2380  0,
2381  2.0);
2382  fHistoList_One_outside.push_back(fPi0InvMassRecoKF_One_outside);
2383  fEMT_InvMass_One_outside =
2384  new TH1D("fEMT_InvMass_One_outside",
2385  "fEMT_InvMass_One_outside; invariant mass in GeV/c^{2};#",
2386  1000,
2387  0,
2388  2.0);
2389  fHistoList_One_outside.push_back(fEMT_InvMass_One_outside);
2390 
2391 
2392  // 2 => Two
2393  fGammaInvMassReco_Two =
2394  new TH1D("fGammaInvMassReco_Two",
2395  "fGammaInvMassReco_Two; invariant mass in GeV/c^{2};#",
2396  110,
2397  -0.01,
2398  0.1);
2399  fHistoList_Two.push_back(fGammaInvMassReco_Two);
2400  fGammaOpeningAngleReco_Two =
2401  new TH1D("fGammaOpeningAngleReco_Two",
2402  "fGammaOpeningAngleReco_Two; angle [deg];#",
2403  200,
2404  -0.1,
2405  19.9);
2406  fHistoList_Two.push_back(fGammaOpeningAngleReco_Two);
2407  fPdg_Two = new TH1D("fPdg_Two", "fPdg_Two; Id ;#", 800, 0, 400);
2408  fHistoList_Two.push_back(fPdg_Two);
2409  fP_reco_Two =
2410  new TH1D("fP_reco_Two", "fP_reco_Two; P in GeV/c^{2} ;#", 600, 0, 6);
2411  fHistoList_Two.push_back(fP_reco_Two);
2412  fPt_reco_Two =
2413  new TH1D("fPt_reco_Two", "fPt_reco_Two; Pt in GeV/c^{2} ;#", 300, 0, 3);
2414  fHistoList_Two.push_back(fPt_reco_Two);
2415  fPi0InvMassRecoKF_Two =
2416  new TH1D("fPi0InvMassRecoKF_Two",
2417  "fPi0InvMassRecoKF_Two; invariant mass in GeV/c^{2};#",
2418  1000,
2419  0,
2420  2.0);
2421  fHistoList_Two.push_back(fPi0InvMassRecoKF_Two);
2422  fEMT_InvMass_Two = new TH1D("fEMT_InvMass_Two",
2423  "fEMT_InvMass_Two; invariant mass in GeV/c^{2};#",
2424  1000,
2425  0,
2426  2.0);
2427  fHistoList_Two.push_back(fEMT_InvMass_Two);
2428  fPi0_pt_vs_rap_Two =
2429  new TH2D("fPi0_pt_vs_rap_Two",
2430  "fPi0_pt_vs_rap_Two; rapidity y; p_{t} in GeV/c ",
2431  90,
2432  -2.,
2433  7.,
2434  60,
2435  -1.,
2436  5.);
2437  fHistoList_Two.push_back(fPi0_pt_vs_rap_Two);
2438  fPi0_pt_vs_rap_est_Two =
2439  new TH2D("fPi0_pt_vs_rap_est_Two",
2440  "fPi0_pt_vs_rap_est_Two; rapidity y; p_{t} in GeV/c ",
2441  10,
2442  0.,
2443  4.,
2444  10,
2445  0.,
2446  4.);
2447  fHistoList_Two.push_back(fPi0_pt_vs_rap_est_Two);
2448  // 2 => Two target
2449  fGammaInvMassReco_Two_target =
2450  new TH1D("fGammaInvMassReco_Two_target",
2451  "fGammaInvMassReco_Two_target; invariant mass in GeV/c^{2};#",
2452  110,
2453  -0.01,
2454  0.1);
2455  fHistoList_Two_target.push_back(fGammaInvMassReco_Two_target);
2456  fGammaOpeningAngleReco_Two_target =
2457  new TH1D("fGammaOpeningAngleReco_Two_target",
2458  "fGammaOpeningAngleReco_Two_target; angle [deg];#",
2459  200,
2460  -0.1,
2461  19.9);
2462  fHistoList_Two_target.push_back(fGammaOpeningAngleReco_Two_target);
2463  fPi0InvMassRecoKF_Two_target =
2464  new TH1D("fPi0InvMassRecoKF_Two_target",
2465  "fPi0InvMassRecoKF_Two_target; invariant mass in GeV/c^{2};#",
2466  1000,
2467  0,
2468  2.0);
2469  fHistoList_Two_target.push_back(fPi0InvMassRecoKF_Two_target);
2470  fEMT_InvMass_Two_target =
2471  new TH1D("fEMT_InvMass_Two_target",
2472  "fEMT_InvMass_Two_target; invariant mass in GeV/c^{2};#",
2473  1000,
2474  0,
2475  2.0);
2476  fHistoList_Two_target.push_back(fEMT_InvMass_Two_target);
2477  // 2 => Two mvd
2478  fGammaInvMassReco_Two_mvd =
2479  new TH1D("fGammaInvMassReco_Two_mvd",
2480  "fGammaInvMassReco_Two_mvd; invariant mass in GeV/c^{2};#",
2481  110,
2482  -0.01,
2483  0.1);
2484  fHistoList_Two_mvd.push_back(fGammaInvMassReco_Two_mvd);
2485  fGammaOpeningAngleReco_Two_mvd =
2486  new TH1D("fGammaOpeningAngleReco_Two_mvd",
2487  "fGammaOpeningAngleReco_Two_mvd; angle [deg];#",
2488  200,
2489  -0.1,
2490  19.9);
2491  fHistoList_Two_mvd.push_back(fGammaOpeningAngleReco_Two_mvd);
2492  fPi0InvMassRecoKF_Two_mvd =
2493  new TH1D("fPi0InvMassRecoKF_Two_mvd",
2494  "fPi0InvMassRecoKF_Two_mvd; invariant mass in GeV/c^{2};#",
2495  1000,
2496  0,
2497  2.0);
2498  fHistoList_Two_mvd.push_back(fPi0InvMassRecoKF_Two_mvd);
2499  // 2 => Two sts
2500  fGammaInvMassReco_Two_sts =
2501  new TH1D("fGammaInvMassReco_Two_sts",
2502  "fGammaInvMassReco_Two_sts; invariant mass in GeV/c^{2};#",
2503  110,
2504  -0.01,
2505  0.1);
2506  fHistoList_Two_sts.push_back(fGammaInvMassReco_Two_sts);
2507  fGammaOpeningAngleReco_Two_sts =
2508  new TH1D("fGammaOpeningAngleReco_Two_sts",
2509  "fGammaOpeningAngleReco_Two_sts; angle [deg];#",
2510  200,
2511  -0.1,
2512  19.9);
2513  fHistoList_Two_sts.push_back(fGammaOpeningAngleReco_Two_sts);
2514  fPi0InvMassRecoKF_Two_sts =
2515  new TH1D("fPi0InvMassRecoKF_Two_sts",
2516  "fPi0InvMassRecoKF_Two_sts; invariant mass in GeV/c^{2};#",
2517  1000,
2518  0,
2519  2.0);
2520  fHistoList_Two_sts.push_back(fPi0InvMassRecoKF_Two_sts);
2521  // 2 => Two outside the target (mvd+sts+pipe)
2522  fGammaInvMassReco_Two_outside =
2523  new TH1D("fGammaInvMassReco_Two_outside",
2524  "fGammaInvMassReco_Two_outside; invariant mass in GeV/c^{2};#",
2525  110,
2526  -0.01,
2527  0.1);
2528  fHistoList_Two_outside.push_back(fGammaInvMassReco_Two_outside);
2529  fGammaOpeningAngleReco_Two_outside =
2530  new TH1D("fGammaOpeningAngleReco_Two_outside",
2531  "fGammaOpeningAngleReco_Two_outside; angle [deg];#",
2532  200,
2533  -0.1,
2534  19.9);
2535  fHistoList_Two_outside.push_back(fGammaOpeningAngleReco_Two_outside);
2536  fPi0InvMassRecoKF_Two_outside =
2537  new TH1D("fPi0InvMassRecoKF_Two_outside",
2538  "fPi0InvMassRecoKF_Two_outside; invariant mass in GeV/c^{2};#",
2539  1000,
2540  0,
2541  2.0);
2542  fHistoList_Two_outside.push_back(fPi0InvMassRecoKF_Two_outside);
2543  fEMT_InvMass_Two_outside =
2544  new TH1D("fEMT_InvMass_Two_outside",
2545  "fEMT_InvMass_Two_outside; invariant mass in GeV/c^{2};#",
2546  1000,
2547  0,
2548  2.0);
2549  fHistoList_Two_outside.push_back(fEMT_InvMass_Two_outside);
2550 
2551 
2552  // 1-2 => OneTwo
2553  fGammaInvMassReco_OneTwo =
2554  new TH1D("fGammaInvMassReco_OneTwo",
2555  "fGammaInvMassReco_OneTwo; invariant mass in GeV/c^{2};#",
2556  110,
2557  -0.01,
2558  0.1);
2559  fHistoList_OneTwo.push_back(fGammaInvMassReco_OneTwo);
2560  fGammaOpeningAngleReco_OneTwo =
2561  new TH1D("fGammaOpeningAngleReco_OneTwo",
2562  "fGammaOpeningAngleReco_OneTwo; angle [deg];#",
2563  200,
2564  -0.1,
2565  19.9);
2566  fHistoList_OneTwo.push_back(fGammaOpeningAngleReco_OneTwo);
2567  fPdg_OneTwo = new TH1D("fPdg_OneTwo", "fPdg_OneTwo; Id ;#", 800, 0, 400);
2568  fHistoList_OneTwo.push_back(fPdg_OneTwo);
2569  fP_reco_OneTwo =
2570  new TH1D("fP_reco_OneTwo", "fP_reco_OneTwo; P in GeV/c^{2} ;#", 600, 0, 6);
2571  fHistoList_OneTwo.push_back(fP_reco_OneTwo);
2572  fPt_reco_OneTwo = new TH1D(
2573  "fPt_reco_OneTwo", "fPt_reco_OneTwo; Pt in GeV/c^{2} ;#", 300, 0, 3);
2574  fHistoList_OneTwo.push_back(fPt_reco_OneTwo);
2575  fPi0InvMassRecoKF_OneTwo =
2576  new TH1D("fPi0InvMassRecoKF_OneTwo",
2577  "fPi0InvMassRecoKF_OneTwo; invariant mass in GeV/c^{2};#",
2578  1000,
2579  0,
2580  2.0);
2581  fHistoList_OneTwo.push_back(fPi0InvMassRecoKF_OneTwo);
2582  fEMT_InvMass_OneTwo =
2583  new TH1D("fEMT_InvMass_OneTwo",
2584  "fEMT_InvMass_OneTwo; invariant mass in GeV/c^{2};#",
2585  1000,
2586  0,
2587  2.0);
2588  fHistoList_OneTwo.push_back(fEMT_InvMass_OneTwo);
2589  fPi0_pt_vs_rap_OneTwo =
2590  new TH2D("fPi0_pt_vs_rap_OneTwo",
2591  "fPi0_pt_vs_rap_OneTwo; rapidity y; p_{t} in GeV/c ",
2592  90,
2593  -2.,
2594  7.,
2595  60,
2596  -1.,
2597  5.);
2598  fHistoList_OneTwo.push_back(fPi0_pt_vs_rap_OneTwo);
2599  fPi0_pt_vs_rap_est_OneTwo =
2600  new TH2D("fPi0_pt_vs_rap_est_OneTwo",
2601  "fPi0_pt_vs_rap_est_OneTwo; rapidity y; p_{t} in GeV/c ",
2602  10,
2603  0.,
2604  4.,
2605  10,
2606  0.,
2607  4.);
2608  fHistoList_OneTwo.push_back(fPi0_pt_vs_rap_est_OneTwo);
2609  // 1-2 => OneTwo target
2610  fGammaInvMassReco_OneTwo_target =
2611  new TH1D("fGammaInvMassReco_OneTwo_target",
2612  "fGammaInvMassReco_OneTwo_target; invariant mass in GeV/c^{2};#",
2613  110,
2614  -0.01,
2615  0.1);
2616  fHistoList_OneTwo_target.push_back(fGammaInvMassReco_OneTwo_target);
2617  fGammaOpeningAngleReco_OneTwo_target =
2618  new TH1D("fGammaOpeningAngleReco_OneTwo_target",
2619  "fGammaOpeningAngleReco_OneTwo_target; angle [deg];#",
2620  200,
2621  -0.1,
2622  19.9);
2623  fHistoList_OneTwo_target.push_back(fGammaOpeningAngleReco_OneTwo_target);
2624  fPi0InvMassRecoKF_OneTwo_target =
2625  new TH1D("fPi0InvMassRecoKF_OneTwo_target",
2626  "fPi0InvMassRecoKF_OneTwo_target; invariant mass in GeV/c^{2};#",
2627  1000,
2628  0,
2629  2.0);
2630  fHistoList_OneTwo_target.push_back(fPi0InvMassRecoKF_OneTwo_target);
2631  fEMT_InvMass_OneTwo_target =
2632  new TH1D("fEMT_InvMass_OneTwo_target",
2633  "fEMT_InvMass_OneTwo_target; invariant mass in GeV/c^{2};#",
2634  1000,
2635  0,
2636  2.0);
2637  fHistoList_OneTwo_target.push_back(fEMT_InvMass_OneTwo_target);
2638  // 1-2 => OneTwo mvd
2639  fGammaInvMassReco_OneTwo_mvd =
2640  new TH1D("fGammaInvMassReco_OneTwo_mvd",
2641  "fGammaInvMassReco_OneTwo_mvd; invariant mass in GeV/c^{2};#",
2642  110,
2643  -0.01,
2644  0.1);
2645  fHistoList_OneTwo_mvd.push_back(fGammaInvMassReco_OneTwo_mvd);
2646  fGammaOpeningAngleReco_OneTwo_mvd =
2647  new TH1D("fGammaOpeningAngleReco_OneTwo_mvd",
2648  "fGammaOpeningAngleReco_OneTwo_mvd; angle [deg];#",
2649  200,
2650  -0.1,
2651  19.9);
2652  fHistoList_OneTwo_mvd.push_back(fGammaOpeningAngleReco_OneTwo_mvd);
2653  fPi0InvMassRecoKF_OneTwo_mvd =
2654  new TH1D("fPi0InvMassRecoKF_OneTwo_mvd",
2655  "fPi0InvMassRecoKF_OneTwo_mvd; invariant mass in GeV/c^{2};#",
2656  1000,
2657  0,
2658  2.0);
2659  fHistoList_OneTwo_mvd.push_back(fPi0InvMassRecoKF_OneTwo_mvd);
2660  // 1-2 => OneTwo sts
2661  fGammaInvMassReco_OneTwo_sts =
2662  new TH1D("fGammaInvMassReco_OneTwo_sts",
2663  "fGammaInvMassReco_OneTwo_sts; invariant mass in GeV/c^{2};#",
2664  110,
2665  -0.01,
2666  0.1);
2667  fHistoList_OneTwo_sts.push_back(fGammaInvMassReco_OneTwo_sts);
2668  fGammaOpeningAngleReco_OneTwo_sts =
2669  new TH1D("fGammaOpeningAngleReco_OneTwo_sts",
2670  "fGammaOpeningAngleReco_OneTwo_sts; angle [deg];#",
2671  200,
2672  -0.1,
2673  19.9);
2674  fHistoList_OneTwo_sts.push_back(fGammaOpeningAngleReco_OneTwo_sts);
2675  fPi0InvMassRecoKF_OneTwo_sts =
2676  new TH1D("fPi0InvMassRecoKF_OneTwo_sts",
2677  "fPi0InvMassRecoKF_OneTwo_sts; invariant mass in GeV/c^{2};#",
2678  1000,
2679  0,
2680  2.0);
2681  fHistoList_OneTwo_sts.push_back(fPi0InvMassRecoKF_OneTwo_sts);
2682  // 1-2 => OneTwo outside the target (mvd+sts+pipe)
2683  fGammaInvMassReco_OneTwo_outside =
2684  new TH1D("fGammaInvMassReco_OneTwo_outside",
2685  "fGammaInvMassReco_OneTwo_outside; invariant mass in GeV/c^{2};#",
2686  110,
2687  -0.01,
2688  0.1);
2689  fHistoList_OneTwo_outside.push_back(fGammaInvMassReco_OneTwo_outside);
2690  fGammaOpeningAngleReco_OneTwo_outside =
2691  new TH1D("fGammaOpeningAngleReco_OneTwo_outside",
2692  "fGammaOpeningAngleReco_OneTwo_outside; angle [deg];#",
2693  200,
2694  -0.1,
2695  19.9);
2696  fHistoList_OneTwo_outside.push_back(fGammaOpeningAngleReco_OneTwo_outside);
2697  fPi0InvMassRecoKF_OneTwo_outside =
2698  new TH1D("fPi0InvMassRecoKF_OneTwo_outside",
2699  "fPi0InvMassRecoKF_OneTwo_outside; invariant mass in GeV/c^{2};#",
2700  1000,
2701  0,
2702  2.0);
2703  fHistoList_OneTwo_outside.push_back(fPi0InvMassRecoKF_OneTwo_outside);
2704  fEMT_InvMass_OneTwo_outside =
2705  new TH1D("fEMT_InvMass_OneTwo_outside",
2706  "fEMT_InvMass_OneTwo_outside; invariant mass in GeV/c^{2};#",
2707  1000,
2708  0,
2709  2.0);
2710  fHistoList_OneTwo_outside.push_back(fEMT_InvMass_OneTwo_outside);
2711 
2712 
2713  // multiplicity plots: How number of gammas change EMT plot and how many gammas we have per event after our cuts
2714  MultiplicityGamma_All = new TH2D(
2715  "MultiplicityGamma_All",
2716  "MultiplicityGamma_All; Nof gammas in event; invariant mass in GeV/c^{2};#",
2717  400,
2718  0,
2719  30,
2720  1000,
2721  0,
2722  2.0);
2723  fHistoList_multiplicity.push_back(MultiplicityGamma_All);
2724  MultiplicityGamma_Zero = new TH2D("MultiplicityGamma_Zero",
2725  "MultiplicityGamma_Zero; Nof gammas in "
2726  "event; invariant mass in GeV/c^{2};#",
2727  400,
2728  0,
2729  30,
2730  1000,
2731  0,
2732  2.0);
2733  fHistoList_multiplicity.push_back(MultiplicityGamma_Zero);
2734  MultiplicityGamma_One = new TH2D(
2735  "MultiplicityGamma_One",
2736  "MultiplicityGamma_One; Nof gammas in event; invariant mass in GeV/c^{2};#",
2737  400,
2738  0,
2739  30,
2740  1000,
2741  0,
2742  2.0);
2743  fHistoList_multiplicity.push_back(MultiplicityGamma_One);
2744  MultiplicityGamma_Two = new TH2D(
2745  "MultiplicityGamma_Two",
2746  "MultiplicityGamma_Two; Nof gammas in event; invariant mass in GeV/c^{2};#",
2747  400,
2748  0,
2749  30,
2750  1000,
2751  0,
2752  2.0);
2753  fHistoList_multiplicity.push_back(MultiplicityGamma_Two);
2754  MultiplicityGamma_OneTwo = new TH2D("MultiplicityGamma_OneTwo",
2755  "MultiplicityGamma_OneTwo; Nof gammas in "
2756  "event; invariant mass in GeV/c^{2};#",
2757  400,
2758  0,
2759  30,
2760  1000,
2761  0,
2762  2.0);
2763  fHistoList_multiplicity.push_back(MultiplicityGamma_OneTwo);
2764 
2765  MultiplicityChargedParticles_All =
2766  new TH2D("MultiplicityChargedParticles_All",
2767  "MultiplicityChargedParticles_All; Nof charged particles in "
2768  "event; invariant mass in GeV/c^{2};#",
2769  1000,
2770  0,
2771  1000,
2772  1000,
2773  0,
2774  2.0);
2775  fHistoList_multiplicity.push_back(MultiplicityChargedParticles_All);
2776  MultiplicityChargedParticles_Zero =
2777  new TH2D("MultiplicityChargedParticles_Zero",
2778  "MultiplicityChargedParticles_Zero; Nof charged particles in "
2779  "event; invariant mass in GeV/c^{2};#",
2780  1000,
2781  0,
2782  1000,
2783  1000,
2784  0,
2785  2.0);
2786  fHistoList_multiplicity.push_back(MultiplicityChargedParticles_Zero);
2787  MultiplicityChargedParticles_One =
2788  new TH2D("MultiplicityChargedParticles_One",
2789  "MultiplicityChargedParticles_One; Nof charged particles in "
2790  "event; invariant mass in GeV/c^{2};#",
2791  1000,
2792  0,
2793  1000,
2794  1000,
2795  0,
2796  2.0);
2797  fHistoList_multiplicity.push_back(MultiplicityChargedParticles_One);
2798  MultiplicityChargedParticles_Two =
2799  new TH2D("MultiplicityChargedParticles_Two",
2800  "MultiplicityChargedParticles_Two; Nof charged particles in "
2801  "event; invariant mass in GeV/c^{2};#",
2802  1000,
2803  0,
2804  1000,
2805  1000,
2806  0,
2807  2.0);
2808  fHistoList_multiplicity.push_back(MultiplicityChargedParticles_Two);
2809  MultiplicityChargedParticles_OneTwo =
2810  new TH2D("MultiplicityChargedParticles_OneTwo",
2811  "MultiplicityChargedParticles_OneTwo; Nof charged particles in "
2812  "event; invariant mass in GeV/c^{2};#",
2813  1000,
2814  0,
2815  1000,
2816  1000,
2817  0,
2818  2.0);
2819  fHistoList_multiplicity.push_back(MultiplicityChargedParticles_OneTwo);
2820 
2821 
2822  // Multi EMT
2823  EMTMulti_InvMass_All_m1 =
2824  new TH1D("EMTMulti_InvMass_All_m1",
2825  "EMTMulti_InvMass_All_m1; invariant mass in GeV/c^{2};#",
2826  1000,
2827  0,
2828  2.0);
2829  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m1);
2830  EMTMulti_InvMass_All_m2 =
2831  new TH1D("EMTMulti_InvMass_All_m2",
2832  "EMTMulti_InvMass_All_m2; invariant mass in GeV/c^{2};#",
2833  1000,
2834  0,
2835  2.0);
2836  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m2);
2837  EMTMulti_InvMass_All_m3 =
2838  new TH1D("EMTMulti_InvMass_All_m3",
2839  "EMTMulti_InvMass_All_m3; invariant mass in GeV/c^{2};#",
2840  1000,
2841  0,
2842  2.0);
2843  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m3);
2844  EMTMulti_InvMass_All_m4 =
2845  new TH1D("EMTMulti_InvMass_All_m4",
2846  "EMTMulti_InvMass_All_m4; invariant mass in GeV/c^{2};#",
2847  1000,
2848  0,
2849  2.0);
2850  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m4);
2851  EMTMulti_InvMass_All_m5 =
2852  new TH1D("EMTMulti_InvMass_All_m5",
2853  "EMTMulti_InvMass_All_m5; invariant mass in GeV/c^{2};#",
2854  1000,
2855  0,
2856  2.0);
2857  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m5);
2858  EMTMulti_InvMass_All_m6 =
2859  new TH1D("EMTMulti_InvMass_All_m6",
2860  "EMTMulti_InvMass_All_m6; invariant mass in GeV/c^{2};#",
2861  1000,
2862  0,
2863  2.0);
2864  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m6);
2865  EMTMulti_InvMass_All_m7 =
2866  new TH1D("EMTMulti_InvMass_All_m7",
2867  "EMTMulti_InvMass_All_m7; invariant mass in GeV/c^{2};#",
2868  1000,
2869  0,
2870  2.0);
2871  fHistoList_multiplicity_All.push_back(EMTMulti_InvMass_All_m7);
2872 
2873  EMTMulti_InvMass_Zero_m1 =
2874  new TH1D("EMTMulti_InvMass_Zero_m1",
2875  "EMTMulti_InvMass_Zero_m1; invariant mass in GeV/c^{2};#",
2876  1000,
2877  0,
2878  2.0);
2879  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m1);
2880  EMTMulti_InvMass_Zero_m2 =
2881  new TH1D("EMTMulti_InvMass_Zero_m2",
2882  "EMTMulti_InvMass_Zero_m2; invariant mass in GeV/c^{2};#",
2883  1000,
2884  0,
2885  2.0);
2886  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m2);
2887  EMTMulti_InvMass_Zero_m3 =
2888  new TH1D("EMTMulti_InvMass_Zero_m3",
2889  "EMTMulti_InvMass_Zero_m3; invariant mass in GeV/c^{2};#",
2890  1000,
2891  0,
2892  2.0);
2893  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m3);
2894  EMTMulti_InvMass_Zero_m4 =
2895  new TH1D("EMTMulti_InvMass_Zero_m4",
2896  "EMTMulti_InvMass_Zero_m4; invariant mass in GeV/c^{2};#",
2897  1000,
2898  0,
2899  2.0);
2900  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m4);
2901  EMTMulti_InvMass_Zero_m5 =
2902  new TH1D("EMTMulti_InvMass_Zero_m5",
2903  "EMTMulti_InvMass_Zero_m5; invariant mass in GeV/c^{2};#",
2904  1000,
2905  0,
2906  2.0);
2907  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m5);
2908  EMTMulti_InvMass_Zero_m6 =
2909  new TH1D("EMTMulti_InvMass_Zero_m6",
2910  "EMTMulti_InvMass_Zero_m6; invariant mass in GeV/c^{2};#",
2911  1000,
2912  0,
2913  2.0);
2914  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m6);
2915  EMTMulti_InvMass_Zero_m7 =
2916  new TH1D("EMTMulti_InvMass_Zero_m7",
2917  "EMTMulti_InvMass_Zero_m7; invariant mass in GeV/c^{2};#",
2918  1000,
2919  0,
2920  2.0);
2921  fHistoList_multiplicity_Zero.push_back(EMTMulti_InvMass_Zero_m7);
2922 
2923  EMTMulti_InvMass_One_m1 =
2924  new TH1D("EMTMulti_InvMass_One_m1",
2925  "EMTMulti_InvMass_One_m1; invariant mass in GeV/c^{2};#",
2926  1000,
2927  0,
2928  2.0);
2929  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m1);
2930  EMTMulti_InvMass_One_m2 =
2931  new TH1D("EMTMulti_InvMass_One_m2",
2932  "EMTMulti_InvMass_One_m2; invariant mass in GeV/c^{2};#",
2933  1000,
2934  0,
2935  2.0);
2936  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m2);
2937  EMTMulti_InvMass_One_m3 =
2938  new TH1D("EMTMulti_InvMass_One_m3",
2939  "EMTMulti_InvMass_One_m3; invariant mass in GeV/c^{2};#",
2940  1000,
2941  0,
2942  2.0);
2943  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m3);
2944  EMTMulti_InvMass_One_m4 =
2945  new TH1D("EMTMulti_InvMass_One_m4",
2946  "EMTMulti_InvMass_One_m4; invariant mass in GeV/c^{2};#",
2947  1000,
2948  0,
2949  2.0);
2950  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m4);
2951  EMTMulti_InvMass_One_m5 =
2952  new TH1D("EMTMulti_InvMass_One_m5",
2953  "EMTMulti_InvMass_One_m5; invariant mass in GeV/c^{2};#",
2954  1000,
2955  0,
2956  2.0);
2957  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m5);
2958  EMTMulti_InvMass_One_m6 =
2959  new TH1D("EMTMulti_InvMass_One_m6",
2960  "EMTMulti_InvMass_One_m6; invariant mass in GeV/c^{2};#",
2961  1000,
2962  0,
2963  2.0);
2964  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m6);
2965  EMTMulti_InvMass_One_m7 =
2966  new TH1D("EMTMulti_InvMass_One_m7",
2967  "EMTMulti_InvMass_One_m7; invariant mass in GeV/c^{2};#",
2968  1000,
2969  0,
2970  2.0);
2971  fHistoList_multiplicity_One.push_back(EMTMulti_InvMass_One_m7);
2972 
2973  EMTMulti_InvMass_Two_m1 =
2974  new TH1D("EMTMulti_InvMass_Two_m1",
2975  "EMTMulti_InvMass_Two_m1; invariant mass in GeV/c^{2};#",
2976  1000,
2977  0,
2978  2.0);
2979  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m1);
2980  EMTMulti_InvMass_Two_m2 =
2981  new TH1D("EMTMulti_InvMass_Two_m2",
2982  "EMTMulti_InvMass_Two_m2; invariant mass in GeV/c^{2};#",
2983  1000,
2984  0,
2985  2.0);
2986  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m2);
2987  EMTMulti_InvMass_Two_m3 =
2988  new TH1D("EMTMulti_InvMass_Two_m3",
2989  "EMTMulti_InvMass_Two_m3; invariant mass in GeV/c^{2};#",
2990  1000,
2991  0,
2992  2.0);
2993  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m3);
2994  EMTMulti_InvMass_Two_m4 =
2995  new TH1D("EMTMulti_InvMass_Two_m4",
2996  "EMTMulti_InvMass_Two_m4; invariant mass in GeV/c^{2};#",
2997  1000,
2998  0,
2999  2.0);
3000  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m4);
3001  EMTMulti_InvMass_Two_m5 =
3002  new TH1D("EMTMulti_InvMass_Two_m5",
3003  "EMTMulti_InvMass_Two_m5; invariant mass in GeV/c^{2};#",
3004  1000,
3005  0,
3006  2.0);
3007  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m5);
3008  EMTMulti_InvMass_Two_m6 =
3009  new TH1D("EMTMulti_InvMass_Two_m6",
3010  "EMTMulti_InvMass_Two_m6; invariant mass in GeV/c^{2};#",
3011  1000,
3012  0,
3013  2.0);
3014  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m6);
3015  EMTMulti_InvMass_Two_m7 =
3016  new TH1D("EMTMulti_InvMass_Two_m7",
3017  "EMTMulti_InvMass_Two_m7; invariant mass in GeV/c^{2};#",
3018  1000,
3019  0,
3020  2.0);
3021  fHistoList_multiplicity_Two.push_back(EMTMulti_InvMass_Two_m7);
3022 
3023  EMTMulti_InvMass_OneTwo_m1 =
3024  new TH1D("EMTMulti_InvMass_OneTwo_m1",
3025  "EMTMulti_InvMass_OneTwo_m1; invariant mass in GeV/c^{2};#",
3026  1000,
3027  0,
3028  2.0);
3029  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m1);
3030  EMTMulti_InvMass_OneTwo_m2 =
3031  new TH1D("EMTMulti_InvMass_OneTwo_m2",
3032  "EMTMulti_InvMass_OneTwo_m2; invariant mass in GeV/c^{2};#",
3033  1000,
3034  0,
3035  2.0);
3036  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m2);
3037  EMTMulti_InvMass_OneTwo_m3 =
3038  new TH1D("EMTMulti_InvMass_OneTwo_m3",
3039  "EMTMulti_InvMass_OneTwo_m3; invariant mass in GeV/c^{2};#",
3040  1000,
3041  0,
3042  2.0);
3043  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m3);
3044  EMTMulti_InvMass_OneTwo_m4 =
3045  new TH1D("EMTMulti_InvMass_OneTwo_m4",
3046  "EMTMulti_InvMass_OneTwo_m4; invariant mass in GeV/c^{2};#",
3047  1000,
3048  0,
3049  2.0);
3050  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m4);
3051  EMTMulti_InvMass_OneTwo_m5 =
3052  new TH1D("EMTMulti_InvMass_OneTwo_m5",
3053  "EMTMulti_InvMass_OneTwo_m5; invariant mass in GeV/c^{2};#",
3054  1000,
3055  0,
3056  2.0);
3057  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m5);
3058  EMTMulti_InvMass_OneTwo_m6 =
3059  new TH1D("EMTMulti_InvMass_OneTwo_m6",
3060  "EMTMulti_InvMass_OneTwo_m6; invariant mass in GeV/c^{2};#",
3061  1000,
3062  0,
3063  2.0);
3064  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m6);
3065  EMTMulti_InvMass_OneTwo_m7 =
3066  new TH1D("EMTMulti_InvMass_OneTwo_m7",
3067  "EMTMulti_InvMass_OneTwo_m7; invariant mass in GeV/c^{2};#",
3068  1000,
3069  0,
3070  2.0);
3071  fHistoList_multiplicity_OneTwo.push_back(EMTMulti_InvMass_OneTwo_m7);
3072 
3073 
3074  // BG cases
3075  //Both all
3076  BG1_all =
3077  new TH1D("BG1_all", "BG1_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3078  fHistoList_bg_all.push_back(BG1_all);
3079  BG2_all =
3080  new TH1D("BG2_all", "BG2_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3081  fHistoList_bg_all.push_back(BG2_all);
3082  BG3_all =
3083  new TH1D("BG3_all", "BG3_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3084  fHistoList_bg_all.push_back(BG3_all);
3085  BG4_all =
3086  new TH1D("BG4_all", "BG4_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3087  fHistoList_bg_all.push_back(BG4_all);
3088  BG5_all =
3089  new TH1D("BG5_all", "BG5_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3090  fHistoList_bg_all.push_back(BG5_all);
3091  BG6_all =
3092  new TH1D("BG6_all", "BG6_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3093  fHistoList_bg_all.push_back(BG6_all);
3094  BG7_all =
3095  new TH1D("BG7_all", "BG7_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3096  fHistoList_bg_all.push_back(BG7_all);
3097  BG8_all =
3098  new TH1D("BG8_all", "BG8_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3099  fHistoList_bg_all.push_back(BG8_all);
3100  BG9_all =
3101  new TH1D("BG9_all", "BG9_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3102  fHistoList_bg_all.push_back(BG9_all);
3103  BG10_all = new TH1D(
3104  "BG10_all", "BG10_all; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3105  fHistoList_bg_all.push_back(BG10_all);
3106  PdgCase8_all =
3107  new TH1D("PdgCase8_all", "PdgCase8_all; Id ;#", 5000, -2500, 2500);
3108  fHistoList_bg_all.push_back(PdgCase8_all);
3109  PdgCase8mothers_all = new TH1D(
3110  "PdgCase8mothers_all", "PdgCase8mothers_all; Id ;#", 5000, -2500, 2500);
3111  fHistoList_bg_all.push_back(PdgCase8mothers_all);
3112  sameMIDcase8_all = new TH1D("sameMIDcase8_all",
3113  "sameMIDcase8_all; invariant mass in GeV/c^{2};#",
3114  1000,
3115  0,
3116  2.0);
3117  fHistoList_bg_all.push_back(sameMIDcase8_all);
3118  sameGRIDcase8_all =
3119  new TH1D("sameGRIDcase8_all",
3120  "sameGRIDcase8_all; invariant mass in GeV/c^{2};#",
3121  1000,
3122  0,
3123  2.0);
3124  fHistoList_bg_all.push_back(sameGRIDcase8_all);
3125  Case1ZYPos_all = new TH2D("Case1ZYPos_all",
3126  "Case1ZYPos_all; z[cm]; y[cm]",
3127  400,
3128  -1,
3129  200,
3130  200,
3131  -50,
3132  50);
3133  fHistoList_bg_all.push_back(Case1ZYPos_all);
3134  sameMIDcase8_mothedPDG_all = new TH1D("sameMIDcase8_mothedPDG_all",
3135  "sameMIDcase8_mothedPDG_all; Id ;#",
3136  5000,
3137  -2500,
3138  2500);
3139  fHistoList_bg_all.push_back(sameMIDcase8_mothedPDG_all);
3140  PdgCase8NonEComeFromTarget_all =
3141  new TH1D("PdgCase8NonEComeFromTarget_all",
3142  "PdgCase8NonEComeFromTarget_all; Id ;#",
3143  5000,
3144  -2500,
3145  2500);
3146  fHistoList_bg_all.push_back(PdgCase8NonEComeFromTarget_all);
3147  PdgCase8NonE_NOT_FromTarget_all =
3148  new TH1D("PdgCase8NonE_NOT_FromTarget_all",
3149  "PdgCase8NonE_NOT_FromTarget_all; Id ;#",
3150  5000,
3151  -2500,
3152  2500);
3153  fHistoList_bg_all.push_back(PdgCase8NonE_NOT_FromTarget_all);
3154  PdgCase8motherNonE_all = new TH1D("PdgCase8motherNonE_all",
3155  "PdgCase8motherNonE_all; Id ;#",
3156  5000,
3157  -2500,
3158  2500);
3159  fHistoList_bg_all.push_back(PdgCase8motherNonE_all);
3160  Case8ElFromDalitz_all =
3161  new TH1D("Case8ElFromDalitz_all",
3162  "Case8ElFromDalitz_all; invariant mass in GeV/c^{2};#",
3163  1000,
3164  0,
3165  2.0);
3166  fHistoList_bg_all.push_back(Case8ElFromDalitz_all);
3167  Case8NonElFrom_pn_all =
3168  new TH1D("Case8NonElFrom_pn_all",
3169  "Case8NonElFrom_pn_all; invariant mass in GeV/c^{2};#",
3170  1000,
3171  0,
3172  2.0);
3173  fHistoList_bg_all.push_back(Case8NonElFrom_pn_all);
3174  Case8NonElFrom_eta_all =
3175  new TH1D("Case8NonElFrom_eta_all",
3176  "Case8NonElFrom_eta_all; invariant mass in GeV/c^{2};#",
3177  1000,
3178  0,
3179  2.0);
3180  fHistoList_bg_all.push_back(Case8NonElFrom_eta_all);
3181  Case8NonElFrom_kaon_all =
3182  new TH1D("Case8NonElFrom_kaon_all",
3183  "Case8NonElFrom_kaon_all; invariant mass in GeV/c^{2};#",
3184  1000,
3185  0,
3186  2.0);
3187  fHistoList_bg_all.push_back(Case8NonElFrom_kaon_all);
3188  sameMIDcase8NonEPdg_all = new TH1D("sameMIDcase8NonEPdg_all",
3189  "sameMIDcase8NonEPdg_all; Id ;#",
3190  5000,
3191  -2500,
3192  2500);
3193  fHistoList_bg_all.push_back(sameMIDcase8NonEPdg_all);
3194  sameMIDcase8NonEMotherPdg_all =
3195  new TH1D("sameMIDcase8NonEMotherPdg_all",
3196  "sameMIDcase8NonEMotherPdg_all; Id ;#",
3197  5000,
3198  -2500,
3199  2500);
3200  fHistoList_bg_all.push_back(sameMIDcase8NonEMotherPdg_all);
3201  sameMIDcase8NonEMotherIM_all =
3202  new TH1D("sameMIDcase8NonEMotherIM_all",
3203  "sameMIDcase8NonEMotherIM_all; invariant mass in GeV/c^{2};#",
3204  1000,
3205  0,
3206  2.0);
3207  fHistoList_bg_all.push_back(sameMIDcase8NonEMotherIM_all);
3208  sameMIDcase8NonEPdgFromTarget_all =
3209  new TH1D("sameMIDcase8NonEPdgFromTarget_all",
3210  "sameMIDcase8NonEPdgFromTarget_all; Id ;#",
3211  5000,
3212  -2500,
3213  2500);
3214  fHistoList_bg_all.push_back(sameMIDcase8NonEPdgFromTarget_all);
3215  sameMIDcase8NonEComeFromTargetIM_all = new TH1D(
3216  "sameMIDcase8NonEComeFromTargetIM_all",
3217  "sameMIDcase8NonEComeFromTargetIM_all; invariant mass in GeV/c^{2};#",
3218  1000,
3219  0,
3220  2.0);
3221  fHistoList_bg_all.push_back(sameMIDcase8NonEComeFromTargetIM_all);
3222  sameMIDcase8NonEComeFromTargetP_all =
3223  new TH1D("sameMIDcase8NonEComeFromTargetP_all",
3224  "sameMIDcase8NonEComeFromTargetP_all; P in GeV/c^{2} ;#",
3225  200,
3226  0,
3227  10);
3228  fHistoList_bg_all.push_back(sameMIDcase8NonEComeFromTargetP_all);
3229  sameMIDcase8NonEComeFromTargetPt_all =
3230  new TH1D("sameMIDcase8NonEComeFromTargetPt_all",
3231  "sameMIDcase8NonEComeFromTargetPt_all; Pt in GeV/c^{2} ;#",
3232  200,
3233  0,
3234  10);
3235  fHistoList_bg_all.push_back(sameMIDcase8NonEComeFromTargetPt_all);
3236  //Both zero
3237  BG1_zero = new TH1D(
3238  "BG1_zero", "BG1_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3239  fHistoList_bg_zero.push_back(BG1_zero);
3240  BG2_zero = new TH1D(
3241  "BG2_zero", "BG2_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3242  fHistoList_bg_zero.push_back(BG2_zero);
3243  BG3_zero = new TH1D(
3244  "BG3_zero", "BG3_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3245  fHistoList_bg_zero.push_back(BG3_zero);
3246  BG4_zero = new TH1D(
3247  "BG4_zero", "BG4_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3248  fHistoList_bg_zero.push_back(BG4_zero);
3249  BG5_zero = new TH1D(
3250  "BG5_zero", "BG5_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3251  fHistoList_bg_zero.push_back(BG5_zero);
3252  BG6_zero = new TH1D(
3253  "BG6_zero", "BG6_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3254  fHistoList_bg_zero.push_back(BG6_zero);
3255  BG7_zero = new TH1D(
3256  "BG7_zero", "BG7_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3257  fHistoList_bg_zero.push_back(BG7_zero);
3258  BG8_zero = new TH1D(
3259  "BG8_zero", "BG8_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3260  fHistoList_bg_zero.push_back(BG8_zero);
3261  BG9_zero = new TH1D(
3262  "BG9_zero", "BG9_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3263  fHistoList_bg_zero.push_back(BG9_zero);
3264  BG10_zero = new TH1D(
3265  "BG10_zero", "BG10_zero; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3266  fHistoList_bg_zero.push_back(BG10_zero);
3267  PdgCase8_zero =
3268  new TH1D("PdgCase8_zero", "PdgCase8_zero; Id ;#", 5000, -2500, 2500);
3269  fHistoList_bg_zero.push_back(PdgCase8_zero);
3270  PdgCase8mothers_zero = new TH1D(
3271  "PdgCase8mothers_zero", "PdgCase8mothers_zero; Id ;#", 5000, -2500, 2500);
3272  fHistoList_bg_zero.push_back(PdgCase8mothers_zero);
3273  sameMIDcase8_zero =
3274  new TH1D("sameMIDcase8_zero",
3275  "sameMIDcase8_zero; invariant mass in GeV/c^{2};#",
3276  1000,
3277  0,
3278  2.0);
3279  fHistoList_bg_zero.push_back(sameMIDcase8_zero);
3280  sameGRIDcase8_zero =
3281  new TH1D("sameGRIDcase8_zero",
3282  "sameGRIDcase8_zero; invariant mass in GeV/c^{2};#",
3283  1000,
3284  0,
3285  2.0);
3286  fHistoList_bg_zero.push_back(sameGRIDcase8_zero);
3287  Case1ZYPos_zero = new TH2D("Case1ZYPos_zero",
3288  "Case1ZYPos_zero; z[cm]; y[cm]",
3289  400,
3290  -1,
3291  200,
3292  200,
3293  -50,
3294  50);
3295  fHistoList_bg_zero.push_back(Case1ZYPos_zero);
3296  sameMIDcase8_mothedPDG_zero = new TH1D("sameMIDcase8_mothedPDG_zero",
3297  "sameMIDcase8_mothedPDG_zero; Id ;#",
3298  5000,
3299  -2500,
3300  2500);
3301  fHistoList_bg_zero.push_back(sameMIDcase8_mothedPDG_zero);
3302  PdgCase8NonEComeFromTarget_zero =
3303  new TH1D("PdgCase8NonEComeFromTarget_zero",
3304  "PdgCase8NonEComeFromTarget_zero; Id ;#",
3305  5000,
3306  -2500,
3307  2500);
3308  fHistoList_bg_zero.push_back(PdgCase8NonEComeFromTarget_zero);
3309  PdgCase8NonE_NOT_FromTarget_zero =
3310  new TH1D("PdgCase8NonE_NOT_FromTarget_zero",
3311  "PdgCase8NonE_NOT_FromTarget_zero; Id ;#",
3312  5000,
3313  -2500,
3314  2500);
3315  fHistoList_bg_zero.push_back(PdgCase8NonE_NOT_FromTarget_zero);
3316  PdgCase8motherNonE_zero = new TH1D("PdgCase8motherNonE_zero",
3317  "PdgCase8motherNonE_zero; Id ;#",
3318  5000,
3319  -2500,
3320  2500);
3321  fHistoList_bg_zero.push_back(PdgCase8motherNonE_zero);
3322  Case8ElFromDalitz_zero =
3323  new TH1D("Case8ElFromDalitz_zero",
3324  "Case8ElFromDalitz_zero; invariant mass in GeV/c^{2};#",
3325  1000,
3326  0,
3327  2.0);
3328  fHistoList_bg_zero.push_back(Case8ElFromDalitz_zero);
3329  Case8NonElFrom_pn_zero =
3330  new TH1D("Case8NonElFrom_pn_zero",
3331  "Case8NonElFrom_pn_zero; invariant mass in GeV/c^{2};#",
3332  1000,
3333  0,
3334  2.0);
3335  fHistoList_bg_zero.push_back(Case8NonElFrom_pn_zero);
3336  Case8NonElFrom_eta_zero =
3337  new TH1D("Case8NonElFrom_eta_zero",
3338  "Case8NonElFrom_eta_zero; invariant mass in GeV/c^{2};#",
3339  1000,
3340  0,
3341  2.0);
3342  fHistoList_bg_zero.push_back(Case8NonElFrom_eta_zero);
3343  Case8NonElFrom_kaon_zero =
3344  new TH1D("Case8NonElFrom_kaon_zero",
3345  "Case8NonElFrom_kaon_zero; invariant mass in GeV/c^{2};#",
3346  1000,
3347  0,
3348  2.0);
3349  fHistoList_bg_zero.push_back(Case8NonElFrom_kaon_zero);
3350  sameMIDcase8NonEPdg_zero = new TH1D("sameMIDcase8NonEPdg_zero",
3351  "sameMIDcase8NonEPdg_zero; Id ;#",
3352  5000,
3353  -2500,
3354  2500);
3355  fHistoList_bg_zero.push_back(sameMIDcase8NonEPdg_zero);
3356  sameMIDcase8NonEMotherPdg_zero =
3357  new TH1D("sameMIDcase8NonEMotherPdg_zero",
3358  "sameMIDcase8NonEMotherPdg_zero; Id ;#",
3359  5000,
3360  -2500,
3361  2500);
3362  fHistoList_bg_zero.push_back(sameMIDcase8NonEMotherPdg_zero);
3363  sameMIDcase8NonEMotherIM_zero =
3364  new TH1D("sameMIDcase8NonEMotherIM_zero",
3365  "sameMIDcase8NonEMotherIM_zero; invariant mass in GeV/c^{2};#",
3366  1000,
3367  0,
3368  2.0);
3369  fHistoList_bg_zero.push_back(sameMIDcase8NonEMotherIM_zero);
3370  sameMIDcase8NonEPdgFromTarget_zero =
3371  new TH1D("sameMIDcase8NonEPdgFromTarget_zero",
3372  "sameMIDcase8NonEPdgFromTarget_zero; Id ;#",
3373  5000,
3374  -2500,
3375  2500);
3376  fHistoList_bg_zero.push_back(sameMIDcase8NonEPdgFromTarget_zero);
3377  sameMIDcase8NonEComeFromTargetIM_zero = new TH1D(
3378  "sameMIDcase8NonEComeFromTargetIM_zero",
3379  "sameMIDcase8NonEComeFromTargetIM_zero; invariant mass in GeV/c^{2};#",
3380  1000,
3381  0,
3382  2.0);
3383  fHistoList_bg_zero.push_back(sameMIDcase8NonEComeFromTargetIM_zero);
3384  sameMIDcase8NonEComeFromTargetP_zero =
3385  new TH1D("sameMIDcase8NonEComeFromTargetP_zero",
3386  "sameMIDcase8NonEComeFromTargetP_zero; P in GeV/c^{2} ;#",
3387  200,
3388  0,
3389  10);
3390  fHistoList_bg_zero.push_back(sameMIDcase8NonEComeFromTargetP_zero);
3391  sameMIDcase8NonEComeFromTargetPt_zero =
3392  new TH1D("sameMIDcase8NonEComeFromTargetPt_zero",
3393  "sameMIDcase8NonEComeFromTargetPt_zero; Pt in GeV/c^{2} ;#",
3394  200,
3395  0,
3396  10);
3397  fHistoList_bg_zero.push_back(sameMIDcase8NonEComeFromTargetPt_zero);
3398  //Both one
3399  BG1_one =
3400  new TH1D("BG1_one", "BG1_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3401  fHistoList_bg_one.push_back(BG1_one);
3402  BG2_one =
3403  new TH1D("BG2_one", "BG2_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3404  fHistoList_bg_one.push_back(BG2_one);
3405  BG3_one =
3406  new TH1D("BG3_one", "BG3_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3407  fHistoList_bg_one.push_back(BG3_one);
3408  BG4_one =
3409  new TH1D("BG4_one", "BG4_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3410  fHistoList_bg_one.push_back(BG4_one);
3411  BG5_one =
3412  new TH1D("BG5_one", "BG5_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3413  fHistoList_bg_one.push_back(BG5_one);
3414  BG6_one =
3415  new TH1D("BG6_one", "BG6_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3416  fHistoList_bg_one.push_back(BG6_one);
3417  BG7_one =
3418  new TH1D("BG7_one", "BG7_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3419  fHistoList_bg_one.push_back(BG7_one);
3420  BG8_one =
3421  new TH1D("BG8_one", "BG8_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3422  fHistoList_bg_one.push_back(BG8_one);
3423  BG9_one =
3424  new TH1D("BG9_one", "BG9_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3425  fHistoList_bg_one.push_back(BG9_one);
3426  BG10_one = new TH1D(
3427  "BG10_one", "BG10_one; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3428  fHistoList_bg_one.push_back(BG10_one);
3429  PdgCase8_one =
3430  new TH1D("PdgCase8_one", "PdgCase8_one; Id ;#", 5000, -2500, 2500);
3431  fHistoList_bg_one.push_back(PdgCase8_one);
3432  PdgCase8mothers_one = new TH1D(
3433  "PdgCase8mothers_one", "PdgCase8mothers_one; Id ;#", 5000, -2500, 2500);
3434  fHistoList_bg_one.push_back(PdgCase8mothers_one);
3435  sameMIDcase8_one = new TH1D("sameMIDcase8_one",
3436  "sameMIDcase8_one; invariant mass in GeV/c^{2};#",
3437  1000,
3438  0,
3439  2.0);
3440  fHistoList_bg_one.push_back(sameMIDcase8_one);
3441  sameGRIDcase8_one =
3442  new TH1D("sameGRIDcase8_one",
3443  "sameGRIDcase8_one; invariant mass in GeV/c^{2};#",
3444  1000,
3445  0,
3446  2.0);
3447  fHistoList_bg_one.push_back(sameGRIDcase8_one);
3448  Case1ZYPos_one = new TH2D("Case1ZYPos_one",
3449  "Case1ZYPos_one; z[cm]; y[cm]",
3450  400,
3451  -1,
3452  200,
3453  200,
3454  -50,
3455  50);
3456  fHistoList_bg_one.push_back(Case1ZYPos_one);
3457  sameMIDcase8_mothedPDG_one = new TH1D("sameMIDcase8_mothedPDG_one",
3458  "sameMIDcase8_mothedPDG_one; Id ;#",
3459  5000,
3460  -2500,
3461  2500);
3462  fHistoList_bg_one.push_back(sameMIDcase8_mothedPDG_one);
3463  PdgCase8NonEComeFromTarget_one =
3464  new TH1D("PdgCase8NonEComeFromTarget_one",
3465  "PdgCase8NonEComeFromTarget_one; Id ;#",
3466  5000,
3467  -2500,
3468  2500);
3469  fHistoList_bg_one.push_back(PdgCase8NonEComeFromTarget_one);
3470  PdgCase8NonE_NOT_FromTarget_one =
3471  new TH1D("PdgCase8NonE_NOT_FromTarget_one",
3472  "PdgCase8NonE_NOT_FromTarget_one; Id ;#",
3473  5000,
3474  -2500,
3475  2500);
3476  fHistoList_bg_one.push_back(PdgCase8NonE_NOT_FromTarget_one);
3477  PdgCase8motherNonE_one = new TH1D("PdgCase8motherNonE_one",
3478  "PdgCase8motherNonE_one; Id ;#",
3479  5000,
3480  -2500,
3481  2500);
3482  fHistoList_bg_one.push_back(PdgCase8motherNonE_one);
3483  Case8ElFromDalitz_one =
3484  new TH1D("Case8ElFromDalitz_one",
3485  "Case8ElFromDalitz_one; invariant mass in GeV/c^{2};#",
3486  1000,
3487  0,
3488  2.0);
3489  fHistoList_bg_one.push_back(Case8ElFromDalitz_one);
3490  Case8NonElFrom_pn_one =
3491  new TH1D("Case8NonElFrom_pn_one",
3492  "Case8NonElFrom_pn_one; invariant mass in GeV/c^{2};#",
3493  1000,
3494  0,
3495  2.0);
3496  fHistoList_bg_one.push_back(Case8NonElFrom_pn_one);
3497  Case8NonElFrom_eta_one =
3498  new TH1D("Case8NonElFrom_eta_one",
3499  "Case8NonElFrom_eta_one; invariant mass in GeV/c^{2};#",
3500  1000,
3501  0,
3502  2.0);
3503  fHistoList_bg_one.push_back(Case8NonElFrom_eta_one);
3504  Case8NonElFrom_kaon_one =
3505  new TH1D("Case8NonElFrom_kaon_one",
3506  "Case8NonElFrom_kaon_one; invariant mass in GeV/c^{2};#",
3507  1000,
3508  0,
3509  2.0);
3510  fHistoList_bg_one.push_back(Case8NonElFrom_kaon_one);
3511  sameMIDcase8NonEPdg_one = new TH1D("sameMIDcase8NonEPdg_one",
3512  "sameMIDcase8NonEPdg_one; Id ;#",
3513  5000,
3514  -2500,
3515  2500);
3516  fHistoList_bg_one.push_back(sameMIDcase8NonEPdg_one);
3517  sameMIDcase8NonEMotherPdg_one =
3518  new TH1D("sameMIDcase8NonEMotherPdg_one",
3519  "sameMIDcase8NonEMotherPdg_one; Id ;#",
3520  5000,
3521  -2500,
3522  2500);
3523  fHistoList_bg_one.push_back(sameMIDcase8NonEMotherPdg_one);
3524  sameMIDcase8NonEMotherIM_one =
3525  new TH1D("sameMIDcase8NonEMotherIM_one",
3526  "sameMIDcase8NonEMotherIM_one; invariant mass in GeV/c^{2};#",
3527  1000,
3528  0,
3529  2.0);
3530  fHistoList_bg_one.push_back(sameMIDcase8NonEMotherIM_one);
3531  sameMIDcase8NonEPdgFromTarget_one =
3532  new TH1D("sameMIDcase8NonEPdgFromTarget_one",
3533  "sameMIDcase8NonEPdgFromTarget_one; Id ;#",
3534  5000,
3535  -2500,
3536  2500);
3537  fHistoList_bg_one.push_back(sameMIDcase8NonEPdgFromTarget_one);
3538  sameMIDcase8NonEComeFromTargetIM_one = new TH1D(
3539  "sameMIDcase8NonEComeFromTargetIM_one",
3540  "sameMIDcase8NonEComeFromTargetIM_one; invariant mass in GeV/c^{2};#",
3541  1000,
3542  0,
3543  2.0);
3544  fHistoList_bg_one.push_back(sameMIDcase8NonEComeFromTargetIM_one);
3545  sameMIDcase8NonEComeFromTargetP_one =
3546  new TH1D("sameMIDcase8NonEComeFromTargetP_one",
3547  "sameMIDcase8NonEComeFromTargetP_one; P in GeV/c^{2} ;#",
3548  200,
3549  0,
3550  10);
3551  fHistoList_bg_one.push_back(sameMIDcase8NonEComeFromTargetP_one);
3552  sameMIDcase8NonEComeFromTargetPt_one =
3553  new TH1D("sameMIDcase8NonEComeFromTargetPt_one",
3554  "sameMIDcase8NonEComeFromTargetPt_one; Pt in GeV/c^{2} ;#",
3555  200,
3556  0,
3557  10);
3558  fHistoList_bg_one.push_back(sameMIDcase8NonEComeFromTargetPt_one);
3559  //Both two
3560  BG1_two =
3561  new TH1D("BG1_two", "BG1_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3562  fHistoList_bg_two.push_back(BG1_two);
3563  BG2_two =
3564  new TH1D("BG2_two", "BG2_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3565  fHistoList_bg_two.push_back(BG2_two);
3566  BG3_two =
3567  new TH1D("BG3_two", "BG3_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3568  fHistoList_bg_two.push_back(BG3_two);
3569  BG4_two =
3570  new TH1D("BG4_two", "BG4_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3571  fHistoList_bg_two.push_back(BG4_two);
3572  BG5_two =
3573  new TH1D("BG5_two", "BG5_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3574  fHistoList_bg_two.push_back(BG5_two);
3575  BG6_two =
3576  new TH1D("BG6_two", "BG6_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3577  fHistoList_bg_two.push_back(BG6_two);
3578  BG7_two =
3579  new TH1D("BG7_two", "BG7_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3580  fHistoList_bg_two.push_back(BG7_two);
3581  BG8_two =
3582  new TH1D("BG8_two", "BG8_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3583  fHistoList_bg_two.push_back(BG8_two);
3584  BG9_two =
3585  new TH1D("BG9_two", "BG9_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3586  fHistoList_bg_two.push_back(BG9_two);
3587  BG10_two = new TH1D(
3588  "BG10_two", "BG10_two; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3589  fHistoList_bg_two.push_back(BG10_two);
3590  PdgCase8_two =
3591  new TH1D("PdgCase8_two", "PdgCase8_two; Id ;#", 5000, -2500, 2500);
3592  fHistoList_bg_two.push_back(PdgCase8_two);
3593  PdgCase8mothers_two = new TH1D(
3594  "PdgCase8mothers_two", "PdgCase8mothers_two; Id ;#", 5000, -2500, 2500);
3595  fHistoList_bg_two.push_back(PdgCase8mothers_two);
3596  sameMIDcase8_two = new TH1D("sameMIDcase8_two",
3597  "sameMIDcase8_two; invariant mass in GeV/c^{2};#",
3598  1000,
3599  0,
3600  2.0);
3601  fHistoList_bg_two.push_back(sameMIDcase8_two);
3602  sameGRIDcase8_two =
3603  new TH1D("sameGRIDcase8_two",
3604  "sameGRIDcase8_two; invariant mass in GeV/c^{2};#",
3605  1000,
3606  0,
3607  2.0);
3608  fHistoList_bg_two.push_back(sameGRIDcase8_two);
3609  Case1ZYPos_two = new TH2D("Case1ZYPos_two",
3610  "Case1ZYPos_two; z[cm]; y[cm]",
3611  400,
3612  -1,
3613  200,
3614  200,
3615  -50,
3616  50);
3617  fHistoList_bg_two.push_back(Case1ZYPos_two);
3618  sameMIDcase8_mothedPDG_two = new TH1D("sameMIDcase8_mothedPDG_two",
3619  "sameMIDcase8_mothedPDG_two; Id ;#",
3620  5000,
3621  -2500,
3622  2500);
3623  fHistoList_bg_two.push_back(sameMIDcase8_mothedPDG_two);
3624  PdgCase8NonEComeFromTarget_two =
3625  new TH1D("PdgCase8NonEComeFromTarget_two",
3626  "PdgCase8NonEComeFromTarget_two; Id ;#",
3627  5000,
3628  -2500,
3629  2500);
3630  fHistoList_bg_two.push_back(PdgCase8NonEComeFromTarget_two);
3631  PdgCase8NonE_NOT_FromTarget_two =
3632  new TH1D("PdgCase8NonE_NOT_FromTarget_two",
3633  "PdgCase8NonE_NOT_FromTarget_two; Id ;#",
3634  5000,
3635  -2500,
3636  2500);
3637  fHistoList_bg_two.push_back(PdgCase8NonE_NOT_FromTarget_two);
3638  PdgCase8motherNonE_two = new TH1D("PdgCase8motherNonE_two",
3639  "PdgCase8motherNonE_two; Id ;#",
3640  5000,
3641  -2500,
3642  2500);
3643  fHistoList_bg_two.push_back(PdgCase8motherNonE_two);
3644  Case8ElFromDalitz_two =
3645  new TH1D("Case8ElFromDalitz_two",
3646  "Case8ElFromDalitz_two; invariant mass in GeV/c^{2};#",
3647  1000,
3648  0,
3649  2.0);
3650  fHistoList_bg_two.push_back(Case8ElFromDalitz_two);
3651  Case8NonElFrom_pn_two =
3652  new TH1D("Case8NonElFrom_pn_two",
3653  "Case8NonElFrom_pn_two; invariant mass in GeV/c^{2};#",
3654  1000,
3655  0,
3656  2.0);
3657  fHistoList_bg_two.push_back(Case8NonElFrom_pn_two);
3658  Case8NonElFrom_eta_two =
3659  new TH1D("Case8NonElFrom_eta_two",
3660  "Case8NonElFrom_eta_two; invariant mass in GeV/c^{2};#",
3661  1000,
3662  0,
3663  2.0);
3664  fHistoList_bg_two.push_back(Case8NonElFrom_eta_two);
3665  Case8NonElFrom_kaon_two =
3666  new TH1D("Case8NonElFrom_kaon_two",
3667  "Case8NonElFrom_kaon_two; invariant mass in GeV/c^{2};#",
3668  1000,
3669  0,
3670  2.0);
3671  fHistoList_bg_two.push_back(Case8NonElFrom_kaon_two);
3672  sameMIDcase8NonEPdg_two = new TH1D("sameMIDcase8NonEPdg_two",
3673  "sameMIDcase8NonEPdg_two; Id ;#",
3674  5000,
3675  -2500,
3676  2500);
3677  fHistoList_bg_two.push_back(sameMIDcase8NonEPdg_two);
3678  sameMIDcase8NonEMotherPdg_two =
3679  new TH1D("sameMIDcase8NonEMotherPdg_two",
3680  "sameMIDcase8NonEMotherPdg_two; Id ;#",
3681  5000,
3682  -2500,
3683  2500);
3684  fHistoList_bg_two.push_back(sameMIDcase8NonEMotherPdg_two);
3685  sameMIDcase8NonEMotherIM_two =
3686  new TH1D("sameMIDcase8NonEMotherIM_two",
3687  "sameMIDcase8NonEMotherIM_two; invariant mass in GeV/c^{2};#",
3688  1000,
3689  0,
3690  2.0);
3691  fHistoList_bg_two.push_back(sameMIDcase8NonEMotherIM_two);
3692  sameMIDcase8NonEPdgFromTarget_two =
3693  new TH1D("sameMIDcase8NonEPdgFromTarget_two",
3694  "sameMIDcase8NonEPdgFromTarget_two; Id ;#",
3695  5000,
3696  -2500,
3697  2500);
3698  fHistoList_bg_two.push_back(sameMIDcase8NonEPdgFromTarget_two);
3699  sameMIDcase8NonEComeFromTargetIM_two = new TH1D(
3700  "sameMIDcase8NonEComeFromTargetIM_two",
3701  "sameMIDcase8NonEComeFromTargetIM_two; invariant mass in GeV/c^{2};#",
3702  1000,
3703  0,
3704  2.0);
3705  fHistoList_bg_two.push_back(sameMIDcase8NonEComeFromTargetIM_two);
3706  sameMIDcase8NonEComeFromTargetP_two =
3707  new TH1D("sameMIDcase8NonEComeFromTargetP_two",
3708  "sameMIDcase8NonEComeFromTargetP_two; P in GeV/c^{2} ;#",
3709  200,
3710  0,
3711  10);
3712  fHistoList_bg_two.push_back(sameMIDcase8NonEComeFromTargetP_two);
3713  sameMIDcase8NonEComeFromTargetPt_two =
3714  new TH1D("sameMIDcase8NonEComeFromTargetPt_two",
3715  "sameMIDcase8NonEComeFromTargetPt_two; Pt in GeV/c^{2} ;#",
3716  200,
3717  0,
3718  10);
3719  fHistoList_bg_two.push_back(sameMIDcase8NonEComeFromTargetPt_two);
3720  //Both onetwo
3721  BG1_onetwo = new TH1D(
3722  "BG1_onetwo", "BG1_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3723  fHistoList_bg_onetwo.push_back(BG1_onetwo);
3724  BG2_onetwo = new TH1D(
3725  "BG2_onetwo", "BG2_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3726  fHistoList_bg_onetwo.push_back(BG2_onetwo);
3727  BG3_onetwo = new TH1D(
3728  "BG3_onetwo", "BG3_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3729  fHistoList_bg_onetwo.push_back(BG3_onetwo);
3730  BG4_onetwo = new TH1D(
3731  "BG4_onetwo", "BG4_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3732  fHistoList_bg_onetwo.push_back(BG4_onetwo);
3733  BG5_onetwo = new TH1D(
3734  "BG5_onetwo", "BG5_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3735  fHistoList_bg_onetwo.push_back(BG5_onetwo);
3736  BG6_onetwo = new TH1D(
3737  "BG6_onetwo", "BG6_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3738  fHistoList_bg_onetwo.push_back(BG6_onetwo);
3739  BG7_onetwo = new TH1D(
3740  "BG7_onetwo", "BG7_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3741  fHistoList_bg_onetwo.push_back(BG7_onetwo);
3742  BG8_onetwo = new TH1D(
3743  "BG8_onetwo", "BG8_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3744  fHistoList_bg_onetwo.push_back(BG8_onetwo);
3745  BG9_onetwo = new TH1D(
3746  "BG9_onetwo", "BG9_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3747  fHistoList_bg_onetwo.push_back(BG9_onetwo);
3748  BG10_onetwo = new TH1D(
3749  "BG10_onetwo", "BG10_onetwo; invariant mass in GeV/c^{2};#", 1000, 0, 2.0);
3750  fHistoList_bg_onetwo.push_back(BG10_onetwo);
3751  PdgCase8_onetwo =
3752  new TH1D("PdgCase8_onetwo", "PdgCase8_onetwo; Id ;#", 5000, -2500, 2500);
3753  fHistoList_bg_onetwo.push_back(PdgCase8_onetwo);
3754  PdgCase8mothers_onetwo = new TH1D("PdgCase8mothers_onetwo",
3755  "PdgCase8mothers_onetwo; Id ;#",
3756  5000,
3757  -2500,
3758  2500);
3759  fHistoList_bg_onetwo.push_back(PdgCase8mothers_onetwo);
3760  sameMIDcase8_onetwo =
3761  new TH1D("sameMIDcase8_onetwo",
3762  "sameMIDcase8_onetwo; invariant mass in GeV/c^{2};#",
3763  1000,
3764  0,
3765  2.0);
3766  fHistoList_bg_onetwo.push_back(sameMIDcase8_onetwo);
3767  sameGRIDcase8_onetwo =
3768  new TH1D("sameGRIDcase8_onetwo",
3769  "sameGRIDcase8_onetwo; invariant mass in GeV/c^{2};#",
3770  1000,
3771  0,
3772  2.0);
3773  fHistoList_bg_onetwo.push_back(sameGRIDcase8_onetwo);
3774  Case1ZYPos_onetwo = new TH2D("Case1ZYPos_onetwo",
3775  "Case1ZYPos_onetwo; z[cm]; y[cm]",
3776  400,
3777  -1,
3778  200,
3779  200,
3780  -50,
3781  50);
3782  fHistoList_bg_onetwo.push_back(Case1ZYPos_onetwo);
3783  sameMIDcase8_mothedPDG_onetwo =
3784  new TH1D("sameMIDcase8_mothedPDG_onetwo",
3785  "sameMIDcase8_mothedPDG_onetwo; Id ;#",
3786  5000,
3787  -2500,
3788  2500);
3789  fHistoList_bg_onetwo.push_back(sameMIDcase8_mothedPDG_onetwo);
3790  PdgCase8NonEComeFromTarget_onetwo =
3791  new TH1D("PdgCase8NonEComeFromTarget_onetwo",
3792  "PdgCase8NonEComeFromTarget_onetwo; Id ;#",
3793  5000,
3794  -2500,
3795  2500);
3796  fHistoList_bg_onetwo.push_back(PdgCase8NonEComeFromTarget_onetwo);
3797  PdgCase8NonE_NOT_FromTarget_onetwo =
3798  new TH1D("PdgCase8NonE_NOT_FromTarget_onetwo",
3799  "PdgCase8NonE_NOT_FromTarget_onetwo; Id ;#",
3800  5000,
3801  -2500,
3802  2500);
3803  fHistoList_bg_onetwo.push_back(PdgCase8NonE_NOT_FromTarget_onetwo);
3804  PdgCase8motherNonE_onetwo = new TH1D("PdgCase8motherNonE_onetwo",
3805  "PdgCase8motherNonE_onetwo; Id ;#",
3806  5000,
3807  -2500,
3808  2500);
3809  fHistoList_bg_onetwo.push_back(PdgCase8motherNonE_onetwo);
3810  Case8ElFromDalitz_onetwo =
3811  new TH1D("Case8ElFromDalitz_onetwo",
3812  "Case8ElFromDalitz_onetwo; invariant mass in GeV/c^{2};#",
3813  1000,
3814  0,
3815  2.0);
3816  fHistoList_bg_onetwo.push_back(Case8ElFromDalitz_onetwo);
3817  Case8NonElFrom_pn_onetwo =
3818  new TH1D("Case8NonElFrom_pn_onetwo",
3819  "Case8NonElFrom_pn_onetwo; invariant mass in GeV/c^{2};#",
3820  1000,
3821  0,
3822  2.0);
3823  fHistoList_bg_onetwo.push_back(Case8NonElFrom_pn_onetwo);
3824  Case8NonElFrom_eta_onetwo =
3825  new TH1D("Case8NonElFrom_eta_onetwo",
3826  "Case8NonElFrom_eta_onetwo; invariant mass in GeV/c^{2};#",
3827  1000,
3828  0,
3829  2.0);
3830  fHistoList_bg_onetwo.push_back(Case8NonElFrom_eta_onetwo);
3831  Case8NonElFrom_kaon_onetwo =
3832  new TH1D("Case8NonElFrom_kaon_onetwo",
3833  "Case8NonElFrom_kaon_onetwo; invariant mass in GeV/c^{2};#",
3834  1000,
3835  0,
3836  2.0);
3837  fHistoList_bg_onetwo.push_back(Case8NonElFrom_kaon_onetwo);
3838  sameMIDcase8NonEPdg_onetwo = new TH1D("sameMIDcase8NonEPdg_onetwo",
3839  "sameMIDcase8NonEPdg_onetwo; Id ;#",
3840  5000,
3841  -2500,
3842  2500);
3843  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEPdg_onetwo);
3844  sameMIDcase8NonEMotherPdg_onetwo =
3845  new TH1D("sameMIDcase8NonEMotherPdg_onetwo",
3846  "sameMIDcase8NonEMotherPdg_onetwo; Id ;#",
3847  5000,
3848  -2500,
3849  2500);
3850  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEMotherPdg_onetwo);
3851  sameMIDcase8NonEMotherIM_onetwo =
3852  new TH1D("sameMIDcase8NonEMotherIM_onetwo",
3853  "sameMIDcase8NonEMotherIM_onetwo; invariant mass in GeV/c^{2};#",
3854  1000,
3855  0,
3856  2.0);
3857  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEMotherIM_onetwo);
3858  sameMIDcase8NonEPdgFromTarget_onetwo =
3859  new TH1D("sameMIDcase8NonEPdgFromTarget_onetwo",
3860  "sameMIDcase8NonEPdgFromTarget_onetwo; Id ;#",
3861  5000,
3862  -2500,
3863  2500);
3864  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEPdgFromTarget_onetwo);
3865  sameMIDcase8NonEComeFromTargetIM_onetwo = new TH1D(
3866  "sameMIDcase8NonEComeFromTargetIM_onetwo",
3867  "sameMIDcase8NonEComeFromTargetIM_onetwo; invariant mass in GeV/c^{2};#",
3868  1000,
3869  0,
3870  2.0);
3871  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEComeFromTargetIM_onetwo);
3872  sameMIDcase8NonEComeFromTargetP_onetwo =
3873  new TH1D("sameMIDcase8NonEComeFromTargetP_onetwo",
3874  "sameMIDcase8NonEComeFromTargetP_onetwo; P in GeV/c^{2} ;#",
3875  200,
3876  0,
3877  10);
3878  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEComeFromTargetP_onetwo);
3879  sameMIDcase8NonEComeFromTargetPt_onetwo =
3880  new TH1D("sameMIDcase8NonEComeFromTargetPt_onetwo",
3881  "sameMIDcase8NonEComeFromTargetPt_onetwo; Pt in GeV/c^{2} ;#",
3882  200,
3883  0,
3884  10);
3885  fHistoList_bg_onetwo.push_back(sameMIDcase8NonEComeFromTargetPt_onetwo);
3886 }
CbmKresConversionKF::PdgCase8_all
TH1D * PdgCase8_all
Definition: CbmKresConversionKF.h:417
CbmKresConversionKF::sameMIDcase8NonEMotherPdg_all
TH1D * sameMIDcase8NonEMotherPdg_all
Definition: CbmKresConversionKF.h:431
CbmKresConversionKF::fHistoList_All_mvd
vector< TH1 * > fHistoList_All_mvd
Definition: CbmKresConversionKF.h:188
CbmKresConversionKF::fGammaOpeningAngleReco_Two_target
TH1D * fGammaOpeningAngleReco_Two_target
Definition: CbmKresConversionKF.h:287
CbmKresConversionKF::fHistoList_Zero_outside
vector< TH1 * > fHistoList_Zero_outside
Definition: CbmKresConversionKF.h:232
CbmKresConversionKF::EMT_Event_multi_onetwo
std::vector< int > EMT_Event_multi_onetwo
Definition: CbmKresConversionKF.h:138
CbmKresConversionKF::fPi0_pt_vs_rap_est_All
TH2D * fPi0_pt_vs_rap_est_All
Definition: CbmKresConversionKF.h:180
CbmKresConversionKF::CheckForCuts_OA_Reco
TH1D * CheckForCuts_OA_Reco
Definition: CbmKresConversionKF.h:153
CbmKresConversionKF::fGammaOpeningAngleReco_Two_sts
TH1D * fGammaOpeningAngleReco_Two_sts
Definition: CbmKresConversionKF.h:298
CbmKresConversionKF::sameMIDcase8NonEMotherPdg_onetwo
TH1D * sameMIDcase8NonEMotherPdg_onetwo
Definition: CbmKresConversionKF.h:559
CbmKresConversionKF::InitHistograms
void InitHistograms()
Definition: CbmKresConversionKF.cxx:1762
CbmMCTrack::GetMotherId
Int_t GetMotherId() const
Definition: CbmMCTrack.h:71
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition: CbmMatch.h:37
CbmKresConversionKF::fPt_reco_Two
TH1D * fPt_reco_Two
Definition: CbmKresConversionKF.h:279
CbmKresConversionKF::EMTMulti_InvMass_All_m2
TH1D * EMTMulti_InvMass_All_m2
Definition: CbmKresConversionKF.h:365
CbmKresConversionKF::fGammaInvMassReco_OneTwo_sts
TH1D * fGammaInvMassReco_OneTwo_sts
Definition: CbmKresConversionKF.h:331
CbmKresConversionKF::PdgCase8mothers_zero
TH1D * PdgCase8mothers_zero
Definition: CbmKresConversionKF.h:450
CbmKresConversionKF::sameMIDcase8NonEPdg_all
TH1D * sameMIDcase8NonEPdg_all
Definition: CbmKresConversionKF.h:430
CbmKresConversionKF::Case8NonElFrom_kaon_all
TH1D * Case8NonElFrom_kaon_all
Definition: CbmKresConversionKF.h:429
CbmKresConversionKF::PdgCase8_onetwo
TH1D * PdgCase8_onetwo
Definition: CbmKresConversionKF.h:545
CbmKresConversionKF::CheckForCuts_InvMass_MC
TH1D * CheckForCuts_InvMass_MC
Definition: CbmKresConversionKF.h:150
CbmKresConversionKF::fP_reco_One
TH1D * fP_reco_One
Definition: CbmKresConversionKF.h:243
CbmKresConversionKF::GammasZeroZ
std::vector< Double_t > GammasZeroZ
Definition: CbmKresConversionKF.h:113
CbmKresConversionKF::Case8ElFromDalitz_zero
TH1D * Case8ElFromDalitz_zero
Definition: CbmKresConversionKF.h:458
CbmKresConversionKF::PdgCase8motherNonE_all
TH1D * PdgCase8motherNonE_all
Definition: CbmKresConversionKF.h:425
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m4
TH1D * EMTMulti_InvMass_OneTwo_m4
Definition: CbmKresConversionKF.h:399
CbmKresConversionKF::Case8NonElFrom_eta_onetwo
TH1D * Case8NonElFrom_eta_onetwo
Definition: CbmKresConversionKF.h:556
CbmKresConversionKF::GammasZeroStsIndex
std::vector< std::vector< int > > GammasZeroStsIndex
Definition: CbmKresConversionKF.h:100
CbmKresConversionKF::fHistoList_multiplicity_One
vector< TH1 * > fHistoList_multiplicity_One
Definition: CbmKresConversionKF.h:359
CbmKresConversionKF::MultiplicityGamma_Zero
TH2D * MultiplicityGamma_Zero
Definition: CbmKresConversionKF.h:345
CbmKresConversionKF::sameMIDcase8NonEMotherPdg_one
TH1D * sameMIDcase8NonEMotherPdg_one
Definition: CbmKresConversionKF.h:495
CbmKresConversionKF.h
CbmKresConversionKF::BG3_two
TH1D * BG3_two
Definition: CbmKresConversionKF.h:505
CbmKresConversionKF::BG2_two
TH1D * BG2_two
Definition: CbmKresConversionKF.h:504
CbmKFParticleFinder.h
CbmKresConversionKF::GammasOneStsIndex
std::vector< std::vector< int > > GammasOneStsIndex
Definition: CbmKresConversionKF.h:101
CbmKresConversionKF::fHistoList_Two_target
vector< TH1 * > fHistoList_Two_target
Definition: CbmKresConversionKF.h:285
CbmKresConversionKF::fGammaInvMassReco_OneTwo_mvd
TH1D * fGammaInvMassReco_OneTwo_mvd
Definition: CbmKresConversionKF.h:326
CbmKresConversionKF::fGammaOpeningAngleReco_Zero_sts
TH1D * fGammaOpeningAngleReco_Zero_sts
Definition: CbmKresConversionKF.h:229
CbmPixelHit::GetX
Double_t GetX() const
Definition: CbmPixelHit.h:83
CbmKresConversionKF::fKFtopo
const KFParticleTopoReconstructor * fKFtopo
Definition: CbmKresConversionKF.h:76
CbmMatch::GetNofLinks
Int_t GetNofLinks() const
Definition: CbmMatch.h:38
CbmKFParticleFinder
Definition: CbmKFParticleFinder.h:26
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m6
TH1D * EMTMulti_InvMass_OneTwo_m6
Definition: CbmKresConversionKF.h:401
CbmKresConversionKF::BG10_all
TH1D * BG10_all
Definition: CbmKresConversionKF.h:416
CbmKresConversionKF::BG9_one
TH1D * BG9_one
Definition: CbmKresConversionKF.h:479
CbmKresConversionKF::fHistoList_All_sts
vector< TH1 * > fHistoList_All_sts
Definition: CbmKresConversionKF.h:193
CbmRichRingFitterEllipseTau
Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov.
Definition: CbmRichRingFitterEllipseTau.h:35
CbmKresConversionKF::fPi0InvMassRecoKF_Two_mvd
TH1D * fPi0InvMassRecoKF_Two_mvd
Definition: CbmKresConversionKF.h:294
CbmKresConversionKF::fHistoList_multiplicity_All
vector< TH1 * > fHistoList_multiplicity_All
Definition: CbmKresConversionKF.h:358
CbmKresConversionKF::fPi0InvMassRecoKF_One_sts
TH1D * fPi0InvMassRecoKF_One_sts
Definition: CbmKresConversionKF.h:264
CbmKresConversionKF::EMT_NofRings
std::vector< int > EMT_NofRings
Definition: CbmKresConversionKF.h:122
CbmPixelHit::GetY
Double_t GetY() const
Definition: CbmPixelHit.h:84
CbmKresConversionKF::fGammaInvMassReco_Two_sts
TH1D * fGammaInvMassReco_Two_sts
Definition: CbmKresConversionKF.h:297
CbmKresConversionKF::fHistoList_One_target
vector< TH1 * > fHistoList_One_target
Definition: CbmKresConversionKF.h:250
CbmKresConversionKF::EMTMulti_InvMass_Two_m3
TH1D * EMTMulti_InvMass_Two_m3
Definition: CbmKresConversionKF.h:390
CbmKresConversionKF::MultiplicityChargedParticles_One
TH2D * MultiplicityChargedParticles_One
Definition: CbmKresConversionKF.h:352
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0
Definition: CbmKresConversionKF.h:156
CbmKresConversionKF::fGammaOpeningAngleReco_One_mvd
TH1D * fGammaOpeningAngleReco_One_mvd
Definition: CbmKresConversionKF.h:258
CbmKresConversionKF::PdgCase8_one
TH1D * PdgCase8_one
Definition: CbmKresConversionKF.h:481
CbmRichRingFitterEllipseTau.h
Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov.
CbmKresConversionKF::EMTMulti_InvMass_One_m6
TH1D * EMTMulti_InvMass_One_m6
Definition: CbmKresConversionKF.h:385
CbmKresConversionKF::fPt_reco_One
TH1D * fPt_reco_One
Definition: CbmKresConversionKF.h:244
CbmKresConversionKF::EMT_pair_momenta_multi_one
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_one
Definition: CbmKresConversionKF.h:130
CbmKresConversionKF::fGammaOpeningAngleReco_All
TH1D * fGammaOpeningAngleReco_All
Definition: CbmKresConversionKF.h:173
CbmKresConversionKF::PdgCase8_zero
TH1D * PdgCase8_zero
Definition: CbmKresConversionKF.h:449
CbmKresConversionKF::GammasOneMC
std::vector< std::vector< CbmMCTrack * > > GammasOneMC
Definition: CbmKresConversionKF.h:108
CbmKresConversionKF::BG2_zero
TH1D * BG2_zero
Definition: CbmKresConversionKF.h:440
CbmKresConversionKF::GammasTwoMC
std::vector< std::vector< CbmMCTrack * > > GammasTwoMC
Definition: CbmKresConversionKF.h:109
CbmKresConversionKF::fEMT_InvMass_Two
TH1D * fEMT_InvMass_Two
Definition: CbmKresConversionKF.h:281
CbmKresConversionKF::fPi0InvMassRecoKF_OneTwo_sts
TH1D * fPi0InvMassRecoKF_OneTwo_sts
Definition: CbmKresConversionKF.h:333
CbmKresConversionKF::fGammaInvMassReco_All
TH1D * fGammaInvMassReco_All
Definition: CbmKresConversionKF.h:172
CbmKresConversionKF::fHistoList_All_outside
vector< TH1 * > fHistoList_All_outside
Definition: CbmKresConversionKF.h:198
CbmKresConversionKF::BG9_all
TH1D * BG9_all
Definition: CbmKresConversionKF.h:415
CbmKresConversionKF::fPi0InvMassRecoKF_All_mvd
TH1D * fPi0InvMassRecoKF_All_mvd
Definition: CbmKresConversionKF.h:191
CbmKresConversionKF::fGammaOpeningAngleReco_OneTwo_outside
TH1D * fGammaOpeningAngleReco_OneTwo_outside
Definition: CbmKresConversionKF.h:337
CbmKresConversionKF::fPi0InvMassRecoKF_All_outside
TH1D * fPi0InvMassRecoKF_All_outside
Definition: CbmKresConversionKF.h:201
CbmGlobalTrack::GetRichRingIndex
Int_t GetRichRingIndex() const
Definition: CbmGlobalTrack.h:41
CbmKresConversionKF::CheckForCuts_OA_MC_from_one_pi0
TH1D * CheckForCuts_OA_MC_from_one_pi0
Definition: CbmKresConversionKF.h:157
CbmKresConversionKF::fStsTrackMatches
TClonesArray * fStsTrackMatches
Definition: CbmKresConversionKF.h:84
CbmKresConversionKF::fPi0InvMassRecoKF_OneTwo
TH1D * fPi0InvMassRecoKF_OneTwo
Definition: CbmKresConversionKF.h:314
CbmKresConversionKF::EMTMulti_InvMass_All_m7
TH1D * EMTMulti_InvMass_All_m7
Definition: CbmKresConversionKF.h:370
CbmKresConversionKF::fGammaInvMassReco_All_mvd
TH1D * fGammaInvMassReco_All_mvd
Definition: CbmKresConversionKF.h:189
CbmKFParticleFinderQA
Definition: CbmKFParticleFinderQA.h:21
CbmKresConversionKF::EMT_multi_two
std::vector< int > EMT_multi_two
Definition: CbmKresConversionKF.h:143
CbmKresConversionKF::PdgCase8NonE_NOT_FromTarget_onetwo
TH1D * PdgCase8NonE_NOT_FromTarget_onetwo
Definition: CbmKresConversionKF.h:552
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetP_zero
TH1D * sameMIDcase8NonEComeFromTargetP_zero
Definition: CbmKresConversionKF.h:467
CbmKresConversionKF::fEMT_InvMass_All
TH1D * fEMT_InvMass_All
Definition: CbmKresConversionKF.h:178
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetP_two
TH1D * sameMIDcase8NonEComeFromTargetP_two
Definition: CbmKresConversionKF.h:531
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetIM_onetwo
TH1D * sameMIDcase8NonEComeFromTargetIM_onetwo
Definition: CbmKresConversionKF.h:562
CbmKresConversionKF::BG8_two
TH1D * BG8_two
Definition: CbmKresConversionKF.h:510
CbmMCTrack::GetPdgCode
Int_t GetPdgCode() const
Definition: CbmMCTrack.h:70
CbmKresConversionKF::fPi0_pt_vs_rap_est_Zero
TH2D * fPi0_pt_vs_rap_est_Zero
Definition: CbmKresConversionKF.h:214
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmKresConversionKF::fGammaOpeningAngleReco_One_sts
TH1D * fGammaOpeningAngleReco_One_sts
Definition: CbmKresConversionKF.h:263
CbmKresConversionKF::Case8NonElFrom_pn_onetwo
TH1D * Case8NonElFrom_pn_onetwo
Definition: CbmKresConversionKF.h:555
CbmKresConversionKF::fHistoList_One_outside
vector< TH1 * > fHistoList_One_outside
Definition: CbmKresConversionKF.h:266
CbmKresConversionKF::EMT_Event_multi_two
std::vector< int > EMT_Event_multi_two
Definition: CbmKresConversionKF.h:132
CbmKresConversionKF::GammasOneTwoZ
std::vector< Double_t > GammasOneTwoZ
Definition: CbmKresConversionKF.h:116
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0_less4cm
TH1D * CheckForCuts_OA_Reco_from_one_pi0_less4cm
Definition: CbmKresConversionKF.h:164
CbmKresConversionKF::PdgCase8NonE_NOT_FromTarget_one
TH1D * PdgCase8NonE_NOT_FromTarget_one
Definition: CbmKresConversionKF.h:488
CbmKresConversionKF::BG1_zero
TH1D * BG1_zero
Definition: CbmKresConversionKF.h:439
CbmKresConversionKF::sameMIDcase8NonEPdgFromTarget_onetwo
TH1D * sameMIDcase8NonEPdgFromTarget_onetwo
Definition: CbmKresConversionKF.h:561
CbmKresConversionKF::fHistoList_Two_outside
vector< TH1 * > fHistoList_Two_outside
Definition: CbmKresConversionKF.h:301
CbmKresConversionKF::EMT_Event_multi_zero
std::vector< int > EMT_Event_multi_zero
Definition: CbmKresConversionKF.h:135
CbmKresConversionKF::CheckIfElectron
int CheckIfElectron(CbmRichRing *ring, double momentum)
Definition: CbmKresConversionKF.cxx:1282
CbmKresConversionKF::PdgCase8NonE_NOT_FromTarget_zero
TH1D * PdgCase8NonE_NOT_FromTarget_zero
Definition: CbmKresConversionKF.h:456
CbmKresConversionKF::GammasTwoStsIndex
std::vector< std::vector< int > > GammasTwoStsIndex
Definition: CbmKresConversionKF.h:102
CbmKresConversionKF::fGammaOpeningAngleReco_Zero_mvd
TH1D * fGammaOpeningAngleReco_Zero_mvd
Definition: CbmKresConversionKF.h:224
CbmKresConversionKF::Case8ElFromDalitz_onetwo
TH1D * Case8ElFromDalitz_onetwo
Definition: CbmKresConversionKF.h:554
CbmKresConversionKF::sameMIDcase8NonEPdg_onetwo
TH1D * sameMIDcase8NonEPdg_onetwo
Definition: CbmKresConversionKF.h:558
CbmKresConversionKF::fHistoList_Two_sts
vector< TH1 * > fHistoList_Two_sts
Definition: CbmKresConversionKF.h:296
CbmKresConversionKF::Case8NonElFrom_kaon_onetwo
TH1D * Case8NonElFrom_kaon_onetwo
Definition: CbmKresConversionKF.h:557
CbmGlobalTrack.h
CbmKresConversionKF::fHistoList_OneTwo_target
vector< TH1 * > fHistoList_OneTwo_target
Definition: CbmKresConversionKF.h:319
CbmKresConversionKF::fPi0InvMassRecoKF_Zero
TH1D * fPi0InvMassRecoKF_Zero
Definition: CbmKresConversionKF.h:211
CbmKresConversionKF::Case1ZYPos_onetwo
TH2D * Case1ZYPos_onetwo
Definition: CbmKresConversionKF.h:549
CbmKresConversionKF::MultiplicityGamma_All
TH2D * MultiplicityGamma_All
Definition: CbmKresConversionKF.h:344
CbmKresConversionKF::CheckForCuts_z_vs_InvMass_Reco_from_one_pi0
TH2D * CheckForCuts_z_vs_InvMass_Reco_from_one_pi0
Definition: CbmKresConversionKF.h:160
CbmKresConversionKF::BG2_all
TH1D * BG2_all
Definition: CbmKresConversionKF.h:408
CbmKresConversionKF::BG1_all
TH1D * BG1_all
Definition: CbmKresConversionKF.h:407
CbmKresConversionKF::fGammaInvMassReco_Zero
TH1D * fGammaInvMassReco_Zero
Definition: CbmKresConversionKF.h:206
CbmRichRing::GetNofHits
Int_t GetNofHits() const
Definition: CbmRichRing.h:40
CbmKresConversionKF::fGammaInvMassReco_One
TH1D * fGammaInvMassReco_One
Definition: CbmKresConversionKF.h:240
CbmKresConversionKF::fPi0InvMassRecoKF_Two
TH1D * fPi0InvMassRecoKF_Two
Definition: CbmKresConversionKF.h:280
CbmRichRing
Definition: CbmRichRing.h:17
CbmKresConversionKF::BG10_zero
TH1D * BG10_zero
Definition: CbmKresConversionKF.h:448
CbmKresConversionKF::GammasOneZ
std::vector< Double_t > GammasOneZ
Definition: CbmKresConversionKF.h:114
CbmKresConversionKF::Case1ZYPos_all
TH2D * Case1ZYPos_all
Definition: CbmKresConversionKF.h:421
CbmKresConversionKF::fPi0_pt_vs_rap_Zero
TH2D * fPi0_pt_vs_rap_Zero
Definition: CbmKresConversionKF.h:213
CbmKresConversionKF::fGammaInvMassReco_OneTwo
TH1D * fGammaInvMassReco_OneTwo
Definition: CbmKresConversionKF.h:309
CbmKresConversionKF::fRichRings
TClonesArray * fRichRings
Definition: CbmKresConversionKF.h:88
CbmKresConversionKF::CheckForCuts_InvMass_Reco
TH1D * CheckForCuts_InvMass_Reco
Definition: CbmKresConversionKF.h:151
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetP_onetwo
TH1D * sameMIDcase8NonEComeFromTargetP_onetwo
Definition: CbmKresConversionKF.h:563
CbmKresConversionBG::Exec
void Exec(CbmMCTrack *mctrack1, CbmMCTrack *mctrack2, CbmMCTrack *mctrack3, CbmMCTrack *mctrack4, Double_t invmassRecoPi0, vector< TH1 * > BGCases)
Definition: CbmKresConversionBG.cxx:37
CbmKresConversionKF::Case8NonElFrom_pn_two
TH1D * Case8NonElFrom_pn_two
Definition: CbmKresConversionKF.h:523
CbmRichRing.h
CbmKresConversionKF::MultiplicityGamma_One
TH2D * MultiplicityGamma_One
Definition: CbmKresConversionKF.h:346
CbmKresConversionKF::fRichProjections
TClonesArray * fRichProjections
Definition: CbmKresConversionKF.h:87
CbmKresConversionKF::EMTMulti_InvMass_Zero_m2
TH1D * EMTMulti_InvMass_Zero_m2
Definition: CbmKresConversionKF.h:373
CbmKresConversionKF::BG8_one
TH1D * BG8_one
Definition: CbmKresConversionKF.h:478
CbmKresConversionKF::fPi0InvMassRecoKF_Two_sts
TH1D * fPi0InvMassRecoKF_Two_sts
Definition: CbmKresConversionKF.h:299
CbmKresConversionKF::fEMT_InvMass_Two_target
TH1D * fEMT_InvMass_Two_target
Definition: CbmKresConversionKF.h:289
CbmKresConversionKF::fHistoList_Two_mvd
vector< TH1 * > fHistoList_Two_mvd
Definition: CbmKresConversionKF.h:291
CbmKresConversionKF::fPdg_One
TH1D * fPdg_One
Definition: CbmKresConversionKF.h:242
CbmKresConversionKF::fGammaOpeningAngleReco_Zero_outside
TH1D * fGammaOpeningAngleReco_Zero_outside
Definition: CbmKresConversionKF.h:234
CbmKresConversionKF::fKFparticle
CbmKFParticleFinder * fKFparticle
Definition: CbmKresConversionKF.h:74
CbmKresConversionKF::sameMIDcase8NonEMotherIM_onetwo
TH1D * sameMIDcase8NonEMotherIM_onetwo
Definition: CbmKresConversionKF.h:560
CbmKresConversionKF::fPi0InvMassRecoKF_All_target
TH1D * fPi0InvMassRecoKF_All_target
Definition: CbmKresConversionKF.h:185
CbmKresConversionKF::EMTMulti_InvMass_One_m7
TH1D * EMTMulti_InvMass_One_m7
Definition: CbmKresConversionKF.h:386
CbmKresConversionKF::EMT_multi_onetwo
std::vector< int > EMT_multi_onetwo
Definition: CbmKresConversionKF.h:145
CbmLmvmKinematicParams::fMinv
Double_t fMinv
Definition: CbmLmvmKinematicParams.h:22
CbmKresConversionKF::EMT_pair_momenta_multi_two
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_two
Definition: CbmKresConversionKF.h:133
CbmKresConversionKF::Case8NonElFrom_pn_one
TH1D * Case8NonElFrom_pn_one
Definition: CbmKresConversionKF.h:491
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0
TH1D * CheckForCuts_OA_Reco_from_one_pi0
Definition: CbmKresConversionKF.h:158
CbmKresConversionKF::EMTMulti_InvMass_All_m5
TH1D * EMTMulti_InvMass_All_m5
Definition: CbmKresConversionKF.h:368
CbmKresConversionKF::sameMIDcase8_all
TH1D * sameMIDcase8_all
Definition: CbmKresConversionKF.h:419
CbmKresConversionKF::fPi0InvMassRecoKF_OneTwo_target
TH1D * fPi0InvMassRecoKF_OneTwo_target
Definition: CbmKresConversionKF.h:322
CbmKresConversionKF::GammasZeroMC
std::vector< std::vector< CbmMCTrack * > > GammasZeroMC
Definition: CbmKresConversionKF.h:107
CbmKresConversionKF::PdgCase8mothers_all
TH1D * PdgCase8mothers_all
Definition: CbmKresConversionKF.h:418
CbmKresConversionKF::sameMIDcase8NonEMotherIM_one
TH1D * sameMIDcase8NonEMotherIM_one
Definition: CbmKresConversionKF.h:496
CbmKresConversionKF::fGammaInvMassReco_Zero_mvd
TH1D * fGammaInvMassReco_Zero_mvd
Definition: CbmKresConversionKF.h:223
CbmKresConversionKF::fPi0_pt_vs_rap_est_OneTwo
TH2D * fPi0_pt_vs_rap_est_OneTwo
Definition: CbmKresConversionKF.h:317
CbmKresConversionBG
Definition: CbmKresConversionBG.h:10
CbmKresConversionKF::fEMT_InvMass_OneTwo_target
TH1D * fEMT_InvMass_OneTwo_target
Definition: CbmKresConversionKF.h:323
CbmKresConversionKF::fEMT_InvMass_All_outside
TH1D * fEMT_InvMass_All_outside
Definition: CbmKresConversionKF.h:202
CbmKresConversionKF::fGammaOpeningAngleReco_One_outside
TH1D * fGammaOpeningAngleReco_One_outside
Definition: CbmKresConversionKF.h:268
CbmKresConversionKF::fPi0InvMassRecoKF_All
TH1D * fPi0InvMassRecoKF_All
Definition: CbmKresConversionKF.h:177
CbmKresConversionKF::fPi0InvMassRecoKF_One_target
TH1D * fPi0InvMassRecoKF_One_target
Definition: CbmKresConversionKF.h:253
CbmKresConversionKF::BG9_two
TH1D * BG9_two
Definition: CbmKresConversionKF.h:511
CbmKresConversionKF::EMTMulti_InvMass_Zero_m5
TH1D * EMTMulti_InvMass_Zero_m5
Definition: CbmKresConversionKF.h:376
CbmKresConversionKF::BG5_all
TH1D * BG5_all
Definition: CbmKresConversionKF.h:411
CbmKresConversionKF::BG2_onetwo
TH1D * BG2_onetwo
Definition: CbmKresConversionKF.h:536
CbmKresConversionKF::BG3_zero
TH1D * BG3_zero
Definition: CbmKresConversionKF.h:441
CbmKresConversionKF::CheckForCuts_InvMass_MC_from_one_pi0
TH1D * CheckForCuts_InvMass_MC_from_one_pi0
Definition: CbmKresConversionKF.h:155
CbmKresConversionKF::fGammaInvMassReco_All_sts
TH1D * fGammaInvMassReco_All_sts
Definition: CbmKresConversionKF.h:194
CbmMCTrack::GetStartZ
Double_t GetStartZ() const
Definition: CbmMCTrack.h:77
CbmKresConversionKF::EMTMulti_InvMass_One_m1
TH1D * EMTMulti_InvMass_One_m1
Definition: CbmKresConversionKF.h:380
CbmKresConversionKF::MultiplicityChargedParticles_All
TH2D * MultiplicityChargedParticles_All
Definition: CbmKresConversionKF.h:350
CbmKresConversionKF::fEMT_InvMass_One
TH1D * fEMT_InvMass_One
Definition: CbmKresConversionKF.h:246
CbmKresConversionKF::PdgCase8mothers_two
TH1D * PdgCase8mothers_two
Definition: CbmKresConversionKF.h:514
CbmKresConversionKF::EMTMulti_InvMass_One_m3
TH1D * EMTMulti_InvMass_One_m3
Definition: CbmKresConversionKF.h:382
CbmKresConversionKF::EMTMulti_InvMass_Zero_m4
TH1D * EMTMulti_InvMass_Zero_m4
Definition: CbmKresConversionKF.h:375
CbmKresConversionKF::BG6_two
TH1D * BG6_two
Definition: CbmKresConversionKF.h:508
CbmKresConversionKF::BG5_two
TH1D * BG5_two
Definition: CbmKresConversionKF.h:507
CbmKresConversionKF::PdgCase8NonEComeFromTarget_one
TH1D * PdgCase8NonEComeFromTarget_one
Definition: CbmKresConversionKF.h:487
CbmKresConversionKF::fHistoList_bg_one
vector< TH1 * > fHistoList_bg_one
Definition: CbmKresConversionKF.h:470
CbmKresConversionKF::MultiplicityChargedParticles_Two
TH2D * MultiplicityChargedParticles_Two
Definition: CbmKresConversionKF.h:353
CbmRichRing::GetHit
UInt_t GetHit(Int_t i) const
Definition: CbmRichRing.h:42
CbmKresConversionKF::GammasOneTwo
std::vector< std::vector< TVector3 > > GammasOneTwo
Definition: CbmKresConversionKF.h:96
CbmKresConversionKF::BG8_zero
TH1D * BG8_zero
Definition: CbmKresConversionKF.h:446
CbmKresConversionKF::fGammaOpeningAngleReco_Two_mvd
TH1D * fGammaOpeningAngleReco_Two_mvd
Definition: CbmKresConversionKF.h:293
CbmKresConversionKF::frefmomentum
std::vector< TVector3 > frefmomentum
Definition: CbmKresConversionKF.h:91
CbmStsTrack.h
Data class for STS tracks.
CbmGlobalTrack::GetStsTrackIndex
Int_t GetStsTrackIndex() const
Definition: CbmGlobalTrack.h:38
CbmKresConversionKF::BG8_onetwo
TH1D * BG8_onetwo
Definition: CbmKresConversionKF.h:542
CbmKresConversionKF::BG5_one
TH1D * BG5_one
Definition: CbmKresConversionKF.h:475
CbmKresConversionKF::Case8NonElFrom_kaon_one
TH1D * Case8NonElFrom_kaon_one
Definition: CbmKresConversionKF.h:493
CbmRichRingLight::GetAaxis
float GetAaxis() const
Definition: CbmRichRingLight.h:163
CbmKresConversionKF::fHistoList_One_sts
vector< TH1 * > fHistoList_One_sts
Definition: CbmKresConversionKF.h:261
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetIM_all
TH1D * sameMIDcase8NonEComeFromTargetIM_all
Definition: CbmKresConversionKF.h:434
CbmKresConversionKF::Case1ZYPos_zero
TH2D * Case1ZYPos_zero
Definition: CbmKresConversionKF.h:453
CbmKresConversionKF::sameMIDcase8_onetwo
TH1D * sameMIDcase8_onetwo
Definition: CbmKresConversionKF.h:547
CbmKresConversionKF::fEMT_InvMass_One_target
TH1D * fEMT_InvMass_One_target
Definition: CbmKresConversionKF.h:254
CbmKresConversionKF::fPi0InvMassRecoKF_One_outside
TH1D * fPi0InvMassRecoKF_One_outside
Definition: CbmKresConversionKF.h:269
CbmKresConversionKF::fPi0_pt_vs_rap_est_Two
TH2D * fPi0_pt_vs_rap_est_Two
Definition: CbmKresConversionKF.h:283
CbmKresConversionKF::fPi0_pt_vs_rap_OneTwo
TH2D * fPi0_pt_vs_rap_OneTwo
Definition: CbmKresConversionKF.h:316
CbmKresConversionKF::BG9_zero
TH1D * BG9_zero
Definition: CbmKresConversionKF.h:447
CbmKresConversionKF::fP_reco_All
TH1D * fP_reco_All
Definition: CbmKresConversionKF.h:175
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m2
TH1D * EMTMulti_InvMass_OneTwo_m2
Definition: CbmKresConversionKF.h:397
CbmKresConversionKF::MultiplicityGamma_Two
TH2D * MultiplicityGamma_Two
Definition: CbmKresConversionKF.h:347
CbmKresConversionKF::sameMIDcase8_mothedPDG_all
TH1D * sameMIDcase8_mothedPDG_all
Definition: CbmKresConversionKF.h:422
CbmKresConversionKF::fStsTracks
TClonesArray * fStsTracks
Definition: CbmKresConversionKF.h:83
CbmKresConversionKF::PdgCase8mothers_onetwo
TH1D * PdgCase8mothers_onetwo
Definition: CbmKresConversionKF.h:546
CbmKresConversionKF::fHistoList_Zero_sts
vector< TH1 * > fHistoList_Zero_sts
Definition: CbmKresConversionKF.h:227
CbmKresConversionKF::BG10_one
TH1D * BG10_one
Definition: CbmKresConversionKF.h:480
CbmRichRingLight.h
CbmKresConversionKF::fGammaOpeningAngleReco_OneTwo_target
TH1D * fGammaOpeningAngleReco_OneTwo_target
Definition: CbmKresConversionKF.h:321
CbmKresConversionKF::Case8ElFromDalitz_all
TH1D * Case8ElFromDalitz_all
Definition: CbmKresConversionKF.h:426
CbmKresConversionKF::fGammaOpeningAngleReco_Two_outside
TH1D * fGammaOpeningAngleReco_Two_outside
Definition: CbmKresConversionKF.h:303
CbmKresConversionKF::fPt_reco_All
TH1D * fPt_reco_All
Definition: CbmKresConversionKF.h:176
CbmKresConversionKF::SetKF
void SetKF(CbmKFParticleFinder *kfparticle, CbmKFParticleFinderQA *kfparticleQA)
Definition: CbmKresConversionKF.cxx:466
CbmKresConversionKF::fPt_reco_OneTwo
TH1D * fPt_reco_OneTwo
Definition: CbmKresConversionKF.h:313
CbmKresConversionKF::sameMIDcase8_two
TH1D * sameMIDcase8_two
Definition: CbmKresConversionKF.h:515
CbmKresConversionKF::MixedEvent
void MixedEvent()
Definition: CbmKresConversionKF.cxx:1307
CbmKresConversionKF::sameMIDcase8_zero
TH1D * sameMIDcase8_zero
Definition: CbmKresConversionKF.h:451
CbmKresConversionKF::MixedEventMulti
void MixedEventMulti()
Definition: CbmKresConversionKF.cxx:1365
CbmKresConversionKF::fEMT_InvMass_OneTwo
TH1D * fEMT_InvMass_OneTwo
Definition: CbmKresConversionKF.h:315
CbmTrackMatchNew.h
CbmKresConversionKF::EMTMulti_InvMass_One_m2
TH1D * EMTMulti_InvMass_One_m2
Definition: CbmKresConversionKF.h:381
CbmRichRingLight::AddHit
void AddHit(CbmRichHitLight hit)
Add new hit to the ring.
Definition: CbmRichRingLight.h:87
CbmKresConversionKF::Case8NonElFrom_kaon_two
TH1D * Case8NonElFrom_kaon_two
Definition: CbmKresConversionKF.h:525
CbmKresConversionKF::fPi0InvMassRecoKF_Two_outside
TH1D * fPi0InvMassRecoKF_Two_outside
Definition: CbmKresConversionKF.h:304
CbmKresConversionKF::fPt_reco_Zero
TH1D * fPt_reco_Zero
Definition: CbmKresConversionKF.h:210
CbmKresConversionKF::fGammaOpeningAngleReco_OneTwo_mvd
TH1D * fGammaOpeningAngleReco_OneTwo_mvd
Definition: CbmKresConversionKF.h:327
CbmKresConversionKF::sameMIDcase8NonEPdgFromTarget_zero
TH1D * sameMIDcase8NonEPdgFromTarget_zero
Definition: CbmKresConversionKF.h:465
CbmKresFunctions::FitToVertex
static TVector3 FitToVertex(CbmStsTrack *stsTrack, double x, double y, double z)
Definition: CbmKresFunctions.h:29
CbmKresConversionKF::fGammaOpeningAngleReco_All_target
TH1D * fGammaOpeningAngleReco_All_target
Definition: CbmKresConversionKF.h:184
CbmKresConversionKF::EMTMulti_InvMass_Zero_m6
TH1D * EMTMulti_InvMass_Zero_m6
Definition: CbmKresConversionKF.h:377
CbmKresFunctions::CalculateKinematicParams_4particles
static CbmLmvmKinematicParams CalculateKinematicParams_4particles(const TVector3 part1, const TVector3 part2, const TVector3 part3, const TVector3 part4)
Definition: CbmKresFunctions.h:212
CbmKresConversionKF::EMT_Event_multi_one
std::vector< int > EMT_Event_multi_one
Definition: CbmKresConversionKF.h:129
CbmKresConversionKF::fHistoList_OneTwo_mvd
vector< TH1 * > fHistoList_OneTwo_mvd
Definition: CbmKresConversionKF.h:325
CbmKresConversionKF::fGammaInvMassReco_Two
TH1D * fGammaInvMassReco_Two
Definition: CbmKresConversionKF.h:275
CbmKresConversionKF::Case8NonElFrom_eta_zero
TH1D * Case8NonElFrom_eta_zero
Definition: CbmKresConversionKF.h:460
CbmKresConversionKF::sameGRIDcase8_zero
TH1D * sameGRIDcase8_zero
Definition: CbmKresConversionKF.h:452
CbmKresConversionKF::fPi0InvMassRecoKF_OneTwo_mvd
TH1D * fPi0InvMassRecoKF_OneTwo_mvd
Definition: CbmKresConversionKF.h:328
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m3
TH1D * EMTMulti_InvMass_OneTwo_m3
Definition: CbmKresConversionKF.h:398
CbmKresConversionKF::fAnaBG
CbmKresConversionBG * fAnaBG
Definition: CbmKresConversionKF.h:80
CbmKresConversionKF::sameMIDcase8NonEMotherIM_all
TH1D * sameMIDcase8NonEMotherIM_all
Definition: CbmKresConversionKF.h:432
CbmKresConversionKF::CheckForCuts_z_vs_InvMass_MC_from_one_pi0
TH2D * CheckForCuts_z_vs_InvMass_MC_from_one_pi0
Definition: CbmKresConversionKF.h:159
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:1146
CbmKresConversionKF::GammasOneTwoMC
std::vector< std::vector< CbmMCTrack * > > GammasOneTwoMC
Definition: CbmKresConversionKF.h:110
CbmKresConversionKF::sameMIDcase8_mothedPDG_one
TH1D * sameMIDcase8_mothedPDG_one
Definition: CbmKresConversionKF.h:486
CbmKresConversionKF::sameMIDcase8NonEPdgFromTarget_two
TH1D * sameMIDcase8NonEPdgFromTarget_two
Definition: CbmKresConversionKF.h:529
CbmKresConversionKF::EMT_pair_momenta_multi_zero
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_zero
Definition: CbmKresConversionKF.h:136
CbmKresConversionKF::fP_reco_Zero
TH1D * fP_reco_Zero
Definition: CbmKresConversionKF.h:209
CbmKresConversionKF::fGammaInvMassReco_All_target
TH1D * fGammaInvMassReco_All_target
Definition: CbmKresConversionKF.h:183
CbmKresConversionKF::fGammaOpeningAngleReco_One
TH1D * fGammaOpeningAngleReco_One
Definition: CbmKresConversionKF.h:241
CbmKresConversionKF::PdgCase8NonEComeFromTarget_zero
TH1D * PdgCase8NonEComeFromTarget_zero
Definition: CbmKresConversionKF.h:455
CbmKresConversionKF::EMTMulti_InvMass_One_m5
TH1D * EMTMulti_InvMass_One_m5
Definition: CbmKresConversionKF.h:384
CbmKresConversionKF::PdgCase8NonE_NOT_FromTarget_two
TH1D * PdgCase8NonE_NOT_FromTarget_two
Definition: CbmKresConversionKF.h:520
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0_4cm_21cm
Definition: CbmKresConversionKF.h:165
CbmKresConversionKF::fPi0InvMassRecoKF_Zero_sts
TH1D * fPi0InvMassRecoKF_Zero_sts
Definition: CbmKresConversionKF.h:230
CbmKresConversionKF::fGammaInvMassReco_One_mvd
TH1D * fGammaInvMassReco_One_mvd
Definition: CbmKresConversionKF.h:257
CbmKresConversionKF::fPi0InvMassRecoKF_OneTwo_outside
TH1D * fPi0InvMassRecoKF_OneTwo_outside
Definition: CbmKresConversionKF.h:338
CbmKresConversionKF::BG1_one
TH1D * BG1_one
Definition: CbmKresConversionKF.h:471
CbmKresConversionKF::fEMT_InvMass_All_target
TH1D * fEMT_InvMass_All_target
Definition: CbmKresConversionKF.h:186
CbmLmvmKinematicParams::fRapidity
Double_t fRapidity
Definition: CbmLmvmKinematicParams.h:21
CbmKresConversionKF::sameMIDcase8NonEMotherIM_two
TH1D * sameMIDcase8NonEMotherIM_two
Definition: CbmKresConversionKF.h:528
CbmKresConversionKF::fTauFit
CbmRichRingFitterEllipseTau * fTauFit
Definition: CbmKresConversionKF.h:78
CbmKresConversionKF::EMT_Event_multi_all
std::vector< int > EMT_Event_multi_all
Definition: CbmKresConversionKF.h:126
CbmKresConversionKF::GammasAllStsIndex
std::vector< std::vector< int > > GammasAllStsIndex
Definition: CbmKresConversionKF.h:99
CbmKresConversionKF::sameMIDcase8_mothedPDG_zero
TH1D * sameMIDcase8_mothedPDG_zero
Definition: CbmKresConversionKF.h:454
CbmKresConversionKF::fEMT_InvMass_One_outside
TH1D * fEMT_InvMass_One_outside
Definition: CbmKresConversionKF.h:270
CbmKresConversionKF::BG1_two
TH1D * BG1_two
Definition: CbmKresConversionKF.h:503
CbmRichRingLight::GetBaxis
float GetBaxis() const
Definition: CbmRichRingLight.h:164
CbmKresConversionKF::PdgCase8NonEComeFromTarget_two
TH1D * PdgCase8NonEComeFromTarget_two
Definition: CbmKresConversionKF.h:519
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetPt_all
TH1D * sameMIDcase8NonEComeFromTargetPt_all
Definition: CbmKresConversionKF.h:436
CbmKresConversionKF::EMTMulti_InvMass_Two_m4
TH1D * EMTMulti_InvMass_Two_m4
Definition: CbmKresConversionKF.h:391
CbmKresConversionKF::GammasOne
std::vector< std::vector< TVector3 > > GammasOne
Definition: CbmKresConversionKF.h:94
CbmKresConversionKF::BG6_onetwo
TH1D * BG6_onetwo
Definition: CbmKresConversionKF.h:540
CbmKresConversionKF::PdgCase8mothers_one
TH1D * PdgCase8mothers_one
Definition: CbmKresConversionKF.h:482
CbmKresConversionKF::fGammaInvMassReco_One_sts
TH1D * fGammaInvMassReco_One_sts
Definition: CbmKresConversionKF.h:262
CbmKresConversionKF::BG4_all
TH1D * BG4_all
Definition: CbmKresConversionKF.h:410
CbmRichHitLight
Definition: CbmRichRingLight.h:14
CbmKresConversionKF::CheckForCuts_OA_MC
TH1D * CheckForCuts_OA_MC
Definition: CbmKresConversionKF.h:152
CbmKresConversionKF::PdgCase8_two
TH1D * PdgCase8_two
Definition: CbmKresConversionKF.h:513
CbmKresConversionKF::~CbmKresConversionKF
virtual ~CbmKresConversionKF()
Definition: CbmKresConversionKF.cxx:464
CbmKresConversionKF::fGammaInvMassReco_All_outside
TH1D * fGammaInvMassReco_All_outside
Definition: CbmKresConversionKF.h:199
CbmKresConversionKF::fEMT_InvMass_Zero
TH1D * fEMT_InvMass_Zero
Definition: CbmKresConversionKF.h:212
CbmKresConversionKF::fGammaOpeningAngleReco_All_mvd
TH1D * fGammaOpeningAngleReco_All_mvd
Definition: CbmKresConversionKF.h:190
CbmKresConversionKF::BG10_two
TH1D * BG10_two
Definition: CbmKresConversionKF.h:512
CbmKresConversionKF::fHistoList_bg_all
vector< TH1 * > fHistoList_bg_all
Definition: CbmKresConversionKF.h:406
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0_more21cm
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0_more21cm
Definition: CbmKresConversionKF.h:167
CbmKresConversionKF::fHistoList_All
vector< TH1 * > fHistoList_All
Definition: CbmKresConversionKF.h:171
CbmKresConversionKF::EMTMulti_InvMass_Two_m7
TH1D * EMTMulti_InvMass_Two_m7
Definition: CbmKresConversionKF.h:394
CbmKresConversionKF::BG8_all
TH1D * BG8_all
Definition: CbmKresConversionKF.h:414
CbmKresConversionKF::fPi0InvMassRecoKF_Two_target
TH1D * fPi0InvMassRecoKF_Two_target
Definition: CbmKresConversionKF.h:288
CbmKresConversionKF::fHistoList_Zero_target
vector< TH1 * > fHistoList_Zero_target
Definition: CbmKresConversionKF.h:216
CbmKresConversionKF::EMTMulti_InvMass_Zero_m1
TH1D * EMTMulti_InvMass_Zero_m1
Definition: CbmKresConversionKF.h:372
CbmKresConversionKF::BG7_two
TH1D * BG7_two
Definition: CbmKresConversionKF.h:509
CbmKresConversionKF::fHistoList_OneTwo_outside
vector< TH1 * > fHistoList_OneTwo_outside
Definition: CbmKresConversionKF.h:335
CbmKresConversionKF::fPi0_pt_vs_rap_est_One
TH2D * fPi0_pt_vs_rap_est_One
Definition: CbmKresConversionKF.h:248
CbmKresConversionKF::BG7_zero
TH1D * BG7_zero
Definition: CbmKresConversionKF.h:445
CbmKresConversionKF::GammasOneTwoStsIndex
std::vector< std::vector< int > > GammasOneTwoStsIndex
Definition: CbmKresConversionKF.h:103
CbmKresConversionKF::fPi0_pt_vs_rap_One
TH2D * fPi0_pt_vs_rap_One
Definition: CbmKresConversionKF.h:247
CbmKresConversionKF::fEMT_InvMass_Zero_target
TH1D * fEMT_InvMass_Zero_target
Definition: CbmKresConversionKF.h:220
CbmKFParticleFinderQA.h
CbmKresConversionKF::sameMIDcase8_mothedPDG_two
TH1D * sameMIDcase8_mothedPDG_two
Definition: CbmKresConversionKF.h:518
CbmKresConversionKF::EMTMulti_InvMass_All_m1
TH1D * EMTMulti_InvMass_All_m1
Definition: CbmKresConversionKF.h:364
CbmKresFunctions::Invmass_2particles_RECO
static double Invmass_2particles_RECO(const TVector3 part1, const TVector3 part2)
Definition: CbmKresFunctions.h:107
CbmKresConversionKF::EMT_pair_momenta
std::vector< std::vector< TVector3 > > EMT_pair_momenta
Definition: CbmKresConversionKF.h:121
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetPt_onetwo
TH1D * sameMIDcase8NonEComeFromTargetPt_onetwo
Definition: CbmKresConversionKF.h:564
CbmKresFunctions.h
CbmKresConversionKF::fHistoList_bg_two
vector< TH1 * > fHistoList_bg_two
Definition: CbmKresConversionKF.h:502
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m5
TH1D * EMTMulti_InvMass_OneTwo_m5
Definition: CbmKresConversionKF.h:400
CbmKresConversionKF::fStsInd
std::vector< int > fStsInd
Definition: CbmKresConversionKF.h:98
CbmKresConversionKF::EMTMulti_InvMass_Two_m5
TH1D * EMTMulti_InvMass_Two_m5
Definition: CbmKresConversionKF.h:392
CbmKresConversionKF::fPi0InvMassRecoKF_Zero_outside
TH1D * fPi0InvMassRecoKF_Zero_outside
Definition: CbmKresConversionKF.h:235
CbmGlobalTrack
Definition: CbmGlobalTrack.h:26
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetIM_two
TH1D * sameMIDcase8NonEComeFromTargetIM_two
Definition: CbmKresConversionKF.h:530
CbmKresConversionKF::fPi0InvMassRecoKF_All_sts
TH1D * fPi0InvMassRecoKF_All_sts
Definition: CbmKresConversionKF.h:196
CbmKresFunctions::CalculateOpeningAngle_MC
static Double_t CalculateOpeningAngle_MC(CbmMCTrack *mctrack1, CbmMCTrack *mctrack2)
Definition: CbmKresFunctions.h:267
CbmKresConversionKF::fGammaOpeningAngleReco_Zero_target
TH1D * fGammaOpeningAngleReco_Zero_target
Definition: CbmKresConversionKF.h:218
CbmKresConversionKF::BG5_onetwo
TH1D * BG5_onetwo
Definition: CbmKresConversionKF.h:539
CbmKresConversionKF::fmcvector
std::vector< CbmMCTrack * > fmcvector
Definition: CbmKresConversionKF.h:105
CbmKresConversionKF::fGammaInvMassReco_Zero_sts
TH1D * fGammaInvMassReco_Zero_sts
Definition: CbmKresConversionKF.h:228
CbmKresConversionKF::MultiplicityGamma_OneTwo
TH2D * MultiplicityGamma_OneTwo
Definition: CbmKresConversionKF.h:348
CbmKresConversionKF::sameMIDcase8NonEPdgFromTarget_one
TH1D * sameMIDcase8NonEPdgFromTarget_one
Definition: CbmKresConversionKF.h:497
CbmKresConversionKF::fKFparticleFinderQA
CbmKFParticleFinderQA * fKFparticleFinderQA
Definition: CbmKresConversionKF.h:75
CbmKresConversionKF::PdgCase8motherNonE_one
TH1D * PdgCase8motherNonE_one
Definition: CbmKresConversionKF.h:489
CbmKresConversionKF::Exec
void Exec(int fEventNumKF, double OpeningAngleCut, double GammaInvMassCut, int RealPID)
Definition: CbmKresConversionKF.cxx:534
CbmKresConversionKF::EMTMulti_InvMass_Two_m1
TH1D * EMTMulti_InvMass_Two_m1
Definition: CbmKresConversionKF.h:388
CbmKresConversionKF::Case8NonElFrom_eta_all
TH1D * Case8NonElFrom_eta_all
Definition: CbmKresConversionKF.h:428
CbmKresConversionKF::fPi0InvMassRecoKF_Zero_target
TH1D * fPi0InvMassRecoKF_Zero_target
Definition: CbmKresConversionKF.h:219
CbmKresConversionKF::PdgCase8motherNonE_two
TH1D * PdgCase8motherNonE_two
Definition: CbmKresConversionKF.h:521
CbmKresConversionKF::fGammaOpeningAngleReco_OneTwo
TH1D * fGammaOpeningAngleReco_OneTwo
Definition: CbmKresConversionKF.h:310
CbmMCTrack.h
CbmKresConversionKF::sameMIDcase8NonEMotherIM_zero
TH1D * sameMIDcase8NonEMotherIM_zero
Definition: CbmKresConversionKF.h:464
CbmKresConversionKF::BG4_two
TH1D * BG4_two
Definition: CbmKresConversionKF.h:506
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetP_all
TH1D * sameMIDcase8NonEComeFromTargetP_all
Definition: CbmKresConversionKF.h:435
CbmKresConversionKF::fGammaOpeningAngleReco_All_sts
TH1D * fGammaOpeningAngleReco_All_sts
Definition: CbmKresConversionKF.h:195
CbmKresConversionKF::fGammaInvMassReco_Two_outside
TH1D * fGammaInvMassReco_Two_outside
Definition: CbmKresConversionKF.h:302
CbmKresConversionKF::fHistoList_multiplicity_Two
vector< TH1 * > fHistoList_multiplicity_Two
Definition: CbmKresConversionKF.h:360
CbmKresConversionKF::fP_reco_Two
TH1D * fP_reco_Two
Definition: CbmKresConversionKF.h:278
CbmKresConversionKF::EMTMulti_InvMass_Zero_m7
TH1D * EMTMulti_InvMass_Zero_m7
Definition: CbmKresConversionKF.h:378
CbmKresConversionKF::fHistoList_CheckForCuts
vector< TH1 * > fHistoList_CheckForCuts
Definition: CbmKresConversionKF.h:149
CbmKFParticleFinder::GetTopoReconstructor
const KFParticleTopoReconstructor * GetTopoReconstructor() const
Definition: CbmKFParticleFinder.h:46
CbmKresConversionKF::sameGRIDcase8_all
TH1D * sameGRIDcase8_all
Definition: CbmKresConversionKF.h:420
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetPt_zero
TH1D * sameMIDcase8NonEComeFromTargetPt_zero
Definition: CbmKresConversionKF.h:468
CbmKresConversionKF::BG6_zero
TH1D * BG6_zero
Definition: CbmKresConversionKF.h:444
CbmKresConversionKF::EMT_pair_momenta_multi_all
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_all
Definition: CbmKresConversionKF.h:127
CbmKresConversionKF::fGammaInvMassReco_OneTwo_target
TH1D * fGammaInvMassReco_OneTwo_target
Definition: CbmKresConversionKF.h:320
CbmKresConversionKF::fRichRingMatches
TClonesArray * fRichRingMatches
Definition: CbmKresConversionKF.h:86
CbmKresConversionKF::fEMT_InvMass_Two_outside
TH1D * fEMT_InvMass_Two_outside
Definition: CbmKresConversionKF.h:305
CbmKresConversionKF::BG6_one
TH1D * BG6_one
Definition: CbmKresConversionKF.h:476
CbmMCTrack
Definition: CbmMCTrack.h:34
CbmKresConversionKF::BG1_onetwo
TH1D * BG1_onetwo
Definition: CbmKresConversionKF.h:535
CbmKresConversionKF::fGammaOpeningAngleReco_Two
TH1D * fGammaOpeningAngleReco_Two
Definition: CbmKresConversionKF.h:276
CbmKresConversionKF::fHistoList_Zero_mvd
vector< TH1 * > fHistoList_Zero_mvd
Definition: CbmKresConversionKF.h:222
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetP_one
TH1D * sameMIDcase8NonEComeFromTargetP_one
Definition: CbmKresConversionKF.h:499
CbmKresConversionKF::BG2_one
TH1D * BG2_one
Definition: CbmKresConversionKF.h:472
CbmKresConversionKF::fHistoList_All_target
vector< TH1 * > fHistoList_All_target
Definition: CbmKresConversionKF.h:182
CbmKresConversionKF::CheckForCuts_z_vs_OA_Reco_from_one_pi0
TH2D * CheckForCuts_z_vs_OA_Reco_from_one_pi0
Definition: CbmKresConversionKF.h:162
CbmKresConversionKF::PdgCase8NonE_NOT_FromTarget_all
TH1D * PdgCase8NonE_NOT_FromTarget_all
Definition: CbmKresConversionKF.h:424
CbmKresConversionKF::Case8NonElFrom_kaon_zero
TH1D * Case8NonElFrom_kaon_zero
Definition: CbmKresConversionKF.h:461
CbmKresConversionKF::sameGRIDcase8_onetwo
TH1D * sameGRIDcase8_onetwo
Definition: CbmKresConversionKF.h:548
CbmKresConversionKF::Case8NonElFrom_pn_zero
TH1D * Case8NonElFrom_pn_zero
Definition: CbmKresConversionKF.h:459
CbmKresConversionKF::fPi0InvMassRecoKF_Zero_mvd
TH1D * fPi0InvMassRecoKF_Zero_mvd
Definition: CbmKresConversionKF.h:225
CbmKresConversionKF::PdgCase8motherNonE_zero
TH1D * PdgCase8motherNonE_zero
Definition: CbmKresConversionKF.h:457
CbmKresConversionKF::BG7_one
TH1D * BG7_one
Definition: CbmKresConversionKF.h:477
CbmKresConversionKF::BG3_all
TH1D * BG3_all
Definition: CbmKresConversionKF.h:409
CbmKresConversionKF::fGammaInvMassReco_One_target
TH1D * fGammaInvMassReco_One_target
Definition: CbmKresConversionKF.h:251
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m1
TH1D * EMTMulti_InvMass_OneTwo_m1
Definition: CbmKresConversionKF.h:396
CbmKresConversionKF::BG9_onetwo
TH1D * BG9_onetwo
Definition: CbmKresConversionKF.h:543
CbmKresConversionKF::BG7_onetwo
TH1D * BG7_onetwo
Definition: CbmKresConversionKF.h:541
CbmKresConversionKF::GammasZero
std::vector< std::vector< TVector3 > > GammasZero
Definition: CbmKresConversionKF.h:93
CbmKresConversionKF::BG3_onetwo
TH1D * BG3_onetwo
Definition: CbmKresConversionKF.h:537
CbmKresConversionKF::GammasAllZ
std::vector< Double_t > GammasAllZ
Definition: CbmKresConversionKF.h:112
CbmKresConversionKF::EMT_Event
std::vector< int > EMT_Event
Definition: CbmKresConversionKF.h:120
CbmKresConversionKF::Case8NonElFrom_pn_all
TH1D * Case8NonElFrom_pn_all
Definition: CbmKresConversionKF.h:427
CbmKresConversionKF::GammasAll
std::vector< std::vector< TVector3 > > GammasAll
Definition: CbmKresConversionKF.h:92
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetPt_one
TH1D * sameMIDcase8NonEComeFromTargetPt_one
Definition: CbmKresConversionKF.h:500
CbmKresConversionKF::Case8NonElFrom_eta_two
TH1D * Case8NonElFrom_eta_two
Definition: CbmKresConversionKF.h:524
CbmKresConversionKF::Case1ZYPos_one
TH2D * Case1ZYPos_one
Definition: CbmKresConversionKF.h:485
CbmKresConversionKF::EMTMulti_InvMass_OneTwo_m7
TH1D * EMTMulti_InvMass_OneTwo_m7
Definition: CbmKresConversionKF.h:402
CbmKresConversionKF::fGammaInvMassReco_OneTwo_outside
TH1D * fGammaInvMassReco_OneTwo_outside
Definition: CbmKresConversionKF.h:336
CbmKresConversionKF::EMTMulti_InvMass_Zero_m3
TH1D * EMTMulti_InvMass_Zero_m3
Definition: CbmKresConversionKF.h:374
CbmKresConversionKF::sameMIDcase8NonEPdgFromTarget_all
TH1D * sameMIDcase8NonEPdgFromTarget_all
Definition: CbmKresConversionKF.h:433
CbmKresConversionKF::GammasTwo
std::vector< std::vector< TVector3 > > GammasTwo
Definition: CbmKresConversionKF.h:95
CbmKresConversionKF::BG10_onetwo
TH1D * BG10_onetwo
Definition: CbmKresConversionKF.h:544
CbmKresConversionKF::EMTMulti_InvMass_One_m4
TH1D * EMTMulti_InvMass_One_m4
Definition: CbmKresConversionKF.h:383
CbmKresConversionKF::fPi0_pt_vs_rap_All
TH2D * fPi0_pt_vs_rap_All
Definition: CbmKresConversionKF.h:179
CbmTrackMatchNew
Definition: CbmTrackMatchNew.h:19
CbmKresConversionKF::EMTMulti_InvMass_All_m3
TH1D * EMTMulti_InvMass_All_m3
Definition: CbmKresConversionKF.h:366
CbmKresConversionKF::fPi0_pt_vs_rap_Two
TH2D * fPi0_pt_vs_rap_Two
Definition: CbmKresConversionKF.h:282
CbmKresConversionKF::Case1ZYPos_two
TH2D * Case1ZYPos_two
Definition: CbmKresConversionKF.h:517
CbmKresConversionKF::fGammaInvMassReco_Zero_target
TH1D * fGammaInvMassReco_Zero_target
Definition: CbmKresConversionKF.h:217
CbmKresConversionKF::fRichHits
TClonesArray * fRichHits
Definition: CbmKresConversionKF.h:89
CbmKresConversionKF::PdgCase8NonEComeFromTarget_all
TH1D * PdgCase8NonEComeFromTarget_all
Definition: CbmKresConversionKF.h:423
CbmKresConversionKF::PdgCase8motherNonE_onetwo
TH1D * PdgCase8motherNonE_onetwo
Definition: CbmKresConversionKF.h:553
CbmKresConversionKF::GammasTwoZ
std::vector< Double_t > GammasTwoZ
Definition: CbmKresConversionKF.h:115
CbmKresConversionKF::sameMIDcase8NonEPdg_zero
TH1D * sameMIDcase8NonEPdg_zero
Definition: CbmKresConversionKF.h:462
CbmKresConversionKF::fHistoList_Zero
vector< TH1 * > fHistoList_Zero
Definition: CbmKresConversionKF.h:205
CbmKresConversionKF::sameMIDcase8NonEMotherPdg_zero
TH1D * sameMIDcase8NonEMotherPdg_zero
Definition: CbmKresConversionKF.h:463
CbmKresConversionKF::BG7_all
TH1D * BG7_all
Definition: CbmKresConversionKF.h:413
CbmKresConversionKF::CheckForCuts_z_vs_OA_MC_from_one_pi0
TH2D * CheckForCuts_z_vs_OA_MC_from_one_pi0
Definition: CbmKresConversionKF.h:161
CbmKresConversionKF::BG5_zero
TH1D * BG5_zero
Definition: CbmKresConversionKF.h:443
CbmKresConversionKF::BG3_one
TH1D * BG3_one
Definition: CbmKresConversionKF.h:473
CbmKresConversionKF::fHistoList_OneTwo_sts
vector< TH1 * > fHistoList_OneTwo_sts
Definition: CbmKresConversionKF.h:330
CbmRichHit.h
CbmKresConversionKF::fPdg_All
TH1D * fPdg_All
Definition: CbmKresConversionKF.h:174
CbmKresConversionKF::fGammaOpeningAngleReco_All_outside
TH1D * fGammaOpeningAngleReco_All_outside
Definition: CbmKresConversionKF.h:200
CbmKresConversionKF::BG4_zero
TH1D * BG4_zero
Definition: CbmKresConversionKF.h:442
CbmKresConversionKF::EMTMulti_InvMass_All_m6
TH1D * EMTMulti_InvMass_All_m6
Definition: CbmKresConversionKF.h:369
CbmRichRingFitterEllipseTau::DoFit
virtual void DoFit(CbmRichRingLight *ring)
Inherited from CbmRichRingFitterBase.
Definition: CbmRichRingFitterEllipseTau.cxx:94
CbmKresConversionKF::PdgCase8NonEComeFromTarget_onetwo
TH1D * PdgCase8NonEComeFromTarget_onetwo
Definition: CbmKresConversionKF.h:551
CbmKresConversionKF::EMTMulti_InvMass_All_m4
TH1D * EMTMulti_InvMass_All_m4
Definition: CbmKresConversionKF.h:367
CbmKresConversionKF::fGammaInvMassReco_Zero_outside
TH1D * fGammaInvMassReco_Zero_outside
Definition: CbmKresConversionKF.h:233
CbmKresConversionKF::fEMT_InvMass_Zero_outside
TH1D * fEMT_InvMass_Zero_outside
Definition: CbmKresConversionKF.h:236
CbmKresConversionKF::Finish
void Finish()
Definition: CbmKresConversionKF.cxx:1513
CbmKresConversionKF::fGlobalTracks
TClonesArray * fGlobalTracks
Definition: CbmKresConversionKF.h:85
CbmKresConversionKF::fPi0InvMassRecoKF_One_mvd
TH1D * fPi0InvMassRecoKF_One_mvd
Definition: CbmKresConversionKF.h:259
CbmKresConversionKF::BG6_all
TH1D * BG6_all
Definition: CbmKresConversionKF.h:412
CbmKresConversionKF::fHistoList_multiplicity_OneTwo
vector< TH1 * > fHistoList_multiplicity_OneTwo
Definition: CbmKresConversionKF.h:362
CbmStsTrack
Definition: CbmStsTrack.h:37
CbmKresConversionKF::fHistoList_bg_zero
vector< TH1 * > fHistoList_bg_zero
Definition: CbmKresConversionKF.h:438
CbmKresConversionKF::sameMIDcase8NonEPdg_one
TH1D * sameMIDcase8NonEPdg_one
Definition: CbmKresConversionKF.h:494
CbmKresConversionKF::EMT_multi_zero
std::vector< int > EMT_multi_zero
Definition: CbmKresConversionKF.h:144
CbmKresConversionKF::fPdg_Zero
TH1D * fPdg_Zero
Definition: CbmKresConversionKF.h:208
CbmKresConversionKF::fEMT_InvMass_OneTwo_outside
TH1D * fEMT_InvMass_OneTwo_outside
Definition: CbmKresConversionKF.h:339
CbmKresConversionKF::MultiplicityChargedParticles_OneTwo
TH2D * MultiplicityChargedParticles_OneTwo
Definition: CbmKresConversionKF.h:354
CbmKresConversionKF::CheckForCuts_InvMass_Reco_from_one_pi0_less4cm
TH1D * CheckForCuts_InvMass_Reco_from_one_pi0_less4cm
Definition: CbmKresConversionKF.h:163
CbmKresConversionKF::fHistoList_One
vector< TH1 * > fHistoList_One
Definition: CbmKresConversionKF.h:239
CbmKresConversionKF::fHistoList_One_mvd
vector< TH1 * > fHistoList_One_mvd
Definition: CbmKresConversionKF.h:256
CbmKresConversionKF::fGammaOpeningAngleReco_Zero
TH1D * fGammaOpeningAngleReco_Zero
Definition: CbmKresConversionKF.h:207
CbmKresFunctions::CalculateOpeningAngle_Reco
static Double_t CalculateOpeningAngle_Reco(TVector3 electron1, TVector3 electron2)
Definition: CbmKresFunctions.h:251
CbmKresConversionKF::sameGRIDcase8_two
TH1D * sameGRIDcase8_two
Definition: CbmKresConversionKF.h:516
CbmKresConversionBG.h
CbmKresConversionKF::EMT_multi_one
std::vector< int > EMT_multi_one
Definition: CbmKresConversionKF.h:142
CbmKresConversionKF::fGammaOpeningAngleReco_OneTwo_sts
TH1D * fGammaOpeningAngleReco_OneTwo_sts
Definition: CbmKresConversionKF.h:332
CbmKresConversionKF::fHistoList_bg_onetwo
vector< TH1 * > fHistoList_bg_onetwo
Definition: CbmKresConversionKF.h:534
CbmKresConversionKF::sameMIDcase8NonEMotherPdg_two
TH1D * sameMIDcase8NonEMotherPdg_two
Definition: CbmKresConversionKF.h:527
CbmKresFunctions::Invmass_2particles_MC
static double Invmass_2particles_MC(const CbmMCTrack *mctrack1, const CbmMCTrack *mctrack2)
Definition: CbmKresFunctions.h:92
CbmRichRingLight
Definition: CbmRichRingLight.h:39
CbmKresConversionKF::fGammaInvMassReco_Two_mvd
TH1D * fGammaInvMassReco_Two_mvd
Definition: CbmKresConversionKF.h:292
CbmKresConversionKF::sameMIDcase8NonEPdg_two
TH1D * sameMIDcase8NonEPdg_two
Definition: CbmKresConversionKF.h:526
CbmKresConversionKF::Case8NonElFrom_eta_one
TH1D * Case8NonElFrom_eta_one
Definition: CbmKresConversionKF.h:492
CbmKresConversionKF::fPdg_Two
TH1D * fPdg_Two
Definition: CbmKresConversionKF.h:277
CbmKresConversionKF::Case8ElFromDalitz_one
TH1D * Case8ElFromDalitz_one
Definition: CbmKresConversionKF.h:490
CbmKresConversionKF::fMcTracks
TClonesArray * fMcTracks
Definition: CbmKresConversionKF.h:82
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm
TH1D * CheckForCuts_OA_Reco_from_one_pi0_4cm_21cm
Definition: CbmKresConversionKF.h:166
CbmKresConversionKF::fPi0InvMassRecoKF_One
TH1D * fPi0InvMassRecoKF_One
Definition: CbmKresConversionKF.h:245
CbmKresConversionKF::sameMIDcase8_one
TH1D * sameMIDcase8_one
Definition: CbmKresConversionKF.h:483
CbmKresConversionKF::EMT_pair_momenta_multi_onetwo
std::vector< std::vector< TVector3 > > EMT_pair_momenta_multi_onetwo
Definition: CbmKresConversionKF.h:139
CbmKresConversionKF::fGammaInvMassReco_Two_target
TH1D * fGammaInvMassReco_Two_target
Definition: CbmKresConversionKF.h:286
CbmKresConversionKF::FindGammas
void FindGammas(vector< KFParticle > allgammas, vector< KFParticle > particlevector, int Event, double AngleCut, double InvMassCut, int RealPID)
Definition: CbmKresConversionKF.cxx:714
CbmKresConversionKF::EMTMulti_InvMass_Two_m2
TH1D * EMTMulti_InvMass_Two_m2
Definition: CbmKresConversionKF.h:389
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetPt_two
TH1D * sameMIDcase8NonEComeFromTargetPt_two
Definition: CbmKresConversionKF.h:532
CbmKresConversionKF::sameMIDcase8_mothedPDG_onetwo
TH1D * sameMIDcase8_mothedPDG_onetwo
Definition: CbmKresConversionKF.h:550
CbmLmvmKinematicParams
Definition: CbmLmvmKinematicParams.h:17
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetIM_one
TH1D * sameMIDcase8NonEComeFromTargetIM_one
Definition: CbmKresConversionKF.h:498
CbmLmvmKinematicParams::fPt
Double_t fPt
Definition: CbmLmvmKinematicParams.h:20
CbmKresConversionKF::EMTMulti_InvMass_Two_m6
TH1D * EMTMulti_InvMass_Two_m6
Definition: CbmKresConversionKF.h:393
CbmKresConversionKF::sameMIDcase8NonEComeFromTargetIM_zero
TH1D * sameMIDcase8NonEComeFromTargetIM_zero
Definition: CbmKresConversionKF.h:466
CbmKresConversionKF::Case8ElFromDalitz_two
TH1D * Case8ElFromDalitz_two
Definition: CbmKresConversionKF.h:522
CbmKresConversionBG::Init
void Init()
Definition: CbmKresConversionBG.cxx:25
CbmKresConversionKF::fGammaInvMassReco_One_outside
TH1D * fGammaInvMassReco_One_outside
Definition: CbmKresConversionKF.h:267
CbmKresConversionKF::fHistoList_multiplicity_Zero
vector< TH1 * > fHistoList_multiplicity_Zero
Definition: CbmKresConversionKF.h:361
CbmKresConversionKF::fHistoList_Two
vector< TH1 * > fHistoList_Two
Definition: CbmKresConversionKF.h:274
CbmRichHit
Definition: CbmRichHit.h:19
CbmKresConversionKF::fGammaOpeningAngleReco_One_target
TH1D * fGammaOpeningAngleReco_One_target
Definition: CbmKresConversionKF.h:252
CbmKresConversionKF::MultiplicityChargedParticles_Zero
TH2D * MultiplicityChargedParticles_Zero
Definition: CbmKresConversionKF.h:351
CbmKresConversionKF::CbmKresConversionKF
CbmKresConversionKF()
Definition: CbmKresConversionKF.cxx:42
CbmKresConversionKF::GammasAllMC
std::vector< std::vector< CbmMCTrack * > > GammasAllMC
Definition: CbmKresConversionKF.h:106
CbmKresConversionKF::BG4_onetwo
TH1D * BG4_onetwo
Definition: CbmKresConversionKF.h:538
CbmKresConversionKF::sameGRIDcase8_one
TH1D * sameGRIDcase8_one
Definition: CbmKresConversionKF.h:484
CbmKresConversionKF::fHistoList_OneTwo
vector< TH1 * > fHistoList_OneTwo
Definition: CbmKresConversionKF.h:308
CbmKresConversionKF::CheckForCuts_OA_Reco_from_one_pi0_more21cm
TH1D * CheckForCuts_OA_Reco_from_one_pi0_more21cm
Definition: CbmKresConversionKF.h:168
CbmLmvmKinematicParams.h
CbmKresConversionKF::fPdg_OneTwo
TH1D * fPdg_OneTwo
Definition: CbmKresConversionKF.h:311
CbmKresConversionKF::BG4_one
TH1D * BG4_one
Definition: CbmKresConversionKF.h:474
CbmKresConversionKF::EMT_Z
std::vector< Double_t > EMT_Z
Definition: CbmKresConversionKF.h:123
CbmKresConversionKF::EMT_multi_all
std::vector< int > EMT_multi_all
Definition: CbmKresConversionKF.h:141
CbmKresConversionKF::fHistoList_multiplicity
vector< TH1 * > fHistoList_multiplicity
Definition: CbmKresConversionKF.h:343
CbmKresConversionKF::fP_reco_OneTwo
TH1D * fP_reco_OneTwo
Definition: CbmKresConversionKF.h:312
CbmKresConversionKF::Init
void Init()
Definition: CbmKresConversionKF.cxx:477