CbmRoot
Loading...
Searching...
No Matches
CbmKresConversionReconstruction.cxx
Go to the documentation of this file.
1/* Copyright (C) 2017-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Ievgenii Kres, Florian Uhlig [committer] */
4
20#include "CbmKresConversionReconstruction.h"
21
22#include "CbmGlobalTrack.h"
23#include "CbmKresFunctions.h"
24#include "CbmMCTrack.h"
25#include "CbmRichRing.h"
26#include "CbmStsTrack.h"
27#include "CbmTrackMatchNew.h"
28
29#include "FairRootManager.h"
30
31#include "TH1.h"
32#include "TH1D.h"
33#include "TH2D.h"
34#include "TH3D.h"
35#include "TProfile2D.h"
36
37#include <iostream>
38
39
40using namespace std;
41
42CbmKresConversionReconstruction::CbmKresConversionReconstruction()
43 : fMcTracks(nullptr)
44 , fGlobalTracks(nullptr)
45 , fStsTracks(nullptr)
46 , fStsTrackMatches(nullptr)
47 , fRichRings(nullptr)
48 , fRichRingMatches(nullptr)
49 , STS_refmomentum()
50 , STS_MCtrack()
51 , STS_Id()
52 , STS_and_RICH_refmomentum()
53 , STS_and_RICH_MCtrack()
54 , STS_and_RICH_Id()
55 , fHistoList_reco()
56 , ConversionPoints2D(nullptr)
57 , ConversionPoints3D(nullptr)
58 , fHistoList_reco_STS_gg()
59 , fHistoList_reco_STS_and_RICH_gg()
60 , fHistoList_reco_STS_gee()
61 , fHistoList_reco_STS_and_RICH_gee()
62 , fHistoList_reco_STS_eeee()
63 , fHistoList_reco_STS_and_RICH_eeee()
64 , STS_InvMass_eeee_mc(nullptr)
65 , STS_InvMass_eeee_refitted(nullptr)
66 , STSRICH_InvMass_eeee_mc(nullptr)
67 , STSRICH_InvMass_eeee_refitted(nullptr)
68 , STS_InvMass_gee_mc(nullptr)
69 , STS_InvMass_gee_refitted(nullptr)
70 , STS_InvMass_realg_gee_reffited(nullptr)
71 , STS_InvMass_img_gee_refitted(nullptr)
72 , STS_OpeningAngle_realg_gee_mc(nullptr)
73 , STS_OpeningAngle_realg_gee_reffited(nullptr)
74 , STS_OpeningAngle_img_gee_mc(nullptr)
75 , STS_OpeningAngle_img_gee_reffited(nullptr)
76 , STSRICH_InvMass_gee_mc(nullptr)
77 , STSRICH_InvMass_gee_refitted(nullptr)
78 , STSRICH_InvMass_realg_gee_reffited(nullptr)
79 , STSRICH_InvMass_img_gee_refitted(nullptr)
80 , STSRICH_OpeningAngle_realg_gee_mc(nullptr)
81 , STSRICH_OpeningAngle_realg_gee_reffited(nullptr)
82 , STSRICH_OpeningAngle_img_gee_mc(nullptr)
83 , STSRICH_OpeningAngle_img_gee_reffited(nullptr)
84 , STS_InvMass_gg_mc(nullptr)
85 , STS_InvMass_gg_reffited(nullptr)
86 , STS_InvMass_realg_gg_mc(nullptr)
87 , STS_InvMass_realg_gg_reffited(nullptr)
88 , STS_OpeningAngle_realg_gg_mc(nullptr)
89 , STS_OpeningAngle_realg_gg_reffited(nullptr)
90 , STS_OpeningAngle_between_gg_mc(nullptr)
91 , STS_OpeningAngle_between_gg_reffited(nullptr)
92 , STSRICH_InvMass_gg_mc(nullptr)
93 , STSRICH_InvMass_gg_reffited(nullptr)
94 , STSRICH_InvMass_realg_gg_mc(nullptr)
95 , STSRICH_InvMass_realg_gg_reffited(nullptr)
96 , STSRICH_OpeningAngle_realg_gg_mc(nullptr)
97 , STSRICH_OpeningAngle_realg_gg_reffited(nullptr)
98 , STSRICH_OpeningAngle_between_gg_mc(nullptr)
99 , STSRICH_OpeningAngle_between_gg_reffited(nullptr)
100{
101}
102
103CbmKresConversionReconstruction::~CbmKresConversionReconstruction() {}
104
105void CbmKresConversionReconstruction::Init()
106{
107 InitHistograms();
108
109 FairRootManager* ioman = FairRootManager::Instance();
110 if (nullptr == ioman) { Fatal("CbmKresConversionReconstruction::Init", "RootManager not instantised!"); }
111
112 fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
113 if (nullptr == fMcTracks) { Fatal("CbmKresConversionReconstruction::Init", "No MCTrack array!"); }
114
115 fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
116 if (nullptr == fGlobalTracks) { Fatal("CbmKresConversionReconstruction::Init", "No GlobalTrack array!"); }
117
118 fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
119 if (nullptr == fStsTracks) { Fatal("CbmKresConversionReconstruction::Init", "No StsTrack array!"); }
120
121 fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
122 if (nullptr == fStsTrackMatches) { Fatal("CbmKresConversionReconstruction::Init", "No StsTrackMatch array!"); }
123
124 fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
125 if (nullptr == fRichRings) { Fatal("CbmKresConversionReconstruction::Init", "No RichRing array!"); }
126
127 fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
128 if (nullptr == fRichRingMatches) { Fatal("CbmKresConversionReconstruction::Init", "No RichRingMatch array!"); }
129}
130
131void CbmKresConversionReconstruction::Exec(int /*fEventNumRec*/)
132{
133 // cout << "CbmKresConversionReconstruction, event No. " << fEventNumRec << endl;
134
135 STS_refmomentum.clear();
136 STS_MCtrack.clear();
137 STS_Id.clear();
138 STS_and_RICH_refmomentum.clear();
139 STS_and_RICH_MCtrack.clear();
140 STS_and_RICH_Id.clear();
141
143 // ========================================================================================
144 Int_t ngTracks = fGlobalTracks->GetEntriesFast();
145 for (Int_t iTr = 0; iTr < ngTracks; iTr++) {
146 CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iTr);
147 if (nullptr == gTrack) continue;
148 int stsInd = gTrack->GetStsTrackIndex();
149 int richInd = gTrack->GetRichRingIndex();
150
151 // ========================================================================================
153 if (stsInd < 0) continue;
154 CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsInd);
155 if (stsTrack == nullptr) continue;
156 CbmTrackMatchNew* stsMatch = (CbmTrackMatchNew*) fStsTrackMatches->At(stsInd);
157 if (stsMatch == nullptr) continue;
158 if (stsMatch->GetNofLinks() <= 0) continue;
159 int stsMcTrackId = stsMatch->GetMatchedLink().GetIndex();
160 if (stsMcTrackId < 0) continue;
161 CbmMCTrack* mcTrackSTS = (CbmMCTrack*) fMcTracks->At(stsMcTrackId);
162 if (mcTrackSTS == nullptr) continue;
163 int pdgSTS = mcTrackSTS->GetPdgCode();
164 int motherIdSTS = mcTrackSTS->GetMotherId();
165 if (TMath::Abs(pdgSTS) != 11) continue;
167 // ========================================================================================
168
169
170 if (motherIdSTS == -1) continue;
171 CbmMCTrack* mcTrackMotherSTS = (CbmMCTrack*) fMcTracks->At(motherIdSTS);
172 if (mcTrackMotherSTS == nullptr) continue;
173
174 if (mcTrackMotherSTS->GetPdgCode() == 111) {}
175 else if (mcTrackMotherSTS->GetPdgCode() == 22) {
176 if (mcTrackMotherSTS->GetMotherId() == -1) continue;
177 CbmMCTrack* mcTrackMotherOfGammaSTS = (CbmMCTrack*) fMcTracks->At(mcTrackMotherSTS->GetMotherId());
178 if (mcTrackMotherOfGammaSTS->GetPdgCode() != 111) continue;
179 float xConv = mcTrackSTS->GetStartX();
180 float yConv = mcTrackSTS->GetStartY();
181 float zConv = mcTrackSTS->GetStartZ();
182 ConversionPoints3D->Fill(zConv, xConv, yConv);
183 ConversionPoints2D->Fill(zConv, yConv);
184 }
185 else {
186 continue;
187 }
188
189 TVector3 refmomentum = CbmKresFunctions::FitToVertex(stsTrack, mcTrackSTS->GetStartX(), mcTrackSTS->GetStartY(),
190 mcTrackSTS->GetStartZ());
191
192 STS_refmomentum.push_back(refmomentum);
193 STS_MCtrack.push_back(mcTrackSTS);
194 STS_Id.push_back(stsMcTrackId);
195
196
197 // ========================================================================================
199 if (richInd < 0) continue;
200 CbmRichRing* richRing = (CbmRichRing*) fRichRings->At(richInd);
201 if (richRing == nullptr) continue;
202 CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(richInd);
203 if (richMatch == nullptr) continue;
204 if (richMatch->GetNofLinks() <= 0) continue;
205 int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
206 if (richMcTrackId < 0) continue;
207 CbmMCTrack* mcTrackRICH = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
208 if (mcTrackRICH == nullptr) continue;
209 int pdgRICH = mcTrackRICH->GetPdgCode();
210 if (TMath::Abs(pdgRICH) != 11) continue;
212 // ========================================================================================
213
214 if (stsMcTrackId != richMcTrackId) continue;
215
216 STS_and_RICH_refmomentum.push_back(refmomentum);
217 STS_and_RICH_MCtrack.push_back(mcTrackSTS);
218 STS_and_RICH_Id.push_back(stsMcTrackId);
219 }
221 // ========================================================================================
222
223 MakeRecoAnalysis(STS_refmomentum, STS_MCtrack, STS_Id, fHistoList_reco_STS_gg, fHistoList_reco_STS_gee,
224 fHistoList_reco_STS_eeee);
225 MakeRecoAnalysis(STS_and_RICH_refmomentum, STS_and_RICH_MCtrack, STS_and_RICH_Id, fHistoList_reco_STS_and_RICH_gg,
226 fHistoList_reco_STS_and_RICH_gee, fHistoList_reco_STS_and_RICH_eeee);
227}
228
229void CbmKresConversionReconstruction::MakeRecoAnalysis(vector<TVector3> RefMom, vector<CbmMCTrack*> MC,
230 vector<Int_t> Id, vector<TH1*> gg, vector<TH1*> gee,
231 vector<TH1*> eeee)
232{
233 Int_t fDecayedParticlePdg = 111;
234
235 if (MC.size() < 4) return;
236
237 for (size_t i = 0; i < MC.size(); i++) {
238 for (size_t j = i + 1; j < MC.size(); j++) {
239 for (size_t k = j + 1; k < MC.size(); k++) {
240 for (size_t l = k + 1; l < MC.size(); l++) {
241
242 if (MC.at(i)->GetPdgCode() + MC.at(j)->GetPdgCode() + MC.at(k)->GetPdgCode() + MC.at(l)->GetPdgCode() != 0)
243 continue;
244
245 int motherId1 = MC.at(i)->GetMotherId();
246 int motherId2 = MC.at(j)->GetMotherId();
247 int motherId3 = MC.at(k)->GetMotherId();
248 int motherId4 = MC.at(l)->GetMotherId();
249
250 int STSmcId1 = Id.at(i);
251 int STSmcId2 = Id.at(j);
252 int STSmcId3 = Id.at(k);
253 int STSmcId4 = Id.at(l);
254 if (STSmcId1 == STSmcId2 || STSmcId1 == STSmcId3 || STSmcId1 == STSmcId4 || STSmcId2 == STSmcId3
255 || STSmcId2 == STSmcId4 || STSmcId3 == STSmcId4)
256 continue; // particle is not used twice
257
259 if (motherId1 == motherId2 && motherId1 == motherId3 && motherId1 == motherId4) {
260 if (motherId1 != -1) {
261 CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(motherId1);
262 if (nullptr == mother1) continue;
263 int mcMotherPdg1 = mother1->GetPdgCode();
264 if (mcMotherPdg1 == fDecayedParticlePdg) {
265 Double_t InvMass_true = CbmKresFunctions::Invmass_4particles_MC(MC.at(i), MC.at(j), MC.at(k), MC.at(l));
266 Double_t InvMass_reco =
267 CbmKresFunctions::Invmass_4particles_RECO(RefMom.at(i), RefMom.at(j), RefMom.at(k), RefMom.at(l));
268 cout << "Decay pi0 -> e+e-e+e- detected!\t\t mc mass: " << InvMass_true
269 << " \t reco mass: " << InvMass_reco << endl;
270 cout << "motherIds: " << motherId1 << "/" << motherId2 << "/" << motherId3 << "/" << motherId4
271 << "\t motherpdg: " << mcMotherPdg1 << "\t mctrack mass: " << mother1->GetMass() << endl;
272 cout << "pdgs: " << MC.at(i)->GetPdgCode() << "/" << MC.at(j)->GetPdgCode() << "/"
273 << MC.at(k)->GetPdgCode() << "/" << MC.at(l)->GetPdgCode() << endl;
274 eeee[0]->Fill(InvMass_true);
275 eeee[1]->Fill(InvMass_reco);
276 }
277 }
278 }
279
280
281 //================================== decay pi0 -> gamma(e+e-) e+e-
282 if ((motherId1 == motherId2 && motherId3 == motherId4) || (motherId1 == motherId3 && motherId2 == motherId4)
283 || (motherId1 == motherId4 && motherId2 == motherId3)) {
284
285 int grandmotherId1 = -1;
286 int grandmotherId2 = -1;
287 int grandmotherId3 = -1;
288 int grandmotherId4 = -1;
289
290 int mcMotherPdg1 = -1;
291 int mcMotherPdg2 = -1;
292 int mcMotherPdg3 = -1;
293 // int mcMotherPdg4 = -1;
294 int mcGrandmotherPdg1 = -1;
295 // int mcGrandmotherPdg2 = -1;
296 // int mcGrandmotherPdg3 = -1;
297 // int mcGrandmotherPdg4 = -1;
298
299 CbmMCTrack* grandmother1 = nullptr;
300
301 if (motherId1 == -1 || motherId2 == -1 || motherId3 == -1 || motherId4 == -1) continue;
302 CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(motherId1);
303 if (nullptr != mother1) mcMotherPdg1 = mother1->GetPdgCode();
304 grandmotherId1 = mother1->GetMotherId();
305 if (grandmotherId1 != -1) {
306 grandmother1 = (CbmMCTrack*) fMcTracks->At(grandmotherId1);
307 if (nullptr != grandmother1) mcGrandmotherPdg1 = grandmother1->GetPdgCode();
308 }
309 CbmMCTrack* mother2 = (CbmMCTrack*) fMcTracks->At(motherId2);
310 if (nullptr != mother2) mcMotherPdg2 = mother2->GetPdgCode();
311 grandmotherId2 = mother2->GetMotherId();
312 CbmMCTrack* mother3 = (CbmMCTrack*) fMcTracks->At(motherId3);
313 if (nullptr != mother3) mcMotherPdg3 = mother3->GetPdgCode();
314 grandmotherId3 = mother3->GetMotherId();
315 CbmMCTrack* mother4 = (CbmMCTrack*) fMcTracks->At(motherId4);
316 // if (nullptr != mother4) mcMotherPdg4 = mother4->GetPdgCode();
317 grandmotherId4 = mother4->GetMotherId();
318
319 if (motherId1 == motherId2 && motherId3 == motherId4) {
320 if (CbmKresFunctions::NofDaughters(motherId1, MC) != 2
321 || CbmKresFunctions::NofDaughters(motherId3, MC) != 2)
322 continue;
323 if ((grandmotherId1 == motherId3 && mcMotherPdg3 == fDecayedParticlePdg)
324 || (motherId1 == grandmotherId3 && mcMotherPdg1 == fDecayedParticlePdg)) {
325 Double_t InvMass_true = CbmKresFunctions::Invmass_4particles_MC(MC.at(i), MC.at(j), MC.at(k), MC.at(l));
326 Double_t InvMass_reco =
327 CbmKresFunctions::Invmass_4particles_RECO(RefMom.at(i), RefMom.at(j), RefMom.at(k), RefMom.at(l));
328 cout << "Decay pi0 -> gamma(e+e-) e+e- detected!\t\t mc mass: " << InvMass_true
329 << "\t, reco mass: " << InvMass_reco << endl;
330 cout << "motherids: " << motherId1 << "/" << motherId2 << "/" << motherId3 << "/" << motherId4 << endl;
331 cout << "pdgs " << MC.at(i)->GetPdgCode() << "/" << MC.at(j)->GetPdgCode() << "/"
332 << MC.at(k)->GetPdgCode() << "/" << MC.at(l)->GetPdgCode() << endl;
333
334 gee[0]->Fill(InvMass_true);
335 gee[1]->Fill(InvMass_reco);
336
337 TVector3 start1;
338 MC.at(i)->GetStartVertex(start1);
339 TVector3 start2;
340 MC.at(j)->GetStartVertex(start2);
341 TVector3 start3;
342 MC.at(k)->GetStartVertex(start3);
343 TVector3 start4;
344 MC.at(l)->GetStartVertex(start4);
345 cout << "start: " << start1.Z() << "/" << start2.Z() << "/" << start3.Z() << "/" << start4.Z() << endl;
346
347 if (mcGrandmotherPdg1
348 == fDecayedParticlePdg) { // case: i,j = electrons from gamma, k,l = electrons from pi0
349 Double_t InvMass_realg = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(j));
350 Double_t InvMass_img = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(k), RefMom.at(l));
351 gee[2]->Fill(InvMass_realg);
352 gee[3]->Fill(InvMass_img);
353
354 Double_t OpeningAngle_realg_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(j));
355 Double_t OpeningAngle_realg_refitted =
356 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(j));
357 gee[4]->Fill(OpeningAngle_realg_mc);
358 gee[5]->Fill(OpeningAngle_realg_refitted);
359
360 Double_t OpeningAngle_img_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(k), MC.at(l));
361 Double_t OpeningAngle_img_refitted =
362 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(k), RefMom.at(l));
363 gee[6]->Fill(OpeningAngle_img_mc);
364 gee[7]->Fill(OpeningAngle_img_refitted);
365 }
366 if (mcMotherPdg1
367 == fDecayedParticlePdg) { // case: i,j = electrons from pi0, k,l = electrons from gamma
368 Double_t InvMass_realg = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(k), RefMom.at(l));
369 Double_t InvMass_img = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(j));
370 gee[2]->Fill(InvMass_realg);
371 gee[3]->Fill(InvMass_img);
372
373 Double_t OpeningAngle_realg_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(k), MC.at(l));
374 Double_t OpeningAngle_realg_refitted =
375 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(k), RefMom.at(l));
376 gee[4]->Fill(OpeningAngle_realg_mc);
377 gee[5]->Fill(OpeningAngle_realg_refitted);
378
379 Double_t OpeningAngle_img_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(j));
380 Double_t OpeningAngle_img_refitted =
381 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(j));
382 gee[6]->Fill(OpeningAngle_img_mc);
383 gee[7]->Fill(OpeningAngle_img_refitted);
384 }
385 }
386 }
387
388 if (motherId1 == motherId3 && motherId2 == motherId4) {
389 if (CbmKresFunctions::NofDaughters(motherId1, MC) != 2
390 || CbmKresFunctions::NofDaughters(motherId2, MC) != 2)
391 continue;
392 if ((grandmotherId1 == motherId2 && mcMotherPdg2 == fDecayedParticlePdg)
393 || (motherId1 == grandmotherId2 && mcMotherPdg1 == fDecayedParticlePdg)) {
394 Double_t InvMass_true = CbmKresFunctions::Invmass_4particles_MC(MC.at(i), MC.at(j), MC.at(k), MC.at(l));
395 Double_t InvMass_reco =
396 CbmKresFunctions::Invmass_4particles_RECO(RefMom.at(i), RefMom.at(j), RefMom.at(k), RefMom.at(l));
397 cout << "Decay pi0 -> gamma(e+e-) e+e- detected!\t\t mc mass: " << InvMass_true
398 << "\t, reco mass: " << InvMass_reco << endl;
399 cout << "motherids: " << motherId1 << "/" << motherId2 << "/" << motherId3 << "/" << motherId4 << endl;
400 cout << "pdgs " << MC.at(i)->GetPdgCode() << "/" << MC.at(j)->GetPdgCode() << "/"
401 << MC.at(k)->GetPdgCode() << "/" << MC.at(l)->GetPdgCode() << endl;
402
403 gee[0]->Fill(InvMass_true);
404 gee[1]->Fill(InvMass_reco);
405
406 TVector3 start1;
407 MC.at(i)->GetStartVertex(start1);
408 TVector3 start2;
409 MC.at(j)->GetStartVertex(start2);
410 TVector3 start3;
411 MC.at(k)->GetStartVertex(start3);
412 TVector3 start4;
413 MC.at(l)->GetStartVertex(start4);
414 cout << "start: " << start1.Z() << "/" << start2.Z() << "/" << start3.Z() << "/" << start4.Z() << endl;
415
416 if (mcGrandmotherPdg1
417 == fDecayedParticlePdg) { // case: i,k = electrons from gamma, j,l = electrons from pi0
418 Double_t InvMass_realg = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(k));
419 Double_t InvMass_img = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(j), RefMom.at(l));
420 gee[2]->Fill(InvMass_realg);
421 gee[3]->Fill(InvMass_img);
422
423 Double_t OpeningAngle_realg_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(k));
424 Double_t OpeningAngle_realg_refitted =
425 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(k));
426 gee[4]->Fill(OpeningAngle_realg_mc);
427 gee[5]->Fill(OpeningAngle_realg_refitted);
428
429 Double_t OpeningAngle_img_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(j), MC.at(l));
430 Double_t OpeningAngle_img_refitted =
431 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(j), RefMom.at(l));
432 gee[6]->Fill(OpeningAngle_img_mc);
433 gee[7]->Fill(OpeningAngle_img_refitted);
434 }
435 if (mcMotherPdg1
436 == fDecayedParticlePdg) { // case: i,k = electrons from pi0, j,l = electrons from gamma
437 Double_t InvMass_realg = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(j), RefMom.at(l));
438 Double_t InvMass_img = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(k));
439 gee[2]->Fill(InvMass_realg);
440 gee[3]->Fill(InvMass_img);
441
442 Double_t OpeningAngle_realg_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(j), MC.at(l));
443 Double_t OpeningAngle_realg_refitted =
444 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(j), RefMom.at(l));
445 gee[4]->Fill(OpeningAngle_realg_mc);
446 gee[5]->Fill(OpeningAngle_realg_refitted);
447
448 Double_t OpeningAngle_img_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(k));
449 Double_t OpeningAngle_img_refitted =
450 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(k));
451 gee[6]->Fill(OpeningAngle_img_mc);
452 gee[7]->Fill(OpeningAngle_img_refitted);
453 }
454 }
455 }
456
457 if (motherId1 == motherId4 && motherId2 == motherId3) {
458 if (CbmKresFunctions::NofDaughters(motherId1, MC) != 2
459 || CbmKresFunctions::NofDaughters(motherId2, MC) != 2)
460 continue;
461 if ((grandmotherId1 == motherId2 && mcMotherPdg2 == fDecayedParticlePdg)
462 || (motherId1 == grandmotherId2 && mcMotherPdg1 == fDecayedParticlePdg)) {
463 Double_t InvMass_true = CbmKresFunctions::Invmass_4particles_MC(MC.at(i), MC.at(j), MC.at(k), MC.at(l));
464 Double_t InvMass_reco =
465 CbmKresFunctions::Invmass_4particles_RECO(RefMom.at(i), RefMom.at(j), RefMom.at(k), RefMom.at(l));
466 cout << "Decay pi0 -> gamma(e+e-) e+e- detected!\t\t mc mass: " << InvMass_true
467 << "\t, reco mass: " << InvMass_reco << endl;
468 cout << "motherids: " << motherId1 << "/" << motherId2 << "/" << motherId3 << "/" << motherId4 << endl;
469 cout << "pdgs " << MC.at(i)->GetPdgCode() << "/" << MC.at(j)->GetPdgCode() << "/"
470 << MC.at(k)->GetPdgCode() << "/" << MC.at(l)->GetPdgCode() << endl;
471
472 gee[0]->Fill(InvMass_true);
473 gee[1]->Fill(InvMass_reco);
474
475 TVector3 start1;
476 MC.at(i)->GetStartVertex(start1);
477 TVector3 start2;
478 MC.at(j)->GetStartVertex(start2);
479 TVector3 start3;
480 MC.at(k)->GetStartVertex(start3);
481 TVector3 start4;
482 MC.at(l)->GetStartVertex(start4);
483 cout << "start: " << start1.Z() << "/" << start2.Z() << "/" << start3.Z() << "/" << start4.Z() << endl;
484
485 if (mcGrandmotherPdg1
486 == fDecayedParticlePdg) { // case: i,l = electrons from gamma, k,j = electrons from pi0
487 Double_t InvMass_realg = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(l));
488 Double_t InvMass_img = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(k), RefMom.at(j));
489 gee[2]->Fill(InvMass_realg);
490 gee[3]->Fill(InvMass_img);
491
492 Double_t OpeningAngle_realg_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(l));
493 Double_t OpeningAngle_realg_refitted =
494 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(l));
495 gee[4]->Fill(OpeningAngle_realg_mc);
496 gee[5]->Fill(OpeningAngle_realg_refitted);
497
498 Double_t OpeningAngle_img_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(k), MC.at(j));
499 Double_t OpeningAngle_img_refitted =
500 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(k), RefMom.at(j));
501 gee[6]->Fill(OpeningAngle_img_mc);
502 gee[7]->Fill(OpeningAngle_img_refitted);
503 }
504 if (mcMotherPdg1
505 == fDecayedParticlePdg) { // case: i,l = electrons from pi0, k,j = electrons from gamma
506 Double_t InvMass_realg = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(k), RefMom.at(j));
507 Double_t InvMass_img = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(l));
508 gee[2]->Fill(InvMass_realg);
509 gee[3]->Fill(InvMass_img);
510
511 Double_t OpeningAngle_realg_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(k), MC.at(j));
512 Double_t OpeningAngle_realg_refitted =
513 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(k), RefMom.at(j));
514 gee[4]->Fill(OpeningAngle_realg_mc);
515 gee[5]->Fill(OpeningAngle_realg_refitted);
516
517 Double_t OpeningAngle_img_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(l));
518 Double_t OpeningAngle_img_refitted =
519 CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(l));
520 gee[6]->Fill(OpeningAngle_img_mc);
521 gee[7]->Fill(OpeningAngle_img_refitted);
522 }
523 }
524 }
525
526
527 //================================== decay pi0 -> gamma gamma -> e+e- e+e-
528 if (grandmotherId1 == grandmotherId2 && grandmotherId1 == grandmotherId3
529 && grandmotherId1 == grandmotherId4) {
530 if (mcGrandmotherPdg1 != fDecayedParticlePdg) continue;
531 Double_t InvMass_true = CbmKresFunctions::Invmass_4particles_MC(MC.at(i), MC.at(j), MC.at(k), MC.at(l));
532 Double_t InvMass_reco =
533 CbmKresFunctions::Invmass_4particles_RECO(RefMom.at(i), RefMom.at(j), RefMom.at(k), RefMom.at(l));
534 cout << "Decay pi0 -> gamma gamma -> e+e- e+e- detected!\t\t mc "
535 "mass: "
536 << InvMass_true << "\t, reco mass: " << InvMass_reco << endl;
537 cout << "motherids: " << motherId1 << "/" << motherId2 << "/" << motherId3 << "/" << motherId4 << endl;
538 cout << "grandmotherid: " << grandmotherId1 << "/" << grandmotherId2 << "/" << grandmotherId3 << "/"
539 << grandmotherId4 << endl;
540 cout << "pdgs " << MC.at(i)->GetPdgCode() << "/" << MC.at(j)->GetPdgCode() << "/"
541 << MC.at(k)->GetPdgCode() << "/" << MC.at(l)->GetPdgCode() << endl;
542
543 gg[0]->Fill(InvMass_true);
544 gg[1]->Fill(InvMass_reco);
545
546 cout << "\t \t mc true info: " << endl;
547 cout << "particle 1: \t" << MC.at(i)->GetPdgCode() << ";\t pt = " << MC.at(i)->GetPt()
548 << ";\t X = " << MC.at(i)->GetStartX() << ";\t Y = " << MC.at(i)->GetStartY()
549 << ";\t Z = " << MC.at(i)->GetStartZ() << ";\t E = " << MC.at(i)->GetEnergy() << endl;
550 cout << "particle 2: \t" << MC.at(j)->GetPdgCode() << ";\t pt = " << MC.at(j)->GetPt()
551 << ";\t X = " << MC.at(j)->GetStartX() << ";\t Y = " << MC.at(j)->GetStartY()
552 << ";\t Z = " << MC.at(j)->GetStartZ() << ";\t E = " << MC.at(j)->GetEnergy() << endl;
553 cout << "particle 3: \t" << MC.at(k)->GetPdgCode() << ";\t pt = " << MC.at(k)->GetPt()
554 << ";\t X = " << MC.at(k)->GetStartX() << ";\t Y = " << MC.at(k)->GetStartY()
555 << ";\t Z = " << MC.at(k)->GetStartZ() << ";\t E = " << MC.at(k)->GetEnergy() << endl;
556 cout << "particle 4: \t" << MC.at(l)->GetPdgCode() << ";\t pt = " << MC.at(l)->GetPt()
557 << ";\t X = " << MC.at(l)->GetStartX() << ";\t Y = " << MC.at(l)->GetStartY()
558 << ";\t Z = " << MC.at(l)->GetStartZ() << ";\t E = " << MC.at(l)->GetEnergy() << endl;
559
560 Double_t OpeningAngle1_mc = 0;
561 Double_t OpeningAngle2_mc = 0;
562 Double_t OpeningAngle1_refitted = 0;
563 Double_t OpeningAngle2_refitted = 0;
564 Double_t InvMass_realg1_mc = 0;
565 Double_t InvMass_realg2_mc = 0;
566 Double_t InvMass_realg1_refitted = 0;
567 Double_t InvMass_realg2_refitted = 0;
568
569 if (motherId1 == motherId2) {
570 OpeningAngle1_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(j));
571 OpeningAngle2_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(k), MC.at(l));
572 gg[4]->Fill(OpeningAngle1_mc);
573 gg[4]->Fill(OpeningAngle2_mc);
574 OpeningAngle1_refitted = CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(j));
575 OpeningAngle2_refitted = CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(k), RefMom.at(l));
576 gg[5]->Fill(OpeningAngle1_refitted);
577 gg[5]->Fill(OpeningAngle2_refitted);
578
579 InvMass_realg1_mc = CbmKresFunctions::Invmass_2particles_MC(MC.at(i), MC.at(j));
580 InvMass_realg2_mc = CbmKresFunctions::Invmass_2particles_MC(MC.at(k), MC.at(l));
581 gg[2]->Fill(InvMass_realg1_mc);
582 gg[2]->Fill(InvMass_realg2_mc);
583 InvMass_realg1_refitted = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(j));
584 InvMass_realg2_refitted = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(k), RefMom.at(l));
585 gg[3]->Fill(InvMass_realg1_refitted);
586 gg[3]->Fill(InvMass_realg2_refitted);
587 }
588 if (motherId1 == motherId3) {
589 OpeningAngle1_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(k));
590 OpeningAngle2_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(j), MC.at(l));
591 gg[4]->Fill(OpeningAngle1_mc);
592 gg[4]->Fill(OpeningAngle2_mc);
593 OpeningAngle1_refitted = CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(k));
594 OpeningAngle2_refitted = CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(j), RefMom.at(l));
595 gg[5]->Fill(OpeningAngle1_refitted);
596 gg[5]->Fill(OpeningAngle2_refitted);
597
598 InvMass_realg1_mc = CbmKresFunctions::Invmass_2particles_MC(MC.at(i), MC.at(k));
599 InvMass_realg2_mc = CbmKresFunctions::Invmass_2particles_MC(MC.at(j), MC.at(l));
600 gg[2]->Fill(InvMass_realg1_mc);
601 gg[2]->Fill(InvMass_realg2_mc);
602 InvMass_realg1_refitted = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(k));
603 InvMass_realg2_refitted = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(j), RefMom.at(l));
604 gg[3]->Fill(InvMass_realg1_refitted);
605 gg[3]->Fill(InvMass_realg2_refitted);
606 }
607 if (motherId1 == motherId4) {
608 OpeningAngle1_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(i), MC.at(l));
609 OpeningAngle2_mc = CbmKresFunctions::CalculateOpeningAngle_MC(MC.at(j), MC.at(k));
610 gg[4]->Fill(OpeningAngle1_mc);
611 gg[4]->Fill(OpeningAngle2_mc);
612 OpeningAngle1_refitted = CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(i), RefMom.at(l));
613 OpeningAngle2_refitted = CbmKresFunctions::CalculateOpeningAngle_Reco(RefMom.at(j), RefMom.at(k));
614 gg[5]->Fill(OpeningAngle1_refitted);
615 gg[5]->Fill(OpeningAngle2_refitted);
616
617 InvMass_realg1_mc = CbmKresFunctions::Invmass_2particles_MC(MC.at(i), MC.at(l));
618 InvMass_realg2_mc = CbmKresFunctions::Invmass_2particles_MC(MC.at(j), MC.at(k));
619 gg[2]->Fill(InvMass_realg1_mc);
620 gg[2]->Fill(InvMass_realg2_mc);
621 InvMass_realg1_refitted = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(i), RefMom.at(l));
622 InvMass_realg2_refitted = CbmKresFunctions::Invmass_2particles_RECO(RefMom.at(j), RefMom.at(k));
623 gg[3]->Fill(InvMass_realg1_refitted);
624 gg[3]->Fill(InvMass_realg2_refitted);
625 }
626 Double_t openingAngleBetweenGammas =
627 CalculateOpeningAngleBetweenGammas_MC(MC.at(i), MC.at(j), MC.at(k), MC.at(l));
628 gg[6]->Fill(openingAngleBetweenGammas);
629 Double_t openingAngleBetweenGammasReco =
630 CalculateOpeningAngleBetweenGammas_Reco(RefMom.at(i), RefMom.at(j), RefMom.at(k), RefMom.at(l));
631 gg[7]->Fill(openingAngleBetweenGammasReco);
632 }
633 }
634 }
635 }
636 }
637 }
638}
639
640
641Double_t CbmKresConversionReconstruction::CalculateOpeningAngleBetweenGammas_MC(CbmMCTrack* mctrack1,
642 CbmMCTrack* mctrack2,
643 CbmMCTrack* mctrack3,
644 CbmMCTrack* mctrack4)
645{
646 Double_t openingAngle;
647 TLorentzVector gamma1;
648 TLorentzVector gamma2;
649
650 if (mctrack1->GetMotherId() == mctrack2->GetMotherId() && mctrack3->GetMotherId() == mctrack4->GetMotherId()) {
651 CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(mctrack1->GetMotherId());
652 mother1->Get4Momentum(gamma1);
653 CbmMCTrack* mother2 = (CbmMCTrack*) fMcTracks->At(mctrack3->GetMotherId());
654 mother2->Get4Momentum(gamma2);
655 }
656 if (mctrack1->GetMotherId() == mctrack3->GetMotherId() && mctrack2->GetMotherId() == mctrack4->GetMotherId()) {
657 CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(mctrack1->GetMotherId());
658 mother1->Get4Momentum(gamma1);
659 CbmMCTrack* mother2 = (CbmMCTrack*) fMcTracks->At(mctrack2->GetMotherId());
660 mother2->Get4Momentum(gamma2);
661 }
662 if (mctrack1->GetMotherId() == mctrack4->GetMotherId() && mctrack2->GetMotherId() == mctrack3->GetMotherId()) {
663 CbmMCTrack* mother1 = (CbmMCTrack*) fMcTracks->At(mctrack1->GetMotherId());
664 mother1->Get4Momentum(gamma1);
665 CbmMCTrack* mother2 = (CbmMCTrack*) fMcTracks->At(mctrack2->GetMotherId());
666 mother2->Get4Momentum(gamma2);
667 }
668
669 Double_t angle = gamma1.Angle(gamma2.Vect());
670 openingAngle = 180. * angle / TMath::Pi();
671
672 return openingAngle;
673}
674
675
676Double_t CbmKresConversionReconstruction::CalculateOpeningAngleBetweenGammas_Reco(TVector3 electron1,
677 TVector3 electron2,
678 TVector3 electron3,
679 TVector3 electron4)
680{
681 Double_t energy1 = TMath::Sqrt(electron1.Mag2() + M2E);
682 TLorentzVector lorVec1(electron1, energy1);
683
684 Double_t energy2 = TMath::Sqrt(electron2.Mag2() + M2E);
685 TLorentzVector lorVec2(electron2, energy2);
686
687 Double_t energy3 = TMath::Sqrt(electron3.Mag2() + M2E);
688 TLorentzVector lorVec3(electron3, energy3);
689
690 Double_t energy4 = TMath::Sqrt(electron4.Mag2() + M2E);
691 TLorentzVector lorVec4(electron4, energy4);
692
693 TLorentzVector lorPhoton1 = lorVec1 + lorVec2;
694 TLorentzVector lorPhoton2 = lorVec3 + lorVec4;
695
696 Double_t angleBetweenPhotons = lorPhoton1.Angle(lorPhoton2.Vect());
697 Double_t theta = 180. * angleBetweenPhotons / TMath::Pi();
698
699 return theta;
700}
701
702
703void CbmKresConversionReconstruction::Finish()
704{
705 gDirectory->mkdir("Reconstruction");
706 gDirectory->cd("Reconstruction");
707
708 gDirectory->mkdir("STS");
709 gDirectory->cd("STS");
710
711 gDirectory->mkdir("STS_gg");
712 gDirectory->cd("STS_gg");
713 for (UInt_t i = 0; i < fHistoList_reco_STS_gg.size(); i++) {
714 fHistoList_reco_STS_gg[i]->Write();
715 }
716 gDirectory->cd("..");
717
718 gDirectory->mkdir("STS_gee");
719 gDirectory->cd("STS_gee");
720 for (UInt_t i = 0; i < fHistoList_reco_STS_gee.size(); i++) {
721 fHistoList_reco_STS_gee[i]->Write();
722 }
723 gDirectory->cd("..");
724
725 gDirectory->mkdir("STS_eeee");
726 gDirectory->cd("STS_eeee");
727 for (UInt_t i = 0; i < fHistoList_reco_STS_eeee.size(); i++) {
728 fHistoList_reco_STS_eeee[i]->Write();
729 }
730 gDirectory->cd("..");
731 gDirectory->cd("..");
732
733 gDirectory->mkdir("STS_and_RICH");
734 gDirectory->cd("STS_and_RICH");
735
736 gDirectory->mkdir("STS_and_RICH_gg");
737 gDirectory->cd("STS_and_RICH_gg");
738 for (UInt_t i = 0; i < fHistoList_reco_STS_and_RICH_gg.size(); i++) {
739 fHistoList_reco_STS_and_RICH_gg[i]->Write();
740 }
741 gDirectory->cd("..");
742
743 gDirectory->mkdir("STS_and_RICH_gee");
744 gDirectory->cd("STS_and_RICH_gee");
745 for (UInt_t i = 0; i < fHistoList_reco_STS_and_RICH_gee.size(); i++) {
746 fHistoList_reco_STS_and_RICH_gee[i]->Write();
747 }
748 gDirectory->cd("..");
749
750 gDirectory->mkdir("STS_and_RICH_eeee");
751 gDirectory->cd("STS_and_RICH_eeee");
752 for (UInt_t i = 0; i < fHistoList_reco_STS_and_RICH_eeee.size(); i++) {
753 fHistoList_reco_STS_and_RICH_eeee[i]->Write();
754 }
755 gDirectory->cd("..");
756 gDirectory->cd("..");
757
758 for (UInt_t i = 0; i < fHistoList_reco.size(); i++) {
759 fHistoList_reco[i]->Write();
760 }
761 gDirectory->cd("..");
762}
763
764
765void CbmKresConversionReconstruction::InitHistograms()
766{
767 ConversionPoints2D =
768 new TH2D("ConversionPoints2D", "Conversion Points 2D ; z [cm]; y [cm]", 200, -1, 200, 300, -150, 150);
769 fHistoList_reco.push_back(ConversionPoints2D);
770 ConversionPoints3D = new TH3D("ConversionPoints3D", "Conversion Points 3D ; z [cm]; x [cm]; y [cm]", 200, -1, 200,
771 300, -150, 150, 300, -150, 150);
772 fHistoList_reco.push_back(ConversionPoints3D);
773
775 STS_InvMass_eeee_mc =
776 new TH1D("STS_InvMass_eeee_mc", "STS_InvMass_eeee_mc; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
777 fHistoList_reco_STS_eeee.push_back(STS_InvMass_eeee_mc);
778 STS_InvMass_eeee_refitted =
779 new TH1D("STS_InvMass_eeee_refitted", "STS_InvMass_eeee_refitted; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
780 fHistoList_reco_STS_eeee.push_back(STS_InvMass_eeee_refitted);
781
783 STSRICH_InvMass_eeee_mc =
784 new TH1D("STSRICH_InvMass_eeee_mc", "STSRICH_InvMass_eeee_mc; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
785 fHistoList_reco_STS_and_RICH_eeee.push_back(STSRICH_InvMass_eeee_mc);
786 STSRICH_InvMass_eeee_refitted = new TH1D(
787 "STSRICH_InvMass_eeee_refitted", "STSRICH_InvMass_eeee_refitted; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
788 fHistoList_reco_STS_and_RICH_eeee.push_back(STSRICH_InvMass_eeee_refitted);
789
791 STS_InvMass_gee_mc =
792 new TH1D("STS_InvMass_gee_mc", "STS_InvMass_gee_mc; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
793 fHistoList_reco_STS_gee.push_back(STS_InvMass_gee_mc);
794 STS_InvMass_gee_refitted =
795 new TH1D("STS_InvMass_gee_refitted", "STS_InvMass_gee_refitted; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
796 fHistoList_reco_STS_gee.push_back(STS_InvMass_gee_refitted);
797 STS_InvMass_realg_gee_reffited = new TH1D(
798 "STS_InvMass_realg_gee_reffited", "STS_InvMass_realg_gee_reffited; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
799 fHistoList_reco_STS_gee.push_back(STS_InvMass_realg_gee_reffited);
800 STS_InvMass_img_gee_refitted = new TH1D(
801 "STS_InvMass_img_gee_refitted", "STS_InvMass_img_gee_refitted; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
802 fHistoList_reco_STS_gee.push_back(STS_InvMass_img_gee_refitted);
803 STS_OpeningAngle_realg_gee_mc =
804 new TH1D("STS_OpeningAngle_realg_gee_mc", "STS_OpeningAngle_realg_gee_mc (between e+e- from #gamma); angle [deg];#",
805 300, -0.1, 29.9);
806 fHistoList_reco_STS_gee.push_back(STS_OpeningAngle_realg_gee_mc);
807 STS_OpeningAngle_realg_gee_reffited = new TH1D("STS_OpeningAngle_realg_gee_reffited",
808 "STS_OpeningAngle_realg_gee_reffited (between e+e- from #gamma); "
809 "angle [deg];#",
810 300, -0.1, 29.9);
811 fHistoList_reco_STS_gee.push_back(STS_OpeningAngle_realg_gee_reffited);
812 STS_OpeningAngle_img_gee_mc = new TH1D("STS_OpeningAngle_img_gee_mc",
813 "STS_OpeningAngle_img_gee_mc (between e+e- from imaginary "
814 "#gamma); angle [deg];#",
815 300, -0.1, 29.9);
816 fHistoList_reco_STS_gee.push_back(STS_OpeningAngle_img_gee_mc);
817 STS_OpeningAngle_img_gee_reffited = new TH1D("STS_OpeningAngle_img_gee_reffited",
818 "STS_OpeningAngle_img_gee_reffited (between e+e- from imaginary "
819 "#gamma); angle [deg];#",
820 300, -0.1, 29.9);
821 fHistoList_reco_STS_gee.push_back(STS_OpeningAngle_img_gee_reffited);
822
824 STSRICH_InvMass_gee_mc =
825 new TH1D("STSRICH_InvMass_gee_mc", "STSRICH_InvMass_gee_mc; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
826 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_InvMass_gee_mc);
827 STSRICH_InvMass_gee_refitted = new TH1D(
828 "STSRICH_InvMass_gee_refitted", "STSRICH_InvMass_gee_refitted; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
829 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_InvMass_gee_refitted);
830 STSRICH_InvMass_realg_gee_reffited =
831 new TH1D("STSRICH_InvMass_realg_gee_reffited", "STSRICH_InvMass_realg_gee_reffited; invariant mass in GeV/c^{2};#",
832 110, -0.01, 0.1);
833 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_InvMass_realg_gee_reffited);
834 STSRICH_InvMass_img_gee_refitted =
835 new TH1D("STSRICH_InvMass_img_gee_refitted", "STSRICH_InvMass_img_gee_refitted; invariant mass in GeV/c^{2};#", 110,
836 -0.01, 0.1);
837 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_InvMass_img_gee_refitted);
838 STSRICH_OpeningAngle_realg_gee_mc = new TH1D("STSRICH_OpeningAngle_realg_gee_mc",
839 "STSRICH_OpeningAngle_realg_gee_mc (between e+e- from #gamma); "
840 "angle [deg];#",
841 300, -0.1, 29.9);
842 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_OpeningAngle_realg_gee_mc);
843 STSRICH_OpeningAngle_realg_gee_reffited = new TH1D("STSRICH_OpeningAngle_realg_gee_reffited",
844 "STSRICH_OpeningAngle_realg_gee_reffited (between e+e- from "
845 "#gamma); angle [deg];#",
846 300, -0.1, 29.9);
847 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_OpeningAngle_realg_gee_reffited);
848 STSRICH_OpeningAngle_img_gee_mc = new TH1D("STSRICH_OpeningAngle_img_gee_mc",
849 "STSRICH_OpeningAngle_img_gee_mc (between e+e- from imaginary "
850 "#gamma); angle [deg];#",
851 300, -0.1, 29.9);
852 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_OpeningAngle_img_gee_mc);
853 STSRICH_OpeningAngle_img_gee_reffited = new TH1D("STSRICH_OpeningAngle_img_gee_reffited",
854 "STSRICH_OpeningAngle_img_gee_reffited (between e+e- from "
855 "imaginary #gamma); angle [deg];#",
856 300, -0.1, 29.9);
857 fHistoList_reco_STS_and_RICH_gee.push_back(STSRICH_OpeningAngle_img_gee_reffited);
858
860 STS_InvMass_gg_mc =
861 new TH1D("STS_InvMass_gg_mc", "STS_InvMass_gg_mc; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
862 fHistoList_reco_STS_gg.push_back(STS_InvMass_gg_mc);
863 STS_InvMass_gg_reffited =
864 new TH1D("STS_InvMass_gg_reffited", "STS_InvMass_gg_reffited; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
865 fHistoList_reco_STS_gg.push_back(STS_InvMass_gg_reffited);
866 STS_InvMass_realg_gg_mc =
867 new TH1D("STS_InvMass_realg_gg_mc", "STS_InvMass_realg_gg_mc; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
868 fHistoList_reco_STS_gg.push_back(STS_InvMass_realg_gg_mc);
869 STS_InvMass_realg_gg_reffited = new TH1D(
870 "STS_InvMass_realg_gg_reffited", "STS_InvMass_realg_gg_reffited; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
871 fHistoList_reco_STS_gg.push_back(STS_InvMass_realg_gg_reffited);
872 STS_OpeningAngle_realg_gg_mc =
873 new TH1D("STS_OpeningAngle_realg_gg_mc", "STS_OpeningAngle_realg_gg_mc (between e+e- from #gamma); angle [deg];#",
874 300, -0.1, 29.9);
875 fHistoList_reco_STS_gg.push_back(STS_OpeningAngle_realg_gg_mc);
876 STS_OpeningAngle_realg_gg_reffited = new TH1D("STS_OpeningAngle_realg_gg_reffited",
877 "STS_OpeningAngle_realg_gg_reffited (between e+e- from #gamma); "
878 "angle [deg];#",
879 300, -0.1, 29.9);
880 fHistoList_reco_STS_gg.push_back(STS_OpeningAngle_realg_gg_reffited);
881 STS_OpeningAngle_between_gg_mc = new TH1D("STS_OpeningAngle_between_gg_mc",
882 "STS_OpeningAngle_between_gg_mc (between #gamma#gamma from "
883 "#pi^{0}); angle [deg];#",
884 300, -0.1, 29.9);
885 fHistoList_reco_STS_gg.push_back(STS_OpeningAngle_between_gg_mc);
886 STS_OpeningAngle_between_gg_reffited = new TH1D("STS_OpeningAngle_between_gg_reffited",
887 "STS_OpeningAngle_between_gg_reffited (between #gamma#gamma from "
888 "#pi^{0}); angle [deg];#",
889 300, -0.1, 29.9);
890 fHistoList_reco_STS_gg.push_back(STS_OpeningAngle_between_gg_reffited);
891
893 STSRICH_InvMass_gg_mc =
894 new TH1D("STSRICH_InvMass_gg_mc", "STSRICH_InvMass_gg_mc; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
895 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_InvMass_gg_mc);
896 STSRICH_InvMass_gg_reffited = new TH1D("STSRICH_InvMass_gg_reffited",
897 "STSRICH_InvMass_gg_reffited; invariant mass in GeV/c^{2};#", 410, -0.01, 0.4);
898 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_InvMass_gg_reffited);
899 STSRICH_InvMass_realg_gg_mc = new TH1D("STSRICH_InvMass_realg_gg_mc",
900 "STSRICH_InvMass_realg_gg_mc; invariant mass in GeV/c^{2};#", 110, -0.01, 0.1);
901 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_InvMass_realg_gg_mc);
902 STSRICH_InvMass_realg_gg_reffited =
903 new TH1D("STSRICH_InvMass_realg_gg_reffited", "STSRICH_InvMass_realg_gg_reffited; invariant mass in GeV/c^{2};#",
904 110, -0.01, 0.1);
905 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_InvMass_realg_gg_reffited);
906 STSRICH_OpeningAngle_realg_gg_mc = new TH1D("STSRICH_OpeningAngle_realg_gg_mc",
907 "STSRICH_OpeningAngle_realg_gg_mc (between e+e- from #gamma); "
908 "angle [deg];#",
909 300, -0.1, 29.9);
910 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_OpeningAngle_realg_gg_mc);
911 STSRICH_OpeningAngle_realg_gg_reffited = new TH1D("STSRICH_OpeningAngle_realg_gg_reffited",
912 "STSRICH_OpeningAngle_realg_gg_reffited (between e+e- from "
913 "#gamma); angle [deg];#",
914 300, -0.1, 29.9);
915 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_OpeningAngle_realg_gg_reffited);
916 STSRICH_OpeningAngle_between_gg_mc = new TH1D("STSRICH_OpeningAngle_between_gg_mc",
917 "STSRICH_OpeningAngle_between_gg_mc (between #gamma#gamma from "
918 "#pi^{0}); angle [deg];#",
919 300, -0.1, 29.9);
920 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_OpeningAngle_between_gg_mc);
921 STSRICH_OpeningAngle_between_gg_reffited = new TH1D("STSRICH_OpeningAngle_between_gg_reffited",
922 "STSRICH_OpeningAngle_between_gg_reffited (between #gamma#gamma "
923 "from #pi^{0}); angle [deg];#",
924 300, -0.1, 29.9);
925 fHistoList_reco_STS_and_RICH_gg.push_back(STSRICH_OpeningAngle_between_gg_reffited);
926}
M2E
#define M2E
Definition CbmAnaJpsiKinematicParams.h:14
CbmStsTrack.h
Data class for STS tracks.
CbmGlobalTrack::GetStsTrackIndex
int32_t GetStsTrackIndex() const
Definition CbmGlobalTrack.h:44
CbmGlobalTrack::GetRichRingIndex
int32_t GetRichRingIndex() const
Definition CbmGlobalTrack.h:47
CbmKresConversionReconstruction::CalculateOpeningAngleBetweenGammas_MC
Double_t CalculateOpeningAngleBetweenGammas_MC(CbmMCTrack *mctrack1, CbmMCTrack *mctrack2, CbmMCTrack *mctrack3, CbmMCTrack *mctrack4)
Definition CbmKresConversionReconstruction.cxx:641
CbmKresConversionReconstruction::MakeRecoAnalysis
void MakeRecoAnalysis(vector< TVector3 > RefMom, vector< CbmMCTrack * > MC, vector< Int_t > Id, vector< TH1 * > gg, vector< TH1 * > gee, vector< TH1 * > eeee)
Definition CbmKresConversionReconstruction.cxx:229
CbmKresConversionReconstruction::CalculateOpeningAngleBetweenGammas_Reco
Double_t CalculateOpeningAngleBetweenGammas_Reco(TVector3 electron1, TVector3 electron2, TVector3 electron3, TVector3 electron4)
Definition CbmKresConversionReconstruction.cxx:676
CbmKresFunctions::NofDaughters
static int NofDaughters(int motherId, vector< CbmMCTrack * > MC)
Definition CbmKresFunctions.h:169
CbmKresFunctions::CalculateOpeningAngle_Reco
static Double_t CalculateOpeningAngle_Reco(TVector3 electron1, TVector3 electron2)
Definition CbmKresFunctions.h:247
CbmKresFunctions::Invmass_2particles_MC
static double Invmass_2particles_MC(const CbmMCTrack *mctrack1, const CbmMCTrack *mctrack2)
Definition CbmKresFunctions.h:95
CbmKresFunctions::CalculateOpeningAngle_MC
static Double_t CalculateOpeningAngle_MC(CbmMCTrack *mctrack1, CbmMCTrack *mctrack2)
Definition CbmKresFunctions.h:263
CbmKresFunctions::Invmass_2particles_RECO
static double Invmass_2particles_RECO(const TVector3 part1, const TVector3 part2)
Definition CbmKresFunctions.h:110
CbmKresFunctions::Invmass_4particles_MC
static double Invmass_4particles_MC(const CbmMCTrack *mctrack1, const CbmMCTrack *mctrack2, const CbmMCTrack *mctrack3, const CbmMCTrack *mctrack4)
Definition CbmKresFunctions.h:125
CbmKresFunctions::FitToVertex
static TVector3 FitToVertex(CbmStsTrack *stsTrack, double x, double y, double z)
Definition CbmKresFunctions.h:34
CbmKresFunctions::Invmass_4particles_RECO
static double Invmass_4particles_RECO(const TVector3 part1, const TVector3 part2, const TVector3 part3, const TVector3 part4)
Definition CbmKresFunctions.h:147
CbmMCTrack::GetStartZ
double GetStartZ() const
Definition CbmMCTrack.h:75
CbmMCTrack::GetMotherId
int32_t GetMotherId() const
Definition CbmMCTrack.h:69
CbmMCTrack::GetMass
double GetMass() const
Mass of the associated particle.
Definition CbmMCTrack.cxx:115
CbmMCTrack::GetStartX
double GetStartX() const
Definition CbmMCTrack.h:73
CbmMCTrack::GetPdgCode
int32_t GetPdgCode() const
Definition CbmMCTrack.h:68
CbmMCTrack::Get4Momentum
void Get4Momentum(TLorentzVector &momentum) const
Definition CbmMCTrack.h:173
CbmMCTrack::GetStartY
double GetStartY() const
Definition CbmMCTrack.h:74
CbmMatch::GetNofLinks
int32_t GetNofLinks() const
Definition CbmMatch.h:42
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition CbmMatch.h:41
std
Hash for CbmL1LinkKey.
Definition algo/base/Options.cxx:21