CbmRoot
CbmKresConversionGeneral.cxx
Go to the documentation of this file.
1 
13 #include "CbmKresConversionGeneral.h"
14 
15 #include "CbmGlobalTrack.h"
16 #include "CbmMCTrack.h"
17 #include "CbmRichHit.h"
18 #include "CbmRichPoint.h"
19 #include "CbmRichRing.h"
20 #include "CbmRichRingFitterEllipseTau.h"
21 #include "CbmRichRingLight.h"
22 #include "CbmRichUtil.h"
23 #include "CbmStsTrack.h"
24 #include "CbmTrackMatchNew.h"
25 #include "FairRootManager.h"
26 #include "TGraph.h"
27 #include "TH1.h"
28 #include "TH1D.h"
29 #include "TH2D.h"
30 #include "TH3D.h"
31 #include "TProfile2D.h"
32 
33 #include <iostream>
34 
35 using namespace std;
36 
37 CbmKresConversionGeneral::CbmKresConversionGeneral()
38  : fMcTracks(nullptr)
39  , fGlobalTracks(nullptr)
40  , fStsTracks(nullptr)
41  , fStsTrackMatches(nullptr)
42  , fRichPoints(nullptr)
43  , fRichHits(nullptr)
44  , fRichRings(nullptr)
45  , fRichRingMatches(nullptr)
46  , fRichProjections(nullptr)
47  , fArrayCentrality(nullptr)
48  , fTauFit(nullptr)
49  , fMinAaxis(0.)
50  , fMaxAaxis(0.)
51  , fMinBaxis(0.)
52  , fMaxBaxis(0.)
53  , fMinRadius(0.)
54  , fMaxRadius(0.)
55  , fitt(nullptr)
56  , imageellipse(nullptr)
57  , imagehits(nullptr)
58  , fHistoList()
59  , fHistoList_MC()
60  , ForChristian_P_vs_R(nullptr)
61  , AllPoints2D(nullptr)
62  , AllPoints3D(nullptr)
63  , MC_PdgCodes(nullptr)
64  , MC_All_photons_Pt(nullptr)
65  , MC_Not_Direct_photons_Pt(nullptr)
66  , MC_Direct_photons_Pt(nullptr)
67  , MC_All_photons_P(nullptr)
68  , MC_Not_Direct_photons_P(nullptr)
69  , MC_Direct_photons_P(nullptr)
70  , MC_photons_mother_Pdg(nullptr)
71  , MC_Not_Direct_photons_theta(nullptr)
72  , MC_Not_Direct_photons_theta_vs_rap(nullptr)
73  , MC_Direct_photons_theta(nullptr)
74  , MC_Direct_photons_theta_vs_rap(nullptr)
75  , MC_Direct_photons_Pt_vs_rap(nullptr)
76  , MC_Direct_photons_Pt_vs_rap_est(nullptr)
77  , MC_electrons_Pt_vs_rap_est(nullptr)
78  , MC_Reconstructed_electrons_Pt_vs_rap_est(nullptr)
79  , MC_omega_Pt_vs_rap_est(nullptr)
80  , MC_pi0_Pt(nullptr)
81  , MC_pi0_Pt_est(nullptr)
82  , MC_pi0_Pt_vs_rap(nullptr)
83  , MC_pi0_Pt_vs_rap_primary(nullptr)
84  , Pi0_pt_vs_rap_est(nullptr)
85  , Pi0_pt_vs_rap_est_primary(nullptr)
86  , MC_pi0_theta(nullptr)
87  , MC_pi0_phi(nullptr)
88  , MC_pi0_Rapidity(nullptr)
89  , MC_pi0_theta_vs_rap(nullptr)
90  , MC_leptons_conversion_ZY(nullptr)
91  , MC_leptons_conversion_XY(nullptr)
92  , MC_leptons_conversion_XZ(nullptr)
93  , MC_leptons_from_pi0_start_vertex(nullptr)
94  , MC_leptons_from_pi0_P(nullptr)
95  , MC_eta_Pt(nullptr)
96  , MC_eta_Pt_vs_rap(nullptr)
97  , MC_eta_Pt_vs_rap_primary(nullptr)
98  , MC_eta_theta(nullptr)
99  , MC_eta_theta_vs_rap(nullptr)
100  , BoA_electrons(nullptr)
101  , BoA_1d_electrons(nullptr)
102  , A_1d_electrons(nullptr)
103  , B_1d_electrons(nullptr)
104  , A_electrons(nullptr)
105  , B_electrons(nullptr)
106  , NumberOfRings_electrons(nullptr)
107  , AllHits_electrons(nullptr)
108  , dR_electrons(nullptr)
109  , dR2d_electrons(nullptr)
110  , Distance_electron(nullptr)
111  , Distance_positron(nullptr)
112  , Tracks_electrons(nullptr)
113  , Rings_electrons(nullptr)
114  , fhBoverAXYZ(nullptr)
115  , fhBaxisXYZ(nullptr)
116  , fhAaxisXYZ(nullptr)
117  , fhdRXYZ(nullptr)
118  , Test_rings(nullptr)
119  , AllPointsPerPMT(nullptr)
120  , AllPointsPerPixel(nullptr)
121  , AllHits2D(nullptr)
122  , AllHits3D(nullptr)
123  , AllHitsPerPMT(nullptr)
124  , AllHitsPerPixel(nullptr)
125  , temporarygraph(nullptr)
126  , HitsPerPmtFullPlane(nullptr)
127  , HitsPerPmtFullMiddle(nullptr) {
128  // ranges for the good rings. A and B are major and minor axes of the ellipse.
129  fMinAaxis = 3.;
130  fMaxAaxis = 7.;
131  fMinBaxis = 3.;
132  fMaxBaxis = 7.;
133  fMinRadius = 3.;
134  fMaxRadius = 7.;
135 }
136 
137 CbmKresConversionGeneral::~CbmKresConversionGeneral() {}
138 
139 void CbmKresConversionGeneral::Init() {
140  InitHistograms();
141 
142  FairRootManager* ioman = FairRootManager::Instance();
143  if (nullptr == ioman) {
144  Fatal("CbmKresConversionGeneral::Init", "RootManager not instantised!");
145  }
146 
147  fMcTracks = (TClonesArray*) ioman->GetObject("MCTrack");
148  if (nullptr == fMcTracks) {
149  Fatal("CbmKresConversionGeneral::Init", "No MCTrack array!");
150  }
151 
152  fGlobalTracks = (TClonesArray*) ioman->GetObject("GlobalTrack");
153  if (nullptr == fGlobalTracks) {
154  Fatal("CbmKresConversionGeneral::Init", "No GlobalTrack array!");
155  }
156 
157  fStsTracks = (TClonesArray*) ioman->GetObject("StsTrack");
158  if (nullptr == fStsTracks) {
159  Fatal("CbmKresConversionGeneral::Init", "No StsTrack array!");
160  }
161 
162  fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
163  if (nullptr == fStsTrackMatches) {
164  Fatal("CbmKresConversionGeneral::Init", "No StsTrackMatch array!");
165  }
166 
167  fRichPoints = (TClonesArray*) ioman->GetObject("RichPoint");
168  if (nullptr == fRichPoints) {
169  Fatal("CbmKresConversionGeneral::Init", "No RichPoint array!");
170  }
171 
172  fRichHits = (TClonesArray*) ioman->GetObject("RichHit");
173  if (nullptr == fRichHits) {
174  Fatal("CbmKresConversionGeneral::Init", "No RichHit array!");
175  }
176 
177  fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
178  if (nullptr == fRichRings) {
179  Fatal("CbmKresConversionGeneral::Init", "No RichRing array!");
180  }
181 
182  fRichRingMatches = (TClonesArray*) ioman->GetObject("RichRingMatch");
183  if (nullptr == fRichRingMatches) {
184  Fatal("CbmKresConversionGeneral::Init", "No RichRingMatch array!");
185  }
186 
187  fRichProjections = (TClonesArray*) ioman->GetObject("RichProjection");
188  if (nullptr == fRichProjections) {
189  Fatal("CbmKresConversionGeneral::Init", "No RichProjection array!");
190  }
191 
192  fArrayCentrality = (FairMCEventHeader*) ioman->GetObject("MCEventHeader.");
193  if (nullptr == fArrayCentrality) {
194  Fatal("CbmAnaConversion2::Init", "No fArrayCentrality array!");
195  }
196 
197  fTauFit =
198  new CbmRichRingFitterEllipseTau();
199 }
200 
201 
202 void CbmKresConversionGeneral::Exec(int /*fEventNumGen*/) {
203  // cout << "CbmKresConversionGeneral, event No. " << fEventNumGen << endl;
204 
205  // ========================================================================================
207  CbmRichRingLight ringPoint;
208  int nofRichPoints = fRichPoints->GetEntriesFast();
209  for (int i = 0; i < nofRichPoints; i++) {
210  CbmRichPoint* point = (CbmRichPoint*) fRichPoints->At(i);
211  if (point == nullptr) continue;
212  // cout << "Point: id = " << point->GetTrackID() << endl;
213  double xPOINT = point->GetX();
214  double yPOINT = point->GetY();
215  double zPOINT = point->GetZ();
216  AllPoints3D->Fill(xPOINT, yPOINT, zPOINT);
217  AllPoints2D->Fill(xPOINT, yPOINT);
218  AllPointsPerPMT->Fill(xPOINT, yPOINT);
219  AllPointsPerPixel->Fill(xPOINT, yPOINT);
220  }
222  // ========================================================================================
223 
224  temporarygraph->Reset();
225  // ========================================================================================
227  int nofRichHits = fRichHits->GetEntriesFast();
228  for (int i = 0; i < nofRichHits; i++) {
229  CbmRichHit* hit = (CbmRichHit*) fRichHits->At(i);
230  if (hit == nullptr) continue;
231  // cout << "Hits: id = " << hit->GetRefId() << endl;
232  double xHIT = hit->GetX();
233  double yHIT = hit->GetY();
234  double zHIT = hit->GetZ();
235  AllHits3D->Fill(xHIT, yHIT, zHIT);
236  AllHits2D->Fill(xHIT, yHIT);
237  AllHitsPerPMT->Fill(xHIT, yHIT);
238  AllHitsPerPixel->Fill(xHIT, yHIT);
239  temporarygraph->Fill(xHIT, yHIT);
240  }
242  // ========================================================================================
243 
244  for (int ix = 1; ix <= temporarygraph->GetNbinsX(); ix++) {
245  for (int iy = 1; iy <= temporarygraph->GetNbinsY(); iy++) {
246  if (temporarygraph->GetBinContent(ix, iy) == 0) continue;
247  HitsPerPmtFullPlane->Fill(temporarygraph->GetBinContent(ix, iy));
248  if (iy <= 6)
249  HitsPerPmtFullMiddle->Fill(temporarygraph->GetBinContent(ix, iy));
250  }
251  }
252 
253  // ========================================================================================
255  Int_t nofMcTracks = fMcTracks->GetEntriesFast();
256  for (int i = 0; i < nofMcTracks; i++) {
257  CbmMCTrack* mctrack = (CbmMCTrack*) fMcTracks->At(i);
258  if (mctrack == nullptr) continue;
259  // cout << "Track: id = " << i << "; pdg = " << mctrack->GetPdgCode() << "; motherID = " << mctrack->GetMotherId() << endl;
260  MC_PdgCodes->Fill(TMath::Abs(mctrack->GetPdgCode()));
261 
262 
263  //***** pi0 analysis
264  if (TMath::Abs(mctrack->GetPdgCode()) == 111) {
265  TVector3 v, momentum;
266  mctrack->GetStartVertex(v);
267  mctrack->GetMomentum(momentum);
268  MC_pi0_Pt->Fill(mctrack->GetPt());
269  MC_pi0_Rapidity->Fill(mctrack->GetRapidity());
270  if (mctrack->GetRapidity() > 1.2 && mctrack->GetRapidity() < 4.0)
271  MC_pi0_Pt_est->Fill(mctrack->GetPt());
272  MC_pi0_Pt_vs_rap->Fill(mctrack->GetRapidity(), mctrack->GetPt());
273  Pi0_pt_vs_rap_est->Fill(mctrack->GetRapidity(), mctrack->GetPt());
274  if (mctrack->GetMotherId() == -1) {
275  MC_pi0_Pt_vs_rap_primary->Fill(mctrack->GetRapidity(),
276  mctrack->GetPt());
277  Pi0_pt_vs_rap_est_primary->Fill(mctrack->GetRapidity(),
278  mctrack->GetPt());
279  }
280  MC_pi0_theta->Fill(momentum.Theta() * 180. / TMath::Pi());
281  MC_pi0_phi->Fill(momentum.Phi() * 180. / TMath::Pi());
282  MC_pi0_theta_vs_rap->Fill(momentum.Theta() * 180. / TMath::Pi(),
283  mctrack->GetRapidity());
284  }
285 
286  //***** eta analysis
287  if (TMath::Abs(mctrack->GetPdgCode()) == 221) {
288  TVector3 v, momentum;
289  mctrack->GetStartVertex(v);
290  mctrack->GetMomentum(momentum);
291  MC_eta_Pt->Fill(mctrack->GetPt());
292  MC_eta_Pt_vs_rap->Fill(mctrack->GetRapidity(), mctrack->GetPt());
293  if (mctrack->GetMotherId() == -1)
294  MC_eta_Pt_vs_rap_primary->Fill(mctrack->GetRapidity(),
295  mctrack->GetPt());
296  MC_eta_theta->Fill(momentum.Theta() * 180. / TMath::Pi());
297  MC_eta_theta_vs_rap->Fill(momentum.Theta() * 180. / TMath::Pi(),
298  mctrack->GetRapidity());
299  }
300 
301  //***** photons analysis
302  if (mctrack->GetPdgCode() == 22) {
303  TVector3 v, momentum;
304  mctrack->GetStartVertex(v);
305  mctrack->GetMomentum(momentum);
306 
307  MC_All_photons_Pt->Fill(mctrack->GetPt());
308  MC_All_photons_P->Fill(mctrack->GetP());
309  if (mctrack->GetMotherId() != -1) {
310  CbmMCTrack* mcTrackmama =
311  (CbmMCTrack*) fMcTracks->At(mctrack->GetMotherId());
312  MC_photons_mother_Pdg->Fill(mcTrackmama->GetPdgCode());
313  MC_Not_Direct_photons_Pt->Fill(mctrack->GetPt());
314  MC_Not_Direct_photons_P->Fill(mctrack->GetP());
315  MC_Not_Direct_photons_theta->Fill(momentum.Theta() * 180.
316  / TMath::Pi());
317  MC_Not_Direct_photons_theta_vs_rap->Fill(
318  momentum.Theta() * 180. / TMath::Pi(), mctrack->GetRapidity());
319  }
320  if (mctrack->GetMotherId() == -1) {
321  MC_photons_mother_Pdg->Fill(mctrack->GetMotherId());
322  MC_Direct_photons_Pt->Fill(mctrack->GetPt());
323  MC_Direct_photons_P->Fill(mctrack->GetP());
324  MC_Direct_photons_Pt_vs_rap->Fill(mctrack->GetRapidity(),
325  mctrack->GetPt());
326  MC_Direct_photons_Pt_vs_rap_est->Fill(mctrack->GetRapidity(),
327  mctrack->GetPt());
328  MC_Direct_photons_theta->Fill(momentum.Theta() * 180. / TMath::Pi());
329  MC_Direct_photons_theta_vs_rap->Fill(
330  momentum.Theta() * 180. / TMath::Pi(), mctrack->GetRapidity());
331  }
332  }
333 
334  //***** electrons and positrons from -> gamma conversion -> pi0
335  if (TMath::Abs(mctrack->GetPdgCode()) == 11) {
336  int motherId = mctrack->GetMotherId();
337  MC_electrons_Pt_vs_rap_est->Fill(mctrack->GetRapidity(),
338  mctrack->GetPt());
339  if (motherId == -1) continue;
340  CbmMCTrack* mother = (CbmMCTrack*) fMcTracks->At(motherId);
341  if (nullptr == mother) continue;
342  int grandmotherId = mother->GetMotherId();
343  if (grandmotherId == -1) continue;
344  CbmMCTrack* grandmother = (CbmMCTrack*) fMcTracks->At(grandmotherId);
345  if (nullptr == grandmother) continue;
346  int mcGrandmotherPdg = grandmother->GetPdgCode();
347  if (mcGrandmotherPdg == 111) {
348  MC_leptons_from_pi0_start_vertex->Fill(mctrack->GetStartZ(),
349  mctrack->GetStartY());
350  MC_leptons_from_pi0_P->Fill(mctrack->GetP());
351  }
352  MC_leptons_conversion_ZY->Fill(mctrack->GetStartZ(),
353  mctrack->GetStartY());
354  MC_leptons_conversion_XY->Fill(mctrack->GetStartX(),
355  mctrack->GetStartY());
356  MC_leptons_conversion_XZ->Fill(mctrack->GetStartX(),
357  mctrack->GetStartZ());
358  }
359 
360  // omega
361  if (TMath::Abs(mctrack->GetPdgCode()) == 223) {
362  MC_omega_Pt_vs_rap_est->Fill(mctrack->GetRapidity(), mctrack->GetPt());
363  }
364  }
366  // ========================================================================================
367 
368 
371  // ========================================================================================
372  Int_t ngTracks = fGlobalTracks->GetEntriesFast();
373  for (Int_t iTr = 0; iTr < ngTracks; iTr++) {
374  CbmGlobalTrack* gTrack = (CbmGlobalTrack*) fGlobalTracks->At(iTr);
375  if (nullptr == gTrack) continue;
376  int stsInd = gTrack->GetStsTrackIndex();
377  int richInd = gTrack->GetRichRingIndex();
378 
379  // ========================================================================================
381  if (stsInd < 0) continue;
382  CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsInd);
383  if (stsTrack == nullptr) continue;
384  CbmTrackMatchNew* stsMatch = (CbmTrackMatchNew*) fStsTrackMatches->At(
385  stsInd);
386  if (stsMatch == nullptr) continue;
387  if (stsMatch->GetNofLinks() <= 0) continue;
388  int stsMcTrackId = stsMatch->GetMatchedLink().GetIndex();
389  if (stsMcTrackId < 0) continue;
390  CbmMCTrack* mcTrackSTS = (CbmMCTrack*) fMcTracks->At(stsMcTrackId);
391  if (mcTrackSTS == nullptr) continue;
392  int pdgSTS = mcTrackSTS->GetPdgCode();
393 
395  if (TMath::Abs(mcTrackSTS->GetPdgCode()) == 11
396  || TMath::Abs(mcTrackSTS->GetPdgCode()) == 211) {
397  if (richInd >= 0) {
398  CbmRichRing* richRing = (CbmRichRing*) fRichRings->At(richInd);
399  if (richRing == nullptr) continue;
400  CbmTrackMatchNew* richMatch =
401  (CbmTrackMatchNew*) fRichRingMatches->At(richInd);
402  if (richMatch == nullptr) continue;
403  if (richMatch->GetNofLinks() <= 0) continue;
404  int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
405  if (richMcTrackId < 0) continue;
406  CbmMCTrack* mcTrackRICH = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
407  if (mcTrackRICH == nullptr) continue;
408  int pdgRICH = mcTrackRICH->GetPdgCode();
409  if (TMath::Abs(pdgRICH) != 11 && TMath::Abs(pdgRICH) != 211) continue;
410  if (stsMcTrackId != richMcTrackId) continue;
411  ForChristian_P_vs_R->Fill(mcTrackSTS->GetP(), richRing->GetRadius());
412  }
413  }
414 
415  if (TMath::Abs(pdgSTS) != 11) continue;
416 
417 
418  Tracks_electrons->Fill(1);
420  // ========================================================================================
421 
422  // ========================================================================================
424  if (richInd < 0) continue;
425  CbmRichRing* richRing = (CbmRichRing*) fRichRings->At(richInd);
426  if (richRing == nullptr) continue;
427  CbmTrackMatchNew* richMatch = (CbmTrackMatchNew*) fRichRingMatches->At(
428  richInd);
429  if (richMatch == nullptr) continue;
430  if (richMatch->GetNofLinks() <= 0) continue;
431  int richMcTrackId = richMatch->GetMatchedLink().GetIndex();
432  if (richMcTrackId < 0) continue;
433  CbmMCTrack* mcTrackRICH = (CbmMCTrack*) fMcTracks->At(richMcTrackId);
434  if (mcTrackRICH == nullptr) continue;
435  int pdgRICH = mcTrackRICH->GetPdgCode();
436  if (TMath::Abs(pdgRICH) != 11) continue;
438  // ========================================================================================
439 
440  if (stsMcTrackId != richMcTrackId) continue;
441 
442  Rings_electrons->Fill(1);
443 
444  // ========================================================================================
446  CbmRichRingLight ringHit;
447  int nofHits = richRing->GetNofHits();
448  for (int i = 0; i < nofHits; i++) {
449  Int_t hitInd = richRing->GetHit(i);
450  CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
451  if (nullptr == hit) continue;
452  CbmRichHitLight hl(hit->GetX(), hit->GetY());
453  ringHit.AddHit(hl);
454  }
455  FitAndFillHistEllipse(&ringHit); // fit hits with ellipse
456 
457  if (ringHit.GetAaxis() > fMinAaxis && ringHit.GetAaxis() < fMaxAaxis
458  && ringHit.GetBaxis() > fMinBaxis
459  && ringHit.GetAaxis() < fMaxBaxis) {
460  if (mcTrackRICH->GetPdgCode() == -11)
461  Distance_positron->Fill(richRing->GetCenterX(),
462  richRing->GetCenterY(),
463  CbmRichUtil::GetRingTrackDistance(iTr));
464  if (mcTrackRICH->GetPdgCode() == 11)
465  Distance_electron->Fill(richRing->GetCenterX(),
466  richRing->GetCenterY(),
467  CbmRichUtil::GetRingTrackDistance(iTr));
468  double a = ringHit.GetAaxis();
469  double b = ringHit.GetBaxis();
470  double p = ringHit.GetPhi();
471  double xc = ringHit.GetCenterX();
472  double yc = ringHit.GetCenterY();
473  BoA_electrons->Fill(xc, yc, b / a);
474  BoA_1d_electrons->Fill(b / a);
475  A_1d_electrons->Fill(a);
476  B_1d_electrons->Fill(b);
477  A_electrons->Fill(xc, yc, a);
478  B_electrons->Fill(xc, yc, b);
479  NumberOfRings_electrons->Fill(xc, yc);
480 
481  fhBoverAXYZ->Fill(xc, yc, b / a);
482  fhBaxisXYZ->Fill(xc, yc, b);
483  fhAaxisXYZ->Fill(xc, yc, a);
484 
485  MC_Reconstructed_electrons_Pt_vs_rap_est->Fill(mcTrackRICH->GetRapidity(),
486  mcTrackRICH->GetPt());
487 
488  // ding a closest position of the ring to the hit
489  double minAngle = 0.;
490  double maxAngle = 2 * 3.14159265358979323846;
491  double stepAngle = 0.01;
492  for (int iH = 0; iH < ringHit.GetNofHits(); iH++) {
493  double xh = ringHit.GetHit(iH).fX;
494  double yh = ringHit.GetHit(iH).fY;
495  AllHits_electrons->Fill(xh, yh);
496  double Lmin = 50.;
497  double xmin = 0.;
498  double ymin = 0.;
499  for (double iT = minAngle; iT < maxAngle; iT = iT + stepAngle) {
500  double xEll = a * cos(iT) * cos(p) - b * sin(iT) * sin(p) + xc;
501  double yEll = a * cos(iT) * sin(p) + b * sin(iT) * cos(p) + yc;
502  double L =
503  sqrt((xh - xEll) * (xh - xEll) + (yh - yEll) * (yh - yEll));
504  if (L < Lmin) {
505  Lmin = L;
506  xmin = xEll;
507  ymin = yEll;
508  }
509  }
510  Double_t sign =
511  sqrt((xmin - xc) * (xmin - xc) + (ymin - yc) * (ymin - yc))
512  - sqrt((xh - xc) * (xh - xc) + (yh - yc) * (yh - yc));
513  double dr = Lmin;
514  if (sign < 0) { dr = -Lmin; }
515  dR_electrons->Fill(dr);
516  dR2d_electrons->Fill(xc, yc, dr);
517  fhdRXYZ->Fill(xc, yc, dr);
518  }
519  }
521  // ========================================================================================
522  }
524  // ========================================================================================
525 }
526 
527 void CbmKresConversionGeneral::FitAndFillHistEllipse(CbmRichRingLight* ring) {
528  fTauFit->DoFit(ring);
529 }
530 
531 
532 void CbmKresConversionGeneral::Finish() {
533  BoA_electrons->SetMaximum(1.);
534  BoA_electrons->SetMinimum(0.8);
535  A_electrons->SetMaximum(5.5);
536  A_electrons->SetMinimum(4.);
537  B_electrons->SetMaximum(5.);
538  B_electrons->SetMinimum(4.);
539  dR2d_electrons->SetMaximum(0.35);
540  dR2d_electrons->SetMinimum(0.15);
541  Distance_electron->SetMaximum(2.);
542  Distance_electron->SetMinimum(0.);
543  Distance_positron->SetMaximum(2.);
544  Distance_positron->SetMinimum(0.);
545 
546  gDirectory->mkdir("General");
547  gDirectory->cd("General");
548  gDirectory->mkdir("MC_info");
549  gDirectory->cd("MC_info");
550  for (size_t i = 0; i < fHistoList_MC.size(); i++) {
551  fHistoList_MC[i]->Write();
552  }
553  gDirectory->cd("..");
554  for (size_t i = 0; i < fHistoList.size(); i++) {
555  fHistoList[i]->Write();
556  }
557  gDirectory->cd("..");
558 }
559 
560 
561 void CbmKresConversionGeneral::InitHistograms() {
562  //***** photons analysis
563  MC_All_photons_Pt =
564  new TH1D("MC_All_photons_Pt",
565  "Monte Carlo, all #gamma, p_{t} distribution; p_{t} in GeV/c",
566  200,
567  0,
568  2);
569  fHistoList_MC.push_back(MC_All_photons_Pt);
570 
571  MC_Not_Direct_photons_Pt = new TH1D(
572  "MC_Not_Direct_photons_Pt",
573  "Monte Carlo, #gamma from decays, p_{t} distribution; p_{t} in GeV/c",
574  200,
575  0,
576  2);
577  fHistoList_MC.push_back(MC_Not_Direct_photons_Pt);
578 
579  MC_Direct_photons_Pt = new TH1D(
580  "MC_Direct_photons_Pt",
581  "Monte Carlo, direct #gamma, p_{t} distribution; p_{t} in GeV/c",
582  200,
583  0,
584  2);
585  fHistoList_MC.push_back(MC_Direct_photons_Pt);
586 
587  MC_All_photons_P =
588  new TH1D("MC_All_photons_P",
589  "Monte Carlo, all #gamma, p distribution; p in GeV/c",
590  1000,
591  0,
592  10);
593  fHistoList_MC.push_back(MC_All_photons_P);
594 
595  MC_Not_Direct_photons_P =
596  new TH1D("MC_Not_Direct_photons_P",
597  "Monte Carlo, #gamma from decays, p distribution; p in GeV/c",
598  1000,
599  0,
600  10);
601  fHistoList_MC.push_back(MC_Not_Direct_photons_P);
602 
603  MC_Direct_photons_P =
604  new TH1D("MC_Direct_photons_P",
605  "Monte Carlo, direct #gamma, p distribution; p in GeV/c",
606  1000,
607  0,
608  10);
609  fHistoList_MC.push_back(MC_Direct_photons_P);
610 
611  MC_Direct_photons_Pt_vs_rap =
612  new TH2D("MC_Direct_photons_Pt_vs_rap",
613  "Monte Carlo, direct #gamma, p_{t} vs rapidity distribution; "
614  "rapidity y; p_{t} in GeV/c ",
615  90,
616  -2.,
617  7.,
618  60,
619  -1.,
620  5.);
621  fHistoList_MC.push_back(MC_Direct_photons_Pt_vs_rap);
622 
623  MC_Direct_photons_Pt_vs_rap_est =
624  new TH2D("MC_Direct_photons_Pt_vs_rap_est",
625  "Monte Carlo, direct #gamma, p_{t} vs rapidity distribution; "
626  "rapidity y; p_{t} in GeV/c ",
627  10,
628  0.,
629  4.,
630  40,
631  0.,
632  4.);
633  fHistoList_MC.push_back(MC_Direct_photons_Pt_vs_rap_est);
634 
635  MC_photons_mother_Pdg = new TH1D(
636  "MC_photons_mother_Pdg", "MC_photons_mother_Pdg; Id;#", 2500, -10, 2511);
637  fHistoList_MC.push_back(MC_photons_mother_Pdg);
638 
639  MC_Not_Direct_photons_theta =
640  new TH1D("MC_Not_Direct_photons_theta",
641  "Monte Carlo, #gamma from decays, #theta distribution; "
642  "emission angle #theta in deg;Entries",
643  180.,
644  0.,
645  180.);
646  fHistoList_MC.push_back(MC_Not_Direct_photons_theta);
647 
648  MC_Not_Direct_photons_theta_vs_rap =
649  new TH2D("MC_Not_Direct_photons_theta_vs_rap",
650  "Monte Carlo, #gamma from decays, #theta vs rapidity "
651  "distribution; emission angle #theta in deg; rapidity y",
652  180.,
653  0.,
654  180.,
655  270,
656  -2.,
657  7.);
658  fHistoList_MC.push_back(MC_Not_Direct_photons_theta_vs_rap);
659 
660  MC_Direct_photons_theta =
661  new TH1D("MC_Direct_photons_theta",
662  "Monte Carlo, direct #gamma, #theta distribution; emission "
663  "angle #theta in deg;Entries",
664  180.,
665  0.,
666  180.);
667  fHistoList_MC.push_back(MC_Direct_photons_theta);
668 
669  MC_Direct_photons_theta_vs_rap =
670  new TH2D("MC_Direct_photons_theta_vs_rap",
671  "Monte Carlo, direct #gamma, #theta vs rapidity distribution; "
672  "emission angle #theta in deg; rapidity y",
673  180.,
674  0.,
675  180.,
676  270,
677  -2.,
678  7.);
679  fHistoList_MC.push_back(MC_Direct_photons_theta_vs_rap);
680 
681  MC_electrons_Pt_vs_rap_est =
682  new TH2D("MC_electrons_Pt_vs_rap_est",
683  "Monte Carlo, direct e, p_{t} vs rapidity distribution; "
684  "rapidity y; p_{t} in GeV/c ",
685  10,
686  0.,
687  4.,
688  40,
689  0.,
690  4.);
691  fHistoList_MC.push_back(MC_electrons_Pt_vs_rap_est);
692 
693  MC_Reconstructed_electrons_Pt_vs_rap_est =
694  new TH2D("MC_Reconstructed_electrons_Pt_vs_rap_est",
695  "Monte Carlo, reconstructed e, p_{t} vs rapidity "
696  "distribution; rapidity y; p_{t} in GeV/c ",
697  10,
698  0.,
699  4.,
700  40,
701  0.,
702  4.);
703  fHistoList_MC.push_back(MC_Reconstructed_electrons_Pt_vs_rap_est);
704 
705  MC_omega_Pt_vs_rap_est =
706  new TH2D("MC_omega_Pt_vs_rap_est",
707  "Monte Carlo, #omega, p_{t} vs rapidity distribution; "
708  "rapidity y; p_{t} in GeV/c ",
709  10,
710  0.,
711  4.,
712  40,
713  0.,
714  4.);
715  fHistoList_MC.push_back(MC_omega_Pt_vs_rap_est);
716 
717 
718  //***** pi0 analysis
719  MC_pi0_Pt = new TH1D(
720  "MC_pi0_Pt",
721  "Monte Carlo, #pi^{0}, p_{t} distribution;p_{t} in GeV/c; Entries",
722  200.,
723  0.,
724  10.);
725  fHistoList_MC.push_back(MC_pi0_Pt);
726 
727  MC_pi0_Pt_est = new TH1D(
728  "MC_pi0_Pt_est",
729  "Monte Carlo, #pi^{0}, p_{t} distribution;p_{t} in GeV/c; Entries",
730  20.,
731  0.,
732  2.);
733  fHistoList_MC.push_back(MC_pi0_Pt_est);
734 
735  MC_pi0_Pt_vs_rap = new TH2D("MC_pi0_Pt_vs_rap",
736  "Monte Carlo, #pi^{0}, p_{t} vs rapidity "
737  "distribution; rapidity y; p_{t} in GeV/c ",
738  90,
739  -2.,
740  7.,
741  60,
742  -1.,
743  5.);
744  fHistoList_MC.push_back(MC_pi0_Pt_vs_rap);
745 
746  MC_pi0_Pt_vs_rap_primary =
747  new TH2D("MC_pi0_Pt_vs_rap_primary",
748  "Monte Carlo, primary #pi^{0}, p_{t} vs rapidity "
749  "distribution; rapidity y; p_{t} in GeV/c ",
750  90,
751  -2.,
752  7.,
753  60,
754  -1.,
755  5.);
756  fHistoList_MC.push_back(MC_pi0_Pt_vs_rap_primary);
757 
758  Pi0_pt_vs_rap_est = new TH2D("Pi0_pt_vs_rap_est",
759  "Pi0_pt_vs_rap_est; rapidity y; p_{t} in GeV/c ",
760  10,
761  0.,
762  4.,
763  40,
764  0.,
765  4.);
766  fHistoList_MC.push_back(Pi0_pt_vs_rap_est);
767 
768  Pi0_pt_vs_rap_est_primary =
769  new TH2D("Pi0_pt_vs_rap_est_primary",
770  "Pi0_pt_vs_rap_est_primary; rapidity y; p_{t} in GeV/c ",
771  10,
772  0.,
773  4.,
774  40,
775  0.,
776  4.);
777  fHistoList_MC.push_back(Pi0_pt_vs_rap_est_primary);
778 
779  MC_pi0_theta = new TH1D("MC_pi0_theta",
780  "Monte Carlo, #pi^{0}, #theta distribution; "
781  "emission angle #theta in deg;Entries",
782  180.,
783  0.,
784  180.);
785  fHistoList_MC.push_back(MC_pi0_theta);
786 
787  MC_pi0_phi = new TH1D("MC_pi0_phi",
788  "Monte Carlo, #pi^{0}, #phi distribution; emission "
789  "angle #phi in deg; Entries",
790  180.,
791  -180.,
792  180.);
793  fHistoList_MC.push_back(MC_pi0_phi);
794 
795  MC_pi0_Rapidity =
796  new TH1D("MC_pi0_Rapidity",
797  "Monte Carlo, #pi^{0}, #rapidity distribution; emission angle "
798  "#phi in deg; Entries",
799  90,
800  -2.,
801  7.);
802  fHistoList_MC.push_back(MC_pi0_Rapidity);
803 
804  MC_pi0_theta_vs_rap =
805  new TH2D("MC_pi0_theta_vs_rap",
806  "Monte Carlo, #pi^{0}, #theta vs rapidity distribution; "
807  "emission angle #theta in deg; rapidity y",
808  180.,
809  0.,
810  180.,
811  270,
812  -2.,
813  7.);
814  fHistoList_MC.push_back(MC_pi0_theta_vs_rap);
815 
816  MC_leptons_conversion_ZY =
817  new TH2D("MC_leptons_conversion_ZY",
818  "Start vertices of leptons coming from #gamma; z[cm]; y[cm]",
819  800,
820  -1,
821  400,
822  880,
823  -220,
824  220);
825  fHistoList_MC.push_back(MC_leptons_conversion_ZY);
826  MC_leptons_conversion_XY =
827  new TH2D("MC_leptons_conversion_XY",
828  "Start vertices of leptons coming from #gamma; x[cm]; y[cm]",
829  1200,
830  -300,
831  300,
832  880,
833  -220,
834  220);
835  fHistoList_MC.push_back(MC_leptons_conversion_XY);
836  MC_leptons_conversion_XZ =
837  new TH2D("MC_leptons_conversion_XZ",
838  "Start vertices of leptons coming from #gamma; x[cm]; z[cm]",
839  1200,
840  -300,
841  300,
842  800,
843  -1,
844  400);
845  fHistoList_MC.push_back(MC_leptons_conversion_XZ);
846 
847  MC_leptons_from_pi0_start_vertex =
848  new TH2D("MC_leptons_from_pi0_start_vertex",
849  "Start vertices of leptons coming from #pi^{0}; z[cm]; y[cm]",
850  200,
851  -1,
852  100,
853  200,
854  -50,
855  50);
856  fHistoList_MC.push_back(MC_leptons_from_pi0_start_vertex);
857 
858  MC_leptons_from_pi0_P = new TH1D("MC_leptons_from_pi0_P",
859  "MC_leptons_from_pi0_P; P_{e} in GeV/c",
860  200,
861  0,
862  5);
863  fHistoList_MC.push_back(MC_leptons_from_pi0_P);
864 
865  //***** eta analysis
866  MC_eta_Pt = new TH1D(
867  "MC_eta_Pt",
868  "Monte Carlo, #eta, p_{t} distribution; p_{t} in GeV/c;Entries",
869  200.,
870  0.,
871  10.);
872  fHistoList_MC.push_back(MC_eta_Pt);
873 
874  MC_eta_Pt_vs_rap = new TH2D("MC_eta_Pt_vs_rap",
875  "Monte Carlo, #eta, p_{t} vs rapidity "
876  "distribution; rapidity y; p_{t} in GeV/c ",
877  90,
878  -2.,
879  7.,
880  60,
881  -1.,
882  5.);
883  fHistoList_MC.push_back(MC_eta_Pt_vs_rap);
884 
885  MC_eta_Pt_vs_rap_primary =
886  new TH2D("MC_eta_Pt_vs_rap_primary",
887  "Monte Carlo, primary #eta, p_{t} vs rapidity distribution; "
888  "rapidity y; p_{t} in GeV/c ",
889  90,
890  -2.,
891  7.,
892  60,
893  -1.,
894  5.);
895  fHistoList_MC.push_back(MC_eta_Pt_vs_rap_primary);
896 
897  MC_eta_theta = new TH1D("MC_eta_theta",
898  "Monte Carlo, #eta, #theta distribution; "
899  "emission angle #theta in deg; Entries",
900  180.,
901  0.,
902  180.);
903  fHistoList_MC.push_back(MC_eta_theta);
904 
905  MC_eta_theta_vs_rap =
906  new TH2D("MC_eta_theta_vs_rap",
907  "Monte Carlo, #eta, #theta vs rapidity distribution; emission "
908  "angle #theta in deg; rapidity y",
909  180.,
910  0.,
911  180.,
912  270,
913  -2.,
914  7.);
915  fHistoList_MC.push_back(MC_eta_theta_vs_rap);
916 
917  //***** RICH analysis: A, B, dR, points, hits
918  ForChristian_P_vs_R = new TH2D("ForChristian_P_vs_R",
919  "ForChristian_P_vs_R; P [GeV]; R [cm]; Nof",
920  100,
921  0,
922  10,
923  100,
924  0,
925  8);
926  fHistoList.push_back(ForChristian_P_vs_R);
927 
928  AllPoints2D = new TH2D("AllPoints2D",
929  "AllPoints2D; X [cm]; Y [cm]; Nof",
930  300,
931  -150,
932  150,
933  120,
934  120,
935  240);
936  fHistoList.push_back(AllPoints2D);
937 
938  AllPoints3D = new TH3D("AllPoints3D",
939  "AllPoints3D; X [cm]; Y [cm]; Z [cm]",
940  300,
941  -150,
942  150,
943  120,
944  120,
945  240,
946  100,
947  160,
948  260);
949  fHistoList.push_back(AllPoints3D);
950 
951  MC_PdgCodes = new TH1D(
952  "MC_PdgCodes", "All PdgCodes from Monte Carlo; PDG code", 3500, 0, 3500);
953  fHistoList.push_back(MC_PdgCodes);
954 
955  BoA_electrons = new TProfile2D("BoA_electrons",
956  "B/A for electrons; X [cm]; Y [cm]",
957  60,
958  -150,
959  150,
960  20,
961  120,
962  220);
963  fHistoList.push_back(BoA_electrons);
964 
965  A_1d_electrons =
966  new TH1D("A_1d_electrons", "A for electrons; A [cm]", 200, 3., 7.);
967  fHistoList.push_back(A_1d_electrons);
968 
969  B_1d_electrons =
970  new TH1D("B_1d_electrons", "B for electrons; B [cm]", 200, 3., 7.);
971  fHistoList.push_back(B_1d_electrons);
972 
973  BoA_1d_electrons =
974  new TH1D("BoA_1d_electrons", "BoA for electrons; B/A", 250, 0.5, 1.);
975  fHistoList.push_back(BoA_1d_electrons);
976 
977  Tracks_electrons =
978  new TH1D("Tracks_electrons", "Electron tracks in STS", 3, -0.5, 2.5);
979  fHistoList.push_back(Tracks_electrons);
980 
981  Rings_electrons =
982  new TH1D("Rings_electrons", "Electron tracks in STS+RICH", 3, -0.5, 2.5);
983  fHistoList.push_back(Rings_electrons);
984 
985  A_electrons = new TProfile2D("A_electrons",
986  "A for electrons; X [cm]; Y [cm]",
987  60,
988  -150,
989  150,
990  20,
991  120,
992  220);
993  fHistoList.push_back(A_electrons);
994 
995  B_electrons = new TProfile2D("B_electrons",
996  "B for electrons; X [cm]; Y [cm]",
997  60,
998  -150,
999  150,
1000  20,
1001  120,
1002  220);
1003  fHistoList.push_back(B_electrons);
1004 
1005  NumberOfRings_electrons =
1006  new TH2D("NumberOfRings_electrons",
1007  "Number of rings from electrons; X [cm]; Y [cm]; Nof",
1008  60,
1009  -150,
1010  150,
1011  20,
1012  120,
1013  220);
1014  fHistoList.push_back(NumberOfRings_electrons);
1015 
1016  AllHits_electrons =
1017  new TH2D("AllHits_electrons",
1018  "Hits from electrons after unfolding; X [cm]; Y [cm]; Nof",
1019  300,
1020  -150,
1021  150,
1022  120,
1023  120,
1024  240);
1025  fHistoList.push_back(AllHits_electrons);
1026 
1027  dR_electrons =
1028  new TH1D("dR_electrons", "dR for electrons; dR [cm]", 100, -2., 2.);
1029  fHistoList.push_back(dR_electrons);
1030 
1031  dR2d_electrons = new TProfile2D("dR2d_electrons",
1032  "dR for electrons; X [cm]; Y [cm]",
1033  60,
1034  -150,
1035  150,
1036  20,
1037  120,
1038  220,
1039  0,
1040  1);
1041  fHistoList.push_back(dR2d_electrons);
1042 
1043  Distance_electron =
1044  new TProfile2D("Distance_electron",
1045  "Distance between projected track and center of the ring "
1046  "for electrons; X [cm];Y [cm]; Nof",
1047  60,
1048  -150,
1049  150,
1050  20,
1051  120,
1052  220);
1053  fHistoList.push_back(Distance_electron);
1054 
1055  Distance_positron =
1056  new TProfile2D("Distance_positron",
1057  "Distance between projected track and center of the ring "
1058  "for positrons; X [cm];Y [cm]; Nof",
1059  60,
1060  -150,
1061  150,
1062  20,
1063  120,
1064  220);
1065  fHistoList.push_back(Distance_positron);
1066 
1067  fhBoverAXYZ = new TH3D("fhBoverAXYZ",
1068  "fhBoverAXYZ; X [cm]; Y [cm]; B/A",
1069  60,
1070  -150,
1071  150,
1072  20,
1073  120,
1074  220,
1075  50,
1076  0.,
1077  1.);
1078  fHistoList.push_back(fhBoverAXYZ);
1079  fhBaxisXYZ = new TH3D("fhBaxisXYZ",
1080  "fhBaxisXYZ; X [cm]; Y [cm]; B [cm]",
1081  60,
1082  -150,
1083  150,
1084  20,
1085  120,
1086  220,
1087  80,
1088  3.,
1089  7.);
1090  fHistoList.push_back(fhBaxisXYZ);
1091  fhAaxisXYZ = new TH3D("fhAaxisXYZ",
1092  "fhAaxisXYZ; X [cm]; Y [cm]; A [cm]",
1093  60,
1094  -150,
1095  150,
1096  20,
1097  120,
1098  220,
1099  80,
1100  3.,
1101  7.);
1102  fHistoList.push_back(fhAaxisXYZ);
1103  fhdRXYZ = new TH3D("fhdRXYZ",
1104  "fhdRXYZ; X [cm]; Y [cm]; dR [cm]",
1105  60,
1106  -150,
1107  150,
1108  20,
1109  120,
1110  220,
1111  100,
1112  -1.,
1113  1.);
1114  fHistoList.push_back(fhdRXYZ);
1115 
1116  Test_rings =
1117  new TH2D("Test_rings", "Test_rings", 60, -150, 150, 20, 120, 220);
1118  fHistoList.push_back(Test_rings);
1119 
1120  AllPointsPerPMT = new TH2D("AllPointsPerPMT",
1121  "AllPointsPerPMT; X [cm]; Y [cm]; Nof",
1122  41,
1123  -105,
1124  105,
1125  17,
1126  125,
1127  210);
1128  fHistoList.push_back(AllPointsPerPMT);
1129  AllPointsPerPixel = new TH2D("AllPointsPerPixel",
1130  "AllPointsPerPixel; X [cm]; Y [cm]; Nof",
1131  350,
1132  -105,
1133  105,
1134  142,
1135  125,
1136  210);
1137  fHistoList.push_back(AllPointsPerPixel);
1138  AllHitsPerPMT = new TH2D("AllHitsPerPMT",
1139  "AllHitsPerPMT; X [cm]; Y [cm]; Nof",
1140  41,
1141  -105,
1142  105,
1143  17,
1144  125,
1145  210);
1146  fHistoList.push_back(AllHitsPerPMT);
1147  AllHitsPerPixel = new TH2D("AllHitsPerPixel",
1148  "AllHitsPerPixel; X [cm]; Y [cm]; Nof",
1149  350,
1150  -105,
1151  105,
1152  142,
1153  125,
1154  210);
1155  fHistoList.push_back(AllHitsPerPixel);
1156 
1157  AllHits2D = new TH2D("AllHits2D",
1158  "AllHits2D; X [cm]; Y [cm]; Nof",
1159  300,
1160  -150,
1161  150,
1162  120,
1163  120,
1164  240);
1165  fHistoList.push_back(AllHits2D);
1166  AllHits3D = new TH3D("AllHits3D",
1167  "AllHits3D; X [cm]; Y [cm]; Z [cm]",
1168  300,
1169  -150.,
1170  150,
1171  120,
1172  120,
1173  240,
1174  100,
1175  160,
1176  260);
1177  fHistoList.push_back(AllHits3D);
1178 
1179  temporarygraph = new TH2D("temporarygraph",
1180  "temporarygraph; X [cm]; Y [cm]; Nof",
1181  41,
1182  -105,
1183  105,
1184  17,
1185  125,
1186  210);
1187  fHistoList.push_back(temporarygraph);
1188  HitsPerPmtFullPlane =
1189  new TH1D("HitsPerPmtFullPlane",
1190  "Number of hits per PMT. Distribution for all PMTs; Nof photons",
1191  50,
1192  -0.5,
1193  49.5);
1194  fHistoList.push_back(HitsPerPmtFullPlane);
1195  HitsPerPmtFullMiddle =
1196  new TH1D("HitsPerPmtFullMiddle",
1197  "Number of hits per PMT. Distribution for all PMT in "
1198  "y={125#;155}, x={-105#;105}; Nof photons",
1199  50,
1200  -0.5,
1201  49.5);
1202  fHistoList.push_back(HitsPerPmtFullMiddle);
1203 
1204  fitt = new TH2D("fitt", "fitt; x; y", 500, -110, 110, 50, 100, 200);
1205  fHistoList.push_back(fitt);
1206 
1207  imagehits = new TGraph(10);
1208  imageellipse = new TGraph(10);
1209 }
CbmKresConversionGeneral::InitHistograms
void InitHistograms()
Definition: CbmKresConversionGeneral.cxx:561
CbmRichPoint.h
CbmKresConversionGeneral::AllHitsPerPixel
TH2D * AllHitsPerPixel
Definition: CbmKresConversionGeneral.h:138
CbmHit::GetZ
Double_t GetZ() const
Definition: CbmHit.h:70
CbmMCTrack::GetMotherId
Int_t GetMotherId() const
Definition: CbmMCTrack.h:71
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition: CbmMatch.h:37
CbmKresConversionGeneral::MC_Direct_photons_Pt_vs_rap
TH2D * MC_Direct_photons_Pt_vs_rap
Definition: CbmKresConversionGeneral.h:83
CbmMCTrack::GetMomentum
void GetMomentum(TVector3 &momentum) const
Definition: CbmMCTrack.h:172
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:136
CbmMCTrack::GetStartX
Double_t GetStartX() const
Definition: CbmMCTrack.h:75
CbmKresConversionGeneral::MC_pi0_theta_vs_rap
TH2D * MC_pi0_theta_vs_rap
Definition: CbmKresConversionGeneral.h:97
CbmKresConversionGeneral::MC_leptons_from_pi0_P
TH1D * MC_leptons_from_pi0_P
Definition: CbmKresConversionGeneral.h:102
CbmKresConversionGeneral::MC_eta_Pt
TH1D * MC_eta_Pt
Definition: CbmKresConversionGeneral.h:103
CbmKresConversionGeneral::MC_leptons_conversion_XZ
TH2D * MC_leptons_conversion_XZ
Definition: CbmKresConversionGeneral.h:100
CbmPixelHit::GetX
Double_t GetX() const
Definition: CbmPixelHit.h:83
CbmKresConversionGeneral::HitsPerPmtFullPlane
TH1D * HitsPerPmtFullPlane
Definition: CbmKresConversionGeneral.h:140
CbmMatch::GetNofLinks
Int_t GetNofLinks() const
Definition: CbmMatch.h:38
CbmKresConversionGeneral::fMinRadius
Double_t fMinRadius
Definition: CbmKresConversionGeneral.h:57
CbmRichRingFitterEllipseTau
Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov.
Definition: CbmRichRingFitterEllipseTau.h:35
CbmPixelHit::GetY
Double_t GetY() const
Definition: CbmPixelHit.h:84
CbmKresConversionGeneral::MC_Direct_photons_theta_vs_rap
TH2D * MC_Direct_photons_theta_vs_rap
Definition: CbmKresConversionGeneral.h:82
CbmKresConversionGeneral::B_1d_electrons
TH1D * B_1d_electrons
Definition: CbmKresConversionGeneral.h:112
CbmKresConversionGeneral::fhdRXYZ
TH3D * fhdRXYZ
Definition: CbmKresConversionGeneral.h:128
CbmRichRingFitterEllipseTau.h
Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov.
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:41
CbmKresConversionGeneral::MC_All_photons_P
TH1D * MC_All_photons_P
Definition: CbmKresConversionGeneral.h:75
CbmKresConversionGeneral::Pi0_pt_vs_rap_est
TH2D * Pi0_pt_vs_rap_est
Definition: CbmKresConversionGeneral.h:92
CbmKresConversionGeneral::MC_Not_Direct_photons_P
TH1D * MC_Not_Direct_photons_P
Definition: CbmKresConversionGeneral.h:76
CbmKresConversionGeneral::MC_pi0_phi
TH1D * MC_pi0_phi
Definition: CbmKresConversionGeneral.h:95
CbmGlobalTrack::GetRichRingIndex
Int_t GetRichRingIndex() const
Definition: CbmGlobalTrack.h:41
CbmKresConversionGeneral::AllHits3D
TH3D * AllHits3D
Definition: CbmKresConversionGeneral.h:136
CbmKresConversionGeneral::fGlobalTracks
TClonesArray * fGlobalTracks
Definition: CbmKresConversionGeneral.h:41
CbmMCTrack::GetPdgCode
Int_t GetPdgCode() const
Definition: CbmMCTrack.h:70
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmKresConversionGeneral::~CbmKresConversionGeneral
virtual ~CbmKresConversionGeneral()
Definition: CbmKresConversionGeneral.cxx:137
CbmKresConversionGeneral::MC_Direct_photons_theta
TH1D * MC_Direct_photons_theta
Definition: CbmKresConversionGeneral.h:81
CbmKresConversionGeneral::AllPoints3D
TH3D * AllPoints3D
Definition: CbmKresConversionGeneral.h:70
CbmKresConversionGeneral::MC_All_photons_Pt
TH1D * MC_All_photons_Pt
Definition: CbmKresConversionGeneral.h:72
CbmKresConversionGeneral::fMinAaxis
Double_t fMinAaxis
Definition: CbmKresConversionGeneral.h:53
CbmGlobalTrack.h
CbmKresConversionGeneral::MC_eta_Pt_vs_rap_primary
TH2D * MC_eta_Pt_vs_rap_primary
Definition: CbmKresConversionGeneral.h:105
CbmKresConversionGeneral::MC_Reconstructed_electrons_Pt_vs_rap_est
TH2D * MC_Reconstructed_electrons_Pt_vs_rap_est
Definition: CbmKresConversionGeneral.h:86
CbmKresConversionGeneral::MC_eta_theta
TH1D * MC_eta_theta
Definition: CbmKresConversionGeneral.h:106
CbmKresConversionGeneral::fitt
TH2D * fitt
Definition: CbmKresConversionGeneral.h:60
CbmRichRing::GetNofHits
Int_t GetNofHits() const
Definition: CbmRichRing.h:40
CbmKresConversionGeneral::MC_Not_Direct_photons_theta_vs_rap
TH2D * MC_Not_Direct_photons_theta_vs_rap
Definition: CbmKresConversionGeneral.h:80
CbmRichRing
Definition: CbmRichRing.h:17
CbmKresConversionGeneral::Distance_electron
TProfile2D * Distance_electron
Definition: CbmKresConversionGeneral.h:119
CbmKresConversionGeneral::BoA_1d_electrons
TH1D * BoA_1d_electrons
Definition: CbmKresConversionGeneral.h:110
CbmKresConversionGeneral::dR_electrons
TH1D * dR_electrons
Definition: CbmKresConversionGeneral.h:117
CbmKresConversionGeneral::AllPointsPerPixel
TH2D * AllPointsPerPixel
Definition: CbmKresConversionGeneral.h:133
CbmRichHitLight::fX
float fX
Definition: CbmRichRingLight.h:34
CbmRichRing.h
CbmKresConversionGeneral::fArrayCentrality
FairMCEventHeader * fArrayCentrality
Definition: CbmKresConversionGeneral.h:49
CbmKresConversionGeneral::fRichHits
TClonesArray * fRichHits
Definition: CbmKresConversionGeneral.h:45
CbmKresConversionGeneral::MC_pi0_Rapidity
TH1D * MC_pi0_Rapidity
Definition: CbmKresConversionGeneral.h:96
CbmKresConversionGeneral::FitAndFillHistEllipse
void FitAndFillHistEllipse(CbmRichRingLight *ring)
Definition: CbmKresConversionGeneral.cxx:527
CbmKresConversionGeneral::fStsTracks
TClonesArray * fStsTracks
Definition: CbmKresConversionGeneral.h:42
CbmKresConversionGeneral::fhBaxisXYZ
TH3D * fhBaxisXYZ
Definition: CbmKresConversionGeneral.h:126
CbmKresConversionGeneral::ForChristian_P_vs_R
TH2D * ForChristian_P_vs_R
Definition: CbmKresConversionGeneral.h:68
CbmKresConversionGeneral::fRichPoints
TClonesArray * fRichPoints
Definition: CbmKresConversionGeneral.h:44
CbmRichUtil::GetRingTrackDistance
static Double_t GetRingTrackDistance(Int_t globalTrackId)
Definition: alignment/CbmRichUtil.h:20
CbmKresConversionGeneral::Tracks_electrons
TH1D * Tracks_electrons
Definition: CbmKresConversionGeneral.h:122
CbmMCTrack::GetStartZ
Double_t GetStartZ() const
Definition: CbmMCTrack.h:77
CbmRichRingLight::GetNofHits
int GetNofHits() const
Return number of hits in ring.
Definition: CbmRichRingLight.h:108
CbmKresConversionGeneral::fRichRings
TClonesArray * fRichRings
Definition: CbmKresConversionGeneral.h:46
CbmRichRing::GetHit
UInt_t GetHit(Int_t i) const
Definition: CbmRichRing.h:42
CbmKresConversionGeneral::fStsTrackMatches
TClonesArray * fStsTrackMatches
Definition: CbmKresConversionGeneral.h:43
CbmKresConversionGeneral::fMinBaxis
Double_t fMinBaxis
Definition: CbmKresConversionGeneral.h:55
CbmStsTrack.h
Data class for STS tracks.
CbmGlobalTrack::GetStsTrackIndex
Int_t GetStsTrackIndex() const
Definition: CbmGlobalTrack.h:38
CbmRichRingLight::GetAaxis
float GetAaxis() const
Definition: CbmRichRingLight.h:163
CbmKresConversionGeneral::MC_eta_Pt_vs_rap
TH2D * MC_eta_Pt_vs_rap
Definition: CbmKresConversionGeneral.h:104
CbmKresConversionGeneral::AllHits_electrons
TH2D * AllHits_electrons
Definition: CbmKresConversionGeneral.h:116
CbmKresConversionGeneral::imagehits
TGraph * imagehits
Definition: CbmKresConversionGeneral.h:62
CbmKresConversionGeneral::Init
void Init()
Definition: CbmKresConversionGeneral.cxx:139
CbmRichRingLight::GetCenterY
float GetCenterY() const
Definition: CbmRichRingLight.h:160
CbmKresConversionGeneral::MC_omega_Pt_vs_rap_est
TH2D * MC_omega_Pt_vs_rap_est
Definition: CbmKresConversionGeneral.h:87
CbmRichRingLight.h
CbmTrackMatchNew.h
CbmKresConversionGeneral::Pi0_pt_vs_rap_est_primary
TH2D * Pi0_pt_vs_rap_est_primary
Definition: CbmKresConversionGeneral.h:93
CbmKresConversionGeneral::fhBoverAXYZ
TH3D * fhBoverAXYZ
Definition: CbmKresConversionGeneral.h:125
CbmRichRingLight::AddHit
void AddHit(CbmRichHitLight hit)
Add new hit to the ring.
Definition: CbmRichRingLight.h:87
CbmKresConversionGeneral::HitsPerPmtFullMiddle
TH1D * HitsPerPmtFullMiddle
Definition: CbmKresConversionGeneral.h:141
CbmKresConversionGeneral::Exec
void Exec(int fEventNumGen)
Definition: CbmKresConversionGeneral.cxx:202
CbmKresConversionGeneral::fRichProjections
TClonesArray * fRichProjections
Definition: CbmKresConversionGeneral.h:48
CbmKresConversionGeneral::temporarygraph
TH2D * temporarygraph
Definition: CbmKresConversionGeneral.h:139
CbmKresConversionGeneral.h
CbmKresConversionGeneral::MC_Not_Direct_photons_Pt
TH1D * MC_Not_Direct_photons_Pt
Definition: CbmKresConversionGeneral.h:73
CbmKresConversionGeneral::Test_rings
TH2D * Test_rings
Definition: CbmKresConversionGeneral.h:130
CbmKresConversionGeneral::MC_leptons_from_pi0_start_vertex
TH2D * MC_leptons_from_pi0_start_vertex
Definition: CbmKresConversionGeneral.h:101
CbmKresConversionGeneral::MC_pi0_Pt_est
TH1D * MC_pi0_Pt_est
Definition: CbmKresConversionGeneral.h:89
CbmKresConversionGeneral::MC_pi0_Pt_vs_rap
TH2D * MC_pi0_Pt_vs_rap
Definition: CbmKresConversionGeneral.h:90
CbmKresConversionGeneral::fhAaxisXYZ
TH3D * fhAaxisXYZ
Definition: CbmKresConversionGeneral.h:127
CbmKresConversionGeneral::MC_Direct_photons_Pt
TH1D * MC_Direct_photons_Pt
Definition: CbmKresConversionGeneral.h:74
CbmKresConversionGeneral::MC_electrons_Pt_vs_rap_est
TH2D * MC_electrons_Pt_vs_rap_est
Definition: CbmKresConversionGeneral.h:85
CbmKresConversionGeneral::MC_leptons_conversion_ZY
TH2D * MC_leptons_conversion_ZY
Definition: CbmKresConversionGeneral.h:98
CbmMCTrack::GetStartVertex
void GetStartVertex(TVector3 &vertex) const
Definition: CbmMCTrack.h:182
xMath::Pi
double Pi()
Definition: xMath.h:5
CbmRichRingLight::GetBaxis
float GetBaxis() const
Definition: CbmRichRingLight.h:164
CbmKresConversionGeneral::AllHitsPerPMT
TH2D * AllHitsPerPMT
Definition: CbmKresConversionGeneral.h:137
CbmRichHitLight
Definition: CbmRichRingLight.h:14
CbmKresConversionGeneral::fTauFit
CbmRichRingFitterEllipseTau * fTauFit
Definition: CbmKresConversionGeneral.h:51
CbmKresConversionGeneral::MC_leptons_conversion_XY
TH2D * MC_leptons_conversion_XY
Definition: CbmKresConversionGeneral.h:99
CbmMCTrack::GetPt
Double_t GetPt() const
Definition: CbmMCTrack.h:99
CbmKresConversionGeneral::fMcTracks
TClonesArray * fMcTracks
Definition: CbmKresConversionGeneral.h:40
CbmKresConversionGeneral::NumberOfRings_electrons
TH2D * NumberOfRings_electrons
Definition: CbmKresConversionGeneral.h:115
CbmKresConversionGeneral::fMaxRadius
Double_t fMaxRadius
Definition: CbmKresConversionGeneral.h:58
CbmGlobalTrack
Definition: CbmGlobalTrack.h:26
CbmMCTrack::GetRapidity
Double_t GetRapidity() const
Definition: CbmMCTrack.cxx:177
CbmKresConversionGeneral::dR2d_electrons
TProfile2D * dR2d_electrons
Definition: CbmKresConversionGeneral.h:118
CbmKresConversionGeneral::AllPoints2D
TH2D * AllPoints2D
Definition: CbmKresConversionGeneral.h:69
CbmMCTrack::GetStartY
Double_t GetStartY() const
Definition: CbmMCTrack.h:76
CbmKresConversionGeneral::A_1d_electrons
TH1D * A_1d_electrons
Definition: CbmKresConversionGeneral.h:111
CbmMCTrack.h
v
__m128 v
Definition: L1/vectors/P4_F32vec4.h:1
CbmKresConversionGeneral::imageellipse
TGraph * imageellipse
Definition: CbmKresConversionGeneral.h:61
CbmKresConversionGeneral::CbmKresConversionGeneral
CbmKresConversionGeneral()
Definition: CbmKresConversionGeneral.cxx:37
CbmKresConversionGeneral::MC_eta_theta_vs_rap
TH2D * MC_eta_theta_vs_rap
Definition: CbmKresConversionGeneral.h:107
CbmRichHitLight::fY
float fY
Definition: CbmRichRingLight.h:35
CbmKresConversionGeneral::fRichRingMatches
TClonesArray * fRichRingMatches
Definition: CbmKresConversionGeneral.h:47
CbmMCTrack
Definition: CbmMCTrack.h:34
CbmKresConversionGeneral::AllHits2D
TH2D * AllHits2D
Definition: CbmKresConversionGeneral.h:135
CbmKresConversionGeneral::B_electrons
TProfile2D * B_electrons
Definition: CbmKresConversionGeneral.h:114
CbmRichRingLight::GetHit
CbmRichHitLight GetHit(int ind)
Return hit by the index.
Definition: CbmRichRingLight.h:114
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:137
CbmKresConversionGeneral::Rings_electrons
TH1D * Rings_electrons
Definition: CbmKresConversionGeneral.h:123
CbmKresConversionGeneral::MC_photons_mother_Pdg
TH1D * MC_photons_mother_Pdg
Definition: CbmKresConversionGeneral.h:78
CbmKresConversionGeneral::Finish
void Finish()
Definition: CbmKresConversionGeneral.cxx:532
CbmRichRing::GetRadius
Float_t GetRadius() const
Definition: CbmRichRing.h:82
CbmKresConversionGeneral::MC_pi0_Pt_vs_rap_primary
TH2D * MC_pi0_Pt_vs_rap_primary
Definition: CbmKresConversionGeneral.h:91
CbmRichRing::GetCenterY
Float_t GetCenterY() const
Definition: CbmRichRing.h:81
CbmTrackMatchNew
Definition: CbmTrackMatchNew.h:19
CbmKresConversionGeneral::fMaxBaxis
Double_t fMaxBaxis
Definition: CbmKresConversionGeneral.h:56
CbmKresConversionGeneral::Distance_positron
TProfile2D * Distance_positron
Definition: CbmKresConversionGeneral.h:120
CbmKresConversionGeneral::MC_Not_Direct_photons_theta
TH1D * MC_Not_Direct_photons_theta
Definition: CbmKresConversionGeneral.h:79
CbmKresConversionGeneral::MC_PdgCodes
TH1D * MC_PdgCodes
Definition: CbmKresConversionGeneral.h:71
CbmKresConversionGeneral::MC_Direct_photons_P
TH1D * MC_Direct_photons_P
Definition: CbmKresConversionGeneral.h:77
CbmRichHit.h
CbmRichRingLight::GetCenterX
float GetCenterX() const
Definition: CbmRichRingLight.h:159
CbmRichRingFitterEllipseTau::DoFit
virtual void DoFit(CbmRichRingLight *ring)
Inherited from CbmRichRingFitterBase.
Definition: CbmRichRingFitterEllipseTau.cxx:94
CbmStsTrack
Definition: CbmStsTrack.h:37
CbmRichPoint
Definition: CbmRichPoint.h:24
CbmKresConversionGeneral::BoA_electrons
TProfile2D * BoA_electrons
Definition: CbmKresConversionGeneral.h:109
CbmKresConversionGeneral::MC_pi0_Pt
TH1D * MC_pi0_Pt
Definition: CbmKresConversionGeneral.h:88
CbmKresConversionGeneral::fMaxAaxis
Double_t fMaxAaxis
Definition: CbmKresConversionGeneral.h:54
CbmRichRingLight
Definition: CbmRichRingLight.h:39
CbmKresConversionGeneral::A_electrons
TProfile2D * A_electrons
Definition: CbmKresConversionGeneral.h:113
CbmMCTrack::GetP
Double_t GetP() const
Definition: CbmMCTrack.h:100
CbmKresConversionGeneral::MC_pi0_theta
TH1D * MC_pi0_theta
Definition: CbmKresConversionGeneral.h:94
CbmRichRing::GetCenterX
Float_t GetCenterX() const
Definition: CbmRichRing.h:80
CbmKresConversionGeneral::AllPointsPerPMT
TH2D * AllPointsPerPMT
Definition: CbmKresConversionGeneral.h:132
CbmRichHit
Definition: CbmRichHit.h:19
CbmKresConversionGeneral::MC_Direct_photons_Pt_vs_rap_est
TH2D * MC_Direct_photons_Pt_vs_rap_est
Definition: CbmKresConversionGeneral.h:84
CbmKresConversionGeneral::fHistoList
vector< TH1 * > fHistoList
Definition: CbmKresConversionGeneral.h:66
CbmRichRingLight::GetPhi
float GetPhi() const
Definition: CbmRichRingLight.h:165
CbmKresConversionGeneral::fHistoList_MC
vector< TH1 * > fHistoList_MC
Definition: CbmKresConversionGeneral.h:67