CbmRoot
Loading...
Searching...
No Matches
CbmRichMCbmQaReal.cxx
Go to the documentation of this file.
1/* Copyright (C) 2019-2021 UGiessen/JINR-LIT, Giessen/Dubna
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Adrian Amatus Weber, Semen Lebedev [committer] */
4
5#include "CbmRichMCbmQaReal.h"
6
7#include "CbmDigiManager.h"
8#include "CbmDrawHist.h"
9#include "CbmEvent.h"
10#include "CbmGlobalTrack.h"
11#include "CbmHistManager.h"
12#include "CbmMatchRecoToMC.h"
13#include "CbmRichConverter.h"
14#include "CbmRichDigi.h"
15#include "CbmRichDraw.h"
16#include "CbmRichGeoManager.h"
17#include "CbmRichHit.h"
18#include "CbmRichMCbmSEDisplay.h"
19#include "CbmRichPoint.h"
20#include "CbmRichRing.h"
21#include "CbmRichRingFinderHoughImpl.h"
22#include "CbmRichUtil.h"
23#include "CbmStsDigi.h"
24#include "CbmTofDigi.h"
25#include "CbmTofHit.h"
26#include "CbmTofTracklet.h"
27#include "CbmTrackMatchNew.h"
28#include "CbmTrdDigi.h"
29#include "CbmTrdTrack.h"
30#include "CbmUtils.h"
31#include "TCanvas.h"
32#include "TClonesArray.h"
33#include "TEllipse.h"
34#include "TF1.h"
35#include "TGeoBBox.h"
36#include "TGeoManager.h"
37#include "TGeoNode.h"
38#include "TH1.h"
39#include "TH1D.h"
40#include "TLatex.h"
41#include "TLine.h"
42#include "TMarker.h"
43#include "TMath.h"
44#include "TStyle.h"
45#include "TSystem.h"
46
47#include <TBox.h>
48#include <TFile.h>
49#include <TLegend.h>
50//#include <CbmSetup.h>
51
52#include <boost/assign/list_of.hpp>
53
54#include <cmath>
55#include <iomanip>
56#include <iostream>
57#include <sstream>
58#include <string>
59
60using namespace std;
61using boost::assign::list_of;
62
63//double RichZPos = 348.;
64double RichZPos = 355.2;
65
66CbmRichMCbmQaReal::CbmRichMCbmQaReal()
67 : FairTask("CbmRichMCbmQaReal")
68 , fBmonDigis(nullptr)
69 , fRichHits(nullptr)
70 , fRichRings(nullptr)
71 , fTofHits(nullptr)
72 , fTofTracks(nullptr)
73 , fTSHeader(nullptr)
74 , fCbmEvent(nullptr)
75 , fHM(nullptr)
76 , fXOffsetHisto(0.)
77 , fTotRichMin(23.7)
78 , fTotRichMax(30.0)
79 , fEventNum(0)
80 , fNofDrawnRings(0)
81 , fNofDrawnRichTofEv(0)
82 , fMaxNofDrawnEvents(100)
83 , fTriggerRichHits(0)
84 , fTriggerTofHits(0)
85 , fOutputDir("result")
86{
87}
88
89InitStatus CbmRichMCbmQaReal::Init()
90{
91 cout << "CbmRichMCbmQaReal::Init" << endl;
92
93 FairRootManager* ioman = FairRootManager::Instance();
94 if (nullptr == ioman)
95 LOG(fatal) << "CbmRichMCbmQaReal::Init "
96 << "RootManager not instantised!";
97
98 fDigiMan = CbmDigiManager::Instance();
99 fDigiMan->Init();
100
101 if (!fDigiMan->IsPresent(ECbmModuleId::kRich))
102 LOG(fatal) << "CbmRichMCbmQaReal::Init: "
103 << "No Rich Digis!";
104
105 if (!fDigiMan->IsPresent(ECbmModuleId::kTof))
106 LOG(fatal) << "CbmRichMCbmQaReal::Init: "
107 << "No Tof Digis!";
108
109 fRichHits = (TClonesArray*) ioman->GetObject("RichHit");
110 if (nullptr == fRichHits)
111 LOG(fatal) << "CbmRichMCbmQaReal::Init: "
112 << "No Rich Hits!";
113
114 fRichRings = (TClonesArray*) ioman->GetObject("RichRing");
115 if (nullptr == fRichRings)
116 LOG(fatal) << "CbmRichMCbmQaReal::Init: "
117 << "No Rich Rings!";
118
119 fTofHits = (TClonesArray*) ioman->GetObject("TofHit");
120 if (nullptr == fTofHits)
121 LOG(fatal) << "CbmRichMCbmQaReal::Init: "
122 << "No Tof Hits!";
123
124 fTofTracks = (TClonesArray*) ioman->GetObject("TofTracks");
125 if (nullptr == fTofTracks)
126 LOG(warning) << "CbmRichMCbmQaReal::Init: "
127 << "No Tof Tracks!";
128
129 fBmonDigis = ioman->InitObjectAs<std::vector<CbmTofDigi> const*>("BmonDigi");
130 if (nullptr == fBmonDigis)
131 LOG(warning) << "CbmRichMCbmQaReal::Init: "
132 << "No Bmon Digis!";
133
134 fTSHeader = ioman->InitObjectAs<CbmTsEventHeader const*>("EventHeader.");
135 if (nullptr == fTSHeader)
136 LOG(warning) << "CbmRichMCbmQaReal::Init: "
137 << "No EventHeader!";
138
139 fCbmEvent = dynamic_cast<TClonesArray*>(ioman->GetObject("CbmEvent"));
140 if (nullptr == fCbmEvent)
141 LOG(fatal) << "CbmRichMCbmQaReal::Init: "
142 << "No Event!";
143
144 InitHistograms();
145
146 //--- Init Single Event display -----------------------------
147 fSeDisplay = new CbmRichMCbmSEDisplay(fHM);
148 fSeDisplay->SetRichHits(fRichHits);
149 fSeDisplay->SetRichRings(fRichRings);
150 fSeDisplay->SetTofTracks(fTofTracks);
151 fSeDisplay->SetTotRich(fTotRichMin, fTotRichMax);
152 fSeDisplay->SetMaxNofDrawnEvents(fMaxNofDrawnEvents);
153 fSeDisplay->SetOutDir(fOutputDir);
154 fSeDisplay->SetLELimits(-60.0, 200.0);
155 fSeDisplay->XOffsetHistos(fXOffsetHisto);
156 //-----------------------------------------------------------
157
158
159 //--- Init Single Event display for Correlated Tracks/Rings---
160 fSeDsply_TR = new CbmRichMCbmSEDisplay(fHM);
161 fSeDsply_TR->SetRichHits(fRichHits);
162 fSeDsply_TR->SetRichRings(fRichRings);
163 fSeDsply_TR->SetTofTracks(fTofTracks);
164 fSeDsply_TR->SetTotRich(fTotRichMin, fTotRichMax);
165 fSeDsply_TR->SetMaxNofDrawnEvents(fMaxNofDrawnEvents);
166 fSeDsply_TR->SetOutDir(fOutputDir);
167 fSeDsply_TR->XOffsetHistos(fXOffsetHisto);
168 fSeDsply_TR->SetLELimits(-60.0, 200.0);
169 fSeDsply_TR->SetCanvasDir("SE_Corr");
170 //-----------------------------------------------------------
171
172
173 return kSUCCESS;
174}
175
176void CbmRichMCbmQaReal::InitHistograms()
177{
178 fHM = new CbmHistManager();
179
180 fHM->Create1<TH1D>("fhNofEvents", "fhNofEvents;Entries", 1, 0.5, 1.5);
181 fHM->Create1<TH1D>("fhNofCbmEvents", "fhNofCbmEvents;Entries", 1, 0.5, 1.5);
182 fHM->Create1<TH1D>("fhNofCbmEventsRing", "fhNofCbmEventsRing;Entries", 1, 0.5, 1.5);
183
184 fHM->Create1<TH1D>("fhHitsInTimeslice", "fhHitsInTimeslice;Timeslice;#Hits", 200, 1, 200);
185
186 // nof objects per timeslice
187 fHM->Create1<TH1D>("fhNofRichDigisInTimeslice", "fhNofRichDigisInTimeslice;# RICH digis / timeslice;Entries", 100,
188 -0.5, 999.5);
189 fHM->Create1<TH1D>("fhNofRichHitsInTimeslice", "fhNofRichHitsInTimeslice;# RICH hits / timeslice;Entries", 100, -0.5,
190 999.5);
191 fHM->Create1<TH1D>("fhNofRichRingsInTimeslice", "fhNofRichRingsInTimeslice;# RICH rings / timeslice;Entries", 10,
192 -0.5, 9.5);
193
194 // RICH hits
195 fHM->Create2<TH2D>("fhRichHitXY", "fhRichHitXY;RICH hit X [cm];RICH hit Y [cm];Entries", 67, -20.1 + fXOffsetHisto,
196 20.1 + fXOffsetHisto, 84, -25.2, 25.2);
197 fHM->Create2<TH2D>("fhRichDigiPixelRate", "fhRichDigiPixelRate;RICH Digi X [cm];RICH Digi Y [cm];Hz", 67,
198 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 84, -25.2, 25.2);
199
200
201 // RICH digis, the limits of log histograms are set in Exec method
202 fHM->Create1<TH1D>("fhRichDigisTimeLog", "fhNofRichDigisTimeLog;Time [ns];Entries", 400, 0., 0.);
203 fHM->Create1<TH1D>("fhRichDigisTimeLogZoom", "fhNofRichDigisTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
204 fHM->Create1<TH1D>("fhRichDigisTimeLogZoom2", "fhNofRichDigisTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
205
206 fHM->Create1<TH1D>("fhRichRingsTimeLog", "fhNofRichRingsTimeLog;Time [ns];Entries", 400, 0., 0.);
207 fHM->Create1<TH1D>("fhRichRingsTimeLogZoom", "fhNofRichRingsTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
208 fHM->Create1<TH1D>("fhRichRingsTimeLogZoom2", "fhNofRichRingsTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
209
210 //TOF
211 fHM->Create1<TH1D>("fhTofDigisTimeLog", "fhTofDigisTimeLog;Time [ns];Entries", 400, 0., 0.);
212 fHM->Create1<TH1D>("fhTofDigisTimeLogZoom", "fhTofDigisTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
213 fHM->Create1<TH1D>("fhTofDigisTimeLogZoom2", "fhTofDigisTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
214
215 //STS
216 fHM->Create1<TH1D>("fhStsDigisTimeLog", "fhStsDigisTimeLog;Time [ns];Entries", 400, 0., 0.);
217 fHM->Create1<TH1D>("fhStsDigisTimeLogZoom", "fhStsDigisTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
218 fHM->Create1<TH1D>("fhStsDigisTimeLogZoom2", "fhStsDigisTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
219
220 //Bmon
221 fHM->Create1<TH1D>("fhBmonDigisTimeLog", "fhBmonDigisTimeLog;Time [ns];Entries", 400, 0., 0.);
222 fHM->Create1<TH1D>("fhBmonDigisTimeLogZoom", "fhBmonDigisTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
223 fHM->Create1<TH1D>("fhBmonDigisTimeLogZoom2", "fhBmonDigisTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
224
225 //TRD1D
226 fHM->Create1<TH1D>("fhTrd1dDigisTimeLog", "fhTrd1dDigisTimeLog;Time [ns];Entries", 400, 0., 0.);
227 fHM->Create1<TH1D>("fhTrd1dDigisTimeLogZoom", "fhTrd1dDigisTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
228 fHM->Create1<TH1D>("fhTrd1dDigisTimeLogZoom2", "fhTrd1dDigisTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
229
230 //TRD2D
231 fHM->Create1<TH1D>("fhTrd2dDigisTimeLog", "fhhTrd2dDigisTimeLog;Time [ns];Entries", 400, 0., 0.);
232 fHM->Create1<TH1D>("fhTrd2dDigisTimeLogZoom", "fhhTrd2dDigisTimeLogZoom;Time [ns];Entries", 400, 0., 0.);
233 fHM->Create1<TH1D>("fhTrd2dDigisTimeLogZoom2", "fhhTrd2dDigisTimeLogZoom2;Time [ns];Entries", 400, 0., 0.);
234
235 //ToT
236 fHM->Create1<TH1D>("fhRichDigisToT", "fhRichDigisToT;ToT [ns];Entries", 601, 9.975, 40.025);
237 fHM->Create1<TH1D>("fhRichHitToT", "fhRichHitToT;ToT [ns];Entries", 601, 9.975, 40.025);
238 fHM->Create1<TH1D>("fhRichHitToTEvent", "fhRichHitToTEvent;ToT [ns];Entries", 601, 9.975, 40.025);
239 fHM->Create2<TH2D>("fhRichHitXYEvent", "fhRichHitXYEvent;RICH hit X [cm];RICH hit Y [cm];Entries", 67,
240 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 84, -25.2, 25.2);
241
242
243 // RICH rings
244 fHM->Create2<TH2D>("fhRichRingXY", "fhRichRingXY;Ring center X [cm];Ring center Y [cm];Entries", 67,
245 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 84, -25.2, 25.2);
246 fHM->Create2<TH2D>("fhRichRingXY_goodTrack", "fhRichRingXY_goodTrack;Ring center X [cm];Ring center Y [cm];Entries",
247 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 84, -25.2, 25.2);
248 fHM->Create2<TH2D>("fhRichRing_goodTrackXY", "fhRichRing_goodTrackXY;Track center X [cm];Track center Y [cm];Entries",
249 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 84, -25.2, 25.2);
250
251 fHM->Create2<TH2D>("fhRichRingRadiusY", "fhRichRingRadiusY;Ring Radius [cm]; Y position[cm];Entries", 70, -0.05, 6.95,
252 84, -25.2, 25.2);
253 fHM->Create2<TH2D>("fhRichHitsRingRadius", "fhRichHitsRingRadius;#Rich Hits/Ring; Ring Radius [cm];Entries", 50, -0.5,
254 49.5, 70, -0.05, 6.95);
255
256 fHM->Create1<TH1D>("fhRichRingRadius", "fhRichRingRadius;Ring radius [cm];Entries", 100, 0., 7.);
257 fHM->Create1<TH1D>("fhNofHitsInRing", "fhNofHitsInRing;# hits in ring;Entries", 50, -0.5, 49.5);
258
259 fHM->Create1<TH1D>("fhRichRingRadius_goodRing", "fhRichRingRadius_goodRing;Ring radius [cm];Entries", 100, 0., 7.);
260 fHM->Create1<TH1D>("fhNofHitsInRing_goodRing", "fhNofHitsInRing_goodRing;# hits in ring;Entries", 50, -0.5, 49.5);
261
262 //Tof Rich correlation
263 fHM->Create2<TH2D>("fhTofRichX", "fhTofRichX;Rich Hit X [cm];TofHit X [cm];Entries", 67, -20.1 + fXOffsetHisto,
264 20.1 + fXOffsetHisto, 400, -50, 110);
265 fHM->Create2<TH2D>("fhTofRichX_stack1", "fhTofRichX_stack1;Rich Hit X [cm];TofHit X [cm];Entries", 67,
266 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
267 fHM->Create2<TH2D>("fhTofRichX_stack2", "fhTofRichX_stack2;Rich Hit X [cm];TofHit X [cm];Entries", 67,
268 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
269 fHM->Create2<TH2D>("fhTofRichX_stack3", "fhTofRichX_stack3;Rich Hit X [cm];TofHit X [cm];Entries", 67,
270 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
271 fHM->Create2<TH2D>("fhTofRichY", "fhTofRichY;Rich Hit Y [cm];TofHit Y [cm];Entries", 84, -25.2, 25.2, 200, -80, 80);
272 fHM->Create2<TH2D>("fhTofRichY_stack1", "fhTofRichY_stack1;Rich Hit Y [cm];TofHit Y [cm];Entries", 84, -25.2, 25.2,
273 200, -80, 80);
274 fHM->Create2<TH2D>("fhTofRichY_stack2", "fhTofRichY_stack2;Rich Hit Y [cm];TofHit Y [cm];Entries", 84, -25.2, 25.2,
275 200, -80, 80);
276 fHM->Create2<TH2D>("fhTofRichY_stack3", "fhTofRichY_stack3;Rich Hit Y [cm];TofHit Y [cm];Entries", 84, -25.2, 25.2,
277 200, -80, 80);
278 //fHM->Create2<TH2D>("fhTofRichRingHitX","fhTofRichRingHitX;Rich Ring Hit X [cm];TofHit X [cm];Entries", 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
279 fHM->Create2<TH2D>("fhTofTrackRichHitX", "fhTofTrackRichHitX;RICH Hit X [cm];TofTrack X [cm];Entries", 67,
280 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
281 fHM->Create2<TH2D>("fhTofTrackRichHitY", "fhTofTrackRichHitY;RICH Hit Y [cm];TofTrack Y [cm];Entries", 84, -25.2,
282 25.2, 200, -80, 80);
283
284
285 fHM->Create2<TH2D>("fhTofTrackHitRichHitX_oBetacuts_dtime",
286 "fhTofTrackHitRichHitX_oBetacuts_dtime;Rich Hit X "
287 "[cm];TofHit X [cm];Entries",
288 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
289 fHM->Create2<TH2D>("fhTofTrackHitRichHitY_oBetacuts_dtime",
290 "fhTofTrackHitRichHitY_oBetacuts_dtime;Rich Hit Y "
291 "[cm];TofHit Y [cm];Entries",
292 84, -25.2, 25.2, 200, -80, 80);
293
294
295 fHM->Create2<TH2D>("fhTofTrackRichHitX_cuts", "fhTofTrackRichHitX_cuts;RICH Hit X [cm];TofTrack X [cm];Entries", 67,
296 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
297 fHM->Create2<TH2D>("fhTofTrackRichHitY_cuts", "fhTofTrackRichHitY_cuts;RICH Hit Y [cm];TofTrack Y [cm];Entries", 84,
298 -25.2, 25.2, 200, -80, 80);
299
300 fHM->Create2<TH2D>("fhTofTrackRichHitX_oBetacuts",
301 "fhTofTrackRichHitX_oBetacuts;RICH Hit X [cm];TofTrack X [cm];Entries", 67, -20.1 + fXOffsetHisto,
302 20.1 + fXOffsetHisto, 400, -50, 110);
303 fHM->Create2<TH2D>("fhTofTrackRichHitY_oBetacuts",
304 "fhTofTrackRichHitY_oBetacuts;RICH Hit Y [cm];TofTrack Y [cm];Entries", 84, -25.2, 25.2, 200, -80,
305 80);
306 fHM->Create1<TH1D>("fhTofTrackRichHitTime_oBetacuts", "fhTofTrackRichHitTime_oBetacuts;#Delta Time [ns];Entries", 280,
307 -70., 70.);
308
309 fHM->Create2<TH2D>("fhTofTrackRichHitX_uBetacuts",
310 "fhTofTrackRichHitX_uBetacuts;RICH Hit X [cm];TofTrack X [cm];Entries", 67, -20.1 + fXOffsetHisto,
311 20.1 + fXOffsetHisto, 400, -50, 110);
312 fHM->Create2<TH2D>("fhTofTrackRichHitY_uBetacuts",
313 "fhTofTrackRichHitY_uBetacuts;RICH Hit Y [cm];TofTrack Y [cm];Entries", 84, -25.2, 25.2, 200, -80,
314 80);
315
316 fHM->Create2<TH2D>("fhTofTrackRichHitX_oBetacuts_dtime",
317 "fhTofTrackRichHitX_oBetacuts_dtime;RICH Hit X "
318 "[cm];TofTrack X [cm];Entries",
319 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
320 fHM->Create2<TH2D>("fhTofTrackRichHitY_oBetacuts_dtime",
321 "fhTofTrackRichHitY_oBetacuts_dtime;RICH Hit Y "
322 "[cm];TofTrack Y [cm];Entries",
323 84, -25.2, 25.2, 200, -80, 80);
324
325 fHM->Create2<TH2D>("fhTofTrackRichHitX_oBetacuts_dtime_4",
326 "fhTofTrackRichHitX_oBetacuts_dtime_4;RICH Hit X "
327 "[cm];TofTrack X [cm];Entries",
328 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
329 fHM->Create2<TH2D>("fhTofTrackRichHitY_oBetacuts_dtime_4",
330 "fhTofTrackRichHitY_oBetacuts_dtime_4;RICH Hit Y "
331 "[cm];TofTrack Y [cm];Entries",
332 84, -25.2, 25.2, 200, -80, 80);
333
334 fHM->Create2<TH2D>("fhTofTrackRichHitX_oBetacuts_dtime_6",
335 "fhTofTrackRichHitX_oBetacuts_dtime_6;RICH Hit X "
336 "[cm];TofTrack X [cm];Entries",
337 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
338 fHM->Create2<TH2D>("fhTofTrackRichHitY_oBetacuts_dtime_6",
339 "fhTofTrackRichHitY_oBetacuts_dtime_6;RICH Hit Y "
340 "[cm];TofTrack Y [cm];Entries",
341 84, -25.2, 25.2, 200, -80, 80);
342
343 fHM->Create2<TH2D>("fhTofTrackRichHitX_oBetacuts_dtime_8",
344 "fhTofTrackRichHitX_oBetacuts_dtime_8;RICH Hit X "
345 "[cm];TofTrack X [cm];Entries",
346 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
347 fHM->Create2<TH2D>("fhTofTrackRichHitY_oBetacuts_dtime_8",
348 "fhTofTrackRichHitY_oBetacuts_dtime_8;RICH Hit Y "
349 "[cm];TofTrack Y [cm];Entries",
350 84, -25.2, 25.2, 200, -80, 80);
351
352 fHM->Create2<TH2D>("fhTofTrackRichHitX_oBetacuts_dtime_10",
353 "fhTofTrackRichHitX_oBetacuts_dtime_10;RICH Hit X "
354 "[cm];TofTrack X [cm];Entries",
355 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
356 fHM->Create2<TH2D>("fhTofTrackRichHitY_oBetacuts_dtime_10",
357 "fhTofTrackRichHitY_oBetacuts_dtime_10;RICH Hit Y "
358 "[cm];TofTrack Y [cm];Entries",
359 84, -25.2, 25.2, 200, -80, 80);
360
361 fHM->Create2<TH2D>("fhTofTrackRichRingHitX", "fhTofTrackRichRingHitX;RICH Ring Hit X [cm];TofTrack X [cm];Entries",
362 67, -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
363 fHM->Create2<TH2D>("fhTofTrackRichRingHitY", "fhTofTrackRichRingHitY;RICH Ring Hit Y [cm];TofTrack Y [cm];Entries",
364 84, -25.2, 25.2, 200, -80, 80);
365
366 fHM->Create2<TH2D>("fhTofHitRichRingHitX", "fhTofHitRichRingHitX;RICH Ring Hit X [cm];Tof Hit X [cm];Entries", 67,
367 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
368 fHM->Create2<TH2D>("fhTofHitRichRingHitY", "fhTofHitRichRingHitY;RICH Ring Hit Y [cm];Tof Hit Y [cm];Entries", 84,
369 -25.2, 25.2, 200, -80, 80);
370
371 //Tof Rich correlation
372 fHM->Create2<TH2D>("fhTofRichX_zoomed", "fhTofRichX_zoomed;Rich Hit X [cm];TofHit X [cm];Entries", 27,
373 -8.1 + fXOffsetHisto, 8.1 + fXOffsetHisto, 180, -15, 75);
374 fHM->Create2<TH2D>("fhTofRichY_zoomed", "fhTofRichY_zoomed;Rich Hit Y [cm];TofHit Y [cm];Entries", 14, 7.8, 16.2, 30,
375 -5., 25);
376
377 fHM->Create2<TH2D>("fhClosTrackRingX", "fhClosTrackRingX;Rich Ring center X [cm];Tof Track X [cm];Entries", 67,
378 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
379 fHM->Create2<TH2D>("fhClosTrackRingY", "fhClosTrackRingY;Rich Ring center Y [cm];Tof Track Y [cm];Entries", 84, -25.2,
380 25.2, 200, -80, 80);
381
382 fHM->Create2<TH2D>("fhTofRichRingX", "fhTofRichRingX;Rich Ring Center X [cm];TofHit X [cm];Entries", 100,
383 -20 + fXOffsetHisto, 20 + fXOffsetHisto, 400, -50, 110);
384 fHM->Create2<TH2D>("fhTofRichRingY", "fhTofRichRingY;Ring Ring Center Y [cm];TofHit Y [cm];Entries", 125, -25, 25,
385 200, -80, 80);
386 fHM->Create2<TH2D>("fhTofRichRingXZ", "fhTofRichXZ; Z [cm];Hit/Ring X [cm];Entries", 140, 230, 370, 400, -50, 110);
387
388 fHM->Create2<TH2D>("fhTofTrackRichRingXY", "fhTofTrackRichRingXY; X [cm]; Y [cm];Entries", 100, -20 + fXOffsetHisto,
389 20 + fXOffsetHisto, 120, -10,
390 20); //1bin == 2mm
391 fHM->Create2<TH2D>("fhTofClosTrackRichRingXY", "fhTofClosTrackRichRingXY; X [cm]; Y [cm];Entries", 100,
392 -20 + fXOffsetHisto, 20 + fXOffsetHisto, 120, -10,
393 20); //1bin == 2mm
394
395 fHM->Create3<TH3D>("fhTofXYZ", "fhTofXYZ;Tof Hit X [cm];TofHit Z [cm];Tof Hit Y [cm];Entries", 100, -20, 20, 141,
396 230., 370., 100, -20, 20);
397 fHM->Create2<TH2D>("fhTofHitsXY", "fhTofHitsXY;Tof Hit X [cm];Tof Hit Y [cm];Entries", 100, -20, 20, 200, -80, 80);
398
399 for (auto moduleIds = 0; moduleIds < 5; moduleIds++) {
400 fHM->Create2<TH2D>(Form("fhTofHitsXY_%u", moduleIds),
401 Form("fhTofHitsXY_%u;Tof Hit X [cm];Tof Hit Y [cm];Entries", moduleIds), 200, -100, 100, 200,
402 -80, 80);
403 fHM->Create2<TH2D>(Form("fhTofHitsZX_%u", moduleIds),
404 Form("fhTofHitsZX_%u;Tof Hit X [cm];Tof Hit Y [cm];Entries", moduleIds), 200, 200, 400, 200,
405 -100, 100);
406 fHM->Create2<TH2D>(Form("fhTofRichX_%u", moduleIds),
407 Form("fhTofRichX_%u;Rich Hit X [cm];TofHit X [cm];Entries", moduleIds), 67,
408 -20.1 + fXOffsetHisto, 20.1 + fXOffsetHisto, 400, -50, 110);
409 fHM->Create2<TH2D>(Form("fhTofRichY_%u", moduleIds),
410 Form("fhTofRichY_%u;Rich Hit Y [cm];TofHit Y [cm];Entries", moduleIds), 84, -25.2, 25.2, 200,
411 -80, 80);
412 fHM->Create2<TH2D>(Form("fhTofRichHitsResidual_%u", moduleIds),
413 Form("fhTofRichHitsResidual_%u;Rich-Tof hit X [cm];Rich-Tof hit Y [cm];Entries", moduleIds),
414 150, -15.0, 15.0, 150, -15.0, 15.0);
415 }
416
417 fHM->Create1<TH1D>("fhTofHitsZ", "fhTofHitsZ;Z [cm];Entries", 350, -0.5, 349.5);
418 fHM->Create2<TH2D>("fhTofHitsXZ", "fhTofHitsXZ;Z [cm];X [cm];Entries", 350, -0.5, 349.5, 400, -50, 110);
419 //Tof Tracks
420 fHM->Create1<TH1D>("fhTofTracksPerEvent", "fhTofTracksPerEvent;NofTracks/Event;Entries", 20, -0.5, 19.5);
421 fHM->Create1<TH1D>("fhTofTracksPerRichEvent", "fhTofTracksPerRichEvent;NofTracks/RichEvent;Entries", 20, -0.5, 19.5);
422 fHM->Create2<TH2D>("fhTofTracksXY", "fhTofTracksXY;X[cm];Y[cm];NofTracks/cm^2", 250, -100, 150, 300, -150,
423 150); //50 , -20 + fXOffsetHisto, 30 + fXOffsetHisto, 180,-90,90); // projected in RICH Plane
424
425 fHM->Create2<TH2D>("fhTofTracksXY_Target", "fhTofTracksXY_Target;X[cm];Y[cm];NofTracks/cm^2", 100, -50, 50, 100, -50,
426 50); //50 , -20 + fXOffsetHisto, 30 + fXOffsetHisto, 180,-90,90); // projected in Z=0
427 fHM->Create2<TH2D>("fhGoodRingsXY_TargetPos", "fhGoodRingsXY_TargetPos;X[cm];Y[cm];NofTracks/cm^2", 100, -50, 50, 100,
428 -50,
429 50); //50 , -20 + fXOffsetHisto, 30 + fXOffsetHisto, 180,-90,90); // projected in Z=0
430
431 fHM->Create2<TH2D>("fhTofTrackRichRingX", "fhTofTrackRichRingX;Rich Ring Center X [cm];TofTrack X [cm];Entries", 100,
432 -20 + fXOffsetHisto, 20 + fXOffsetHisto, 400, -50, 110);
433 fHM->Create2<TH2D>("fhTofTrackRichRingY", "fhTofTrackRichRingY;Ring Ring Center Y [cm];TofTrack Y [cm];Entries", 125,
434 -25, 25, 200, -80, 80);
435
436 fHM->Create2<TH2D>("fhTofTracksXYRICH", "fhTofTracksXYRICH;X[cm];Y[cm];NofTracks/cm^2", 50, -20 + fXOffsetHisto,
437 30 + fXOffsetHisto, 180, -90,
438 90); // projected in RICH Plane
439 fHM->Create1<TH1D>("fhNofTofTracks", "fhNofTofTracks;X[cm];Y[cm];NofTracks", 4, 0,
440 4); // 1: All 2: left; 3: right; 4: RICH
441
442 fHM->Create1<TH1D>("fhRingTrackDistance", "fhRingTrackDistance;RingTrackDistance [cm];Entries", 31, -0.25, 14.75);
443 fHM->Create1<TH1D>("fhRingTrackDistance_X", "fhRingTrackDistance_X;RingTrackDistance X [cm];Entries", 100, -25.0,
444 25.0);
445 fHM->Create1<TH1D>("fhRingTrackDistance_Y", "fhRingTrackDistance_Y;RingTrackDistance Y [cm];Entries", 100, -25.0,
446 25.0);
447 fHM->Create2<TH2D>("fhRingTrackDistance_XY",
448 "fhRingTrackDistance_XY;RingTrackDistance X [cm]; RingTrackDistance Y [cm]; Entries", 100, -25.0,
449 25.0, 100, -25.0, 25.0);
450
451 fHM->Create1<TH1D>("fhTrackRingDistance", "fhTrackRingDistance;TrackRingDistance [cm];Entries", 31, -0.5, 30.5);
452 fHM->Create1<TH1D>("fhTrackRingDistanceOnTarget", "fhTrackRingDistanceOnTarget;TrackRingDistance [cm];Entries", 31,
453 -0.5, 30.5);
454 fHM->Create1<TH1D>("fhTrackRingDistanceOffTarget", "fhTrackRingDistanceOffTarget;TrackRingDistance [cm];Entries", 31,
455 -0.5, 30.5);
456 fHM->Create2<TH2D>("fhTrackRingDistanceVSRingradius",
457 "fhTrackRingDistanceVSRingradius;TrackRingDistance "
458 "[cm];RingRadius [cm];Entries",
459 81, -0.5, 80.5, 100, 0., 7.);
460
461 fHM->Create2<TH2D>("fhTrackRingDistanceVSRingChi2",
462 "fhTrackRingDistanceVSRingChi2;TrackRingDistance [cm];\\Chi^2;Entries", 60, 0, 30, 101, 0., 10.1);
463 fHM->Create2<TH2D>("fhTrackRingDistanceVSRingChi2_goodRing",
464 "fhTrackRingDistanceVSRingChi2_goodRing;TrackRingDistance "
465 "[cm];\\Chi^2;Entries",
466 40, 0, 10.0, 101, 0., 10.1);
467
468 fHM->Create1<TH1D>("fhTrackRingDistance_corr", "fhTrackRingDistance_corr;TrackRingDistance [cm];Entries", 31, -0.5,
469 30.5);
470
471 fHM->Create1<TH1D>("fhTofBetaTracksWithHitsNoRing", "fhTofBetaTracksWithHitsNoRing; \\beta;Entries", 301, -1.505,
472 1.505);
473 fHM->Create1<TH1D>("fhTofBetaTracksWithHits", "fhTofBetaTracksWithHits; \\beta;Entries", 151, -0.005, 1.505);
474 fHM->Create1<TH1D>("fhTofBetaTracksNoRing", "fhTofBetaTracksNoRing; \\beta;Entries", 151, -0.005, 1.505);
475 fHM->Create1<TH1D>("fhTofBetaTrackswithClosestRingInRange", "fhTofBetaTrackswithClosestRingInRange; \\beta;Entries",
476 301, -1.505, 1.505);
477
478 fHM->Create1<TH1D>("fhRichRingBeta", "fhRichRingBeta; \\beta;Entries", 151, -0.005, 1.505);
479 fHM->Create1<TH1D>("fhRichRingBeta_GoodRing", "fhRichRingBeta_GoodRing; \\beta;Entries", 151, -0.005, 1.505);
480
481 fHM->Create1<TH1D>("fhTofBetaRing", "fhTofBetaRing; \\beta;Entries", 301, -1.505, 1.505);
482 fHM->Create1<TH1D>("fhTofBetaAll", "fhTofBetaAll; \\beta;Entries", 301, -1.505, 1.505);
483 fHM->Create2<TH2D>("fhTofBetaVsRadius", "fhTofBetaVsRadius; \\beta;ring radius [cm];Entries", 301, -1.505, 1.505, 100,
484 0., 7.);
485 fHM->Create2<TH2D>("fhTofBetaRingDist", "fhTofBetaRingDist; \\beta;ring Dist [cm];Entries", 301, -1.505, 1.505, 100,
486 0., 20.);
487 fHM->Create1<TH1D>("fhTofBetaAllFullAcc", "fhTofBetaAllFullAcc; \\beta;Entries", 301, -1.505, 1.505);
488
489 fHM->Create1<TH1D>("fhRingDeltaTime", "fhRingDeltaTime; \\Delta Time/ns;Entries", 101, -10.1, 10.1);
490 fHM->Create1<TH1D>("fhRingToTs", "fhRingToTs; ToT/ns;Entries", 601, 9.975, 40.025);
491 fHM->Create1<TH1D>("fhRingLE", "fhRingLE;LE/ns;Entries", 261, -60.5, 200.5);
492 fHM->Create1<TH1D>("fhGoodRingLE", "fhGoodRingLE;LE/ns;Entries", 261, -60.5, 200.5);
493 fHM->Create1<TH1D>("fhRingNoClTrackLE", "fhRingNoClTrackLE;LE/ns;Entries", 261, -60.5, 200.5);
494 fHM->Create1<TH1D>("fhRingClTrackFarAwayLE", "fhRingClTrackFarAwayLE;LE/ns;Entries", 231, -30.5, 200.5);
495 fHM->Create2<TH2D>("fhRingLEvsToT", "fhRingLEvsToT;LE/ns;ToT/ns;Entries", 261, -60.5, 200.5, 601, 9.975, 40.025);
496
497 fHM->Create1<TH1D>("fhInnerRingDeltaTime", "fhInnerRingDeltaTime; \\Delta Time/ns;Entries", 101, -10.1, 10.1);
498 fHM->Create1<TH1D>("fhInnerRingToTs", "fhInnerRingToTs; ToT/ns;Entries", 601, 9.975, 40.025);
499 fHM->Create1<TH1D>("fhInnerRingLE", "fhInnerRingLE;LE/ns;Entries", 261, -60.5, 200.5);
500 fHM->Create1<TH1D>("fhInnerGoodRingLE", "fhInnerGoodRingLE;LE/ns;Entries", 261, -60.5, 200.5);
501 fHM->Create1<TH1D>("fhInnerRingNoClTrackLE", "fhInnerRingNoClTrackLE;LE/ns;Entries", 261, -60.5, 200.5);
502 fHM->Create1<TH1D>("fhInnerRingClTrackFarAwayLE", "fhInnerRingClTrackFarAwayLE;LE/ns;Entries", 261, -60.5, 200.5);
503 fHM->Create1<TH1D>("fhInnerRingFlag", "fhInnerRingFlag;Has|HasNot;Entries", 2, -0.5, 1.5);
504 fHM->Create1<TH1D>("fhNofInnerHits", "fhNofInnerHits;#Hits;Entries", 31, -0.5, 30.5);
505
506 fHM->Create1<TH1D>("fhDiRICHsInRegion", "fhNofInnerHits;#Hits;DiRICH", 4096, 28672, 32767);
507
508 fHM->Create1<TH1D>("fhBlobTrackDistX", "fhBlobTrackDistX; |TofTrackX - MAPMT center X| [cm];Entries", 30, -0.5, 29.5);
509 fHM->Create1<TH1D>("fhBlobTrackDistY", "fhBlobTrackDistY; |TofTrackY - MAPMT center Y| [cm];Entries", 30, -0.5, 29.5);
510 fHM->Create1<TH1D>("fhBlobTrackDist", "fhBlobTrackDist; |TofTrack - MAPMT center dist| [cm];Entries", 30, -0.5, 29.5);
511
512 fHM->Create1<TH1D>("fhNofBlobEvents", "fhNofBlobEvents;;#Events with min. one Blob", 1, 0.5, 1.5);
513 fHM->Create1<TH1D>("fhNofBlobsInEvent", "fhNofBlobsInEvent;#Blobs in Event;Entries", 36, 0.5, 36.5);
514
515 fHM->Create1<TH1D>("fhRichDigisConsecTime", "fhRichDigisConsecTime;consecutive time [ns];Entries", 500, -0.5, 499.5);
516 fHM->Create1<TH1D>("fhRichDigisConsecTimeTOT", "fhRichDigisConsecTimeTOT;consecutive time [ns];Entries", 500, -0.5,
517 499.5);
518
519 fHM->Create1<TH1D>("fhNofHitsInGoodRing", "fhNofHitsInGoodRing;# hits in ring;Entries", 50, -0.5, 49.5);
520 fHM->Create1<TH1D>("fhTracksWithRings", "fhTracksWithRings;Scenarios;Entries", 5, -0.5, 4.5);
521
522 fHM->Create1<TH1D>("fhRichRingChi2", "fhRichRingChi2;\\Chi^2;Entries", 101, 0., 10.1);
523 fHM->Create1<TH1D>("fhRichRingChi2_goodRing", "fhRichRingChi2_goodRing;\\Chi^2;Entries", 101, 0., 10.1);
524
525 fHM->Create2<TH2D>("fhTofTracksXYRICH_Accectance", "fhTofTracksXYRICH_Accectance;X[cm];Y[cm];NofTracks/cm^2", 50,
526 -20 + fXOffsetHisto, 30 + fXOffsetHisto, 180, -90,
527 90); // projected in RICH Plane
528
529 fHM->Create1<TH1D>("fhHitTimeEvent", "fhHitTimeEvent;time [ns];Entries", 300, -100., 200);
530
531 for (auto i = 0; i < 5; ++i)
532 fHM->Create2<TH2D>(Form("fhTofHitXZ_Station_%u", i), Form("fhTofHitXZ_Station_%u;Z [cm];X [cm];Entries", i), 350,
533 -0.5, 349.5, 400, -50, 110);
534
535 fHM->Create1<TH1D>("fhBmonDigiMultiplicity", "fhBmonDigiMultiplicity;multiplicity; Entries", 16, -1.5, 14.5);
536 fHM->Create1<TH1D>("fhBmonDigiTime", "fhBmonDigiTime;time [ns]; Entries", 500, 0., 100.);
537 fHM->Create1<TH1D>("fhBmonDigiTimeEvent", "fhBmonDigiTimeEvent;time [ns]; Entries", 500, 0., 100.);
538
539 //Hit Time Plots
540 if (fDoTimePlots) {
541 fHM->Create1<TH1D>("fhHitTimeMeanRichHit", "fhHitTimeMeanRichHit;time [ns];Entries", 600, -30., 30);
542 fHM->Create1<TH1D>("fhHitTimeMeanRichHitVsEvent", "fhHitTimeMeanRichHitVsEvent;time [ns];Entries", 300, -100., 200);
543 fHM->Create1<TH1D>("fhHitTimeMeanTofHitVsEvent", "fhHitTimeMeanTofHitVsEvent;time [ns];Entries", 300, -100., 200);
544 fHM->Create1<TH1D>("fhHitTimeMeanRichHitVsMeanTof", "fhHitTimeMeanRichHitVsMeanTof;time [ns];Entries", 300, -100.,
545 200);
546
547 for (auto i = 0; i < 72; ++i)
548 fHM->Create1<TH1D>(Form("/HitTime/fhHitTimeEvent_%u", i),
549 Form("/HitTime/fhHitTimeEvent_%u; time [ns];Entries", i), 300, -100, 200);
550
551 for (auto i = 0; i < 72; ++i)
552 fHM->Create1<TH1D>(Form("/HitTime/fhHitTimeMeanRichHit_%u", i),
553 Form("/HitTime/fhHitTimeMeanRichHit_%u; time [ns];Entries", i), 300, -30, 30);
554
555 for (auto i = 0; i < 72; ++i)
556 fHM->Create2<TH2D>(Form("/HitTime_2D/fhHitTimeEvent_%u", i),
557 Form("/HitTime_2D/fhHitTimeEvent_%u; time [ns], ToT [ns];Entries", i), 300, -100, 200, 30, 15,
558 30);
559
560 for (auto i = 0; i < 33; ++i)
561 fHM->Create1<TH1D>(Form("/HitTime_chnl/fhHitTimeEvent_chnl_%u", i),
562 Form("/HitTime_chnl/fhHitTimeEvent_chnl_%u; time [ns];Entries", i), 300, -100, 200);
563 } // End Hit Time Plots
564}
565
566
567void CbmRichMCbmQaReal::Exec(Option_t* /*option*/)
568{
569 fEventNum++;
570 fHM->H1("fhNofEvents")->Fill(1);
571 cout << "CbmRichMCbmQaReal, event No. " << fEventNum << endl;
572
573 uint64_t tsStartTime = 0;
574 if (nullptr != fTSHeader) tsStartTime = fTSHeader->GetTsStartTime();
575
576 if (fDigiHitsInitialized == false) {
577 auto nOfCbmEvent = fCbmEvent->GetEntriesFast();
578 if (nOfCbmEvent > 0) {
579 CbmEvent* ev = static_cast<CbmEvent*>(fCbmEvent->At(0));
580 /*if ((fDigiMan->GetNofDigis(ECbmModuleId::kRich)> 10) &&
581 //(fDigiMan->GetNofDigis(ECbmModuleId::kSts) > 30) ||
582 //(fRichRings->GetEntriesFast()> 0) ||
583 (fDigiMan->GetNofDigis(ECbmModuleId::kTof) > 10)
584 )*/
585 if (ev != nullptr) {
586 double minTime = ev->GetStartTime(); //std::numeric_limits<double>::max();
587 /* for (int i = 0; i < fDigiMan->GetNofDigis(ECbmModuleId::kRich); i++) {
588 const CbmRichDigi* richDigi = fDigiMan->Get<CbmRichDigi>(i);
589 // fHM->H1("fhRichDigisToT")->Fill(richDigi->GetToT());
590 if (richDigi->GetTime() < minTime) minTime = richDigi->GetTime();
591 }*/
592
593 double dT = 40e9;
594 double dTZoom1 = 0.8e9;
595 double dTZoom2 = 0.008e9;
596 fHM->H1("fhRichDigisTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
597 fHM->H1("fhRichDigisTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
598 fHM->H1("fhRichDigisTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
599
600 fHM->H1("fhRichRingsTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
601 fHM->H1("fhRichRingsTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
602 fHM->H1("fhRichRingsTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
603
604 fHM->H1("fhTofDigisTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
605 fHM->H1("fhTofDigisTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
606 fHM->H1("fhTofDigisTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
607
608 fHM->H1("fhStsDigisTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
609 fHM->H1("fhStsDigisTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
610 fHM->H1("fhStsDigisTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
611
612 fHM->H1("fhTrd1dDigisTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
613 fHM->H1("fhTrd1dDigisTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
614 fHM->H1("fhTrd1dDigisTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
615
616 fHM->H1("fhTrd2dDigisTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
617 fHM->H1("fhTrd2dDigisTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
618 fHM->H1("fhTrd2dDigisTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
619
620 fHM->H1("fhBmonDigisTimeLog")->GetXaxis()->SetLimits(minTime, minTime + dT);
621 fHM->H1("fhBmonDigisTimeLogZoom")->GetXaxis()->SetLimits(minTime, minTime + dTZoom1);
622 fHM->H1("fhBmonDigisTimeLogZoom2")->GetXaxis()->SetLimits(minTime, minTime + dTZoom2);
623
624 fTSMinTime = tsStartTime;
625 fDigiHitsInitialized = true;
626 }
627 }
628 } // if (fDigiHitsInitialized == false)
629
630 if (fDigiHitsInitialized == true) {
631
632 double TsTimeAfterStart = static_cast<double>(tsStartTime - fTSMinTime);
633 int nofRichDigis = fDigiMan->GetNofDigis(ECbmModuleId::kRich);
634 fHM->H1("fhNofRichDigisInTimeslice")->Fill(nofRichDigis);
635 for (int i = 0; i < nofRichDigis; i++) {
636 const CbmRichDigi* digi = fDigiMan->Get<CbmRichDigi>(i);
637 fHM->H1("fhRichDigisTimeLog")->Fill(digi->GetTime() + TsTimeAfterStart);
638 fHM->H1("fhRichDigisTimeLogZoom")->Fill(digi->GetTime() + TsTimeAfterStart);
639 fHM->H1("fhRichDigisTimeLogZoom2")->Fill(digi->GetTime() + TsTimeAfterStart);
640 }
641
642 int nofRichRings = fRichRings->GetEntriesFast();
643 for (int i = 0; i < nofRichRings; i++) {
644 CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(i));
645 fHM->H1("fhRichRingsTimeLog")->Fill(ring->GetTime() + TsTimeAfterStart);
646 fHM->H1("fhRichRingsTimeLogZoom")->Fill(ring->GetTime() + TsTimeAfterStart);
647 fHM->H1("fhRichRingsTimeLogZoom2")->Fill(ring->GetTime() + TsTimeAfterStart);
648 }
649
650 int nofTofDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTof);
651 for (int i = 0; i < nofTofDigis; i++) {
652 const CbmTofDigi* digi = fDigiMan->Get<CbmTofDigi>(i);
653 fHM->H1("fhTofDigisTimeLog")->Fill(digi->GetTime() + TsTimeAfterStart);
654 fHM->H1("fhTofDigisTimeLogZoom")->Fill(digi->GetTime() + TsTimeAfterStart);
655 fHM->H1("fhTofDigisTimeLogZoom2")->Fill(digi->GetTime() + TsTimeAfterStart);
656 }
657
658 if (fDigiMan->IsPresent(ECbmModuleId::kSts)) {
659 int nofStsDigis = fDigiMan->GetNofDigis(ECbmModuleId::kSts);
660 for (int i = 0; i < nofStsDigis; i++) {
661 const CbmStsDigi* digi = fDigiMan->Get<CbmStsDigi>(i);
662 fHM->H1("fhStsDigisTimeLog")->Fill(digi->GetTime() + TsTimeAfterStart);
663 fHM->H1("fhStsDigisTimeLogZoom")->Fill(digi->GetTime() + TsTimeAfterStart);
664 fHM->H1("fhStsDigisTimeLogZoom2")->Fill(digi->GetTime() + TsTimeAfterStart);
665 }
666 }
667
668 if (fDigiMan->IsPresent(ECbmModuleId::kTrd)) {
669 int nofTrd1dDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTrd);
670 for (int i = 0; i < nofTrd1dDigis; i++) {
671 const CbmTrdDigi* digi = fDigiMan->Get<CbmTrdDigi>(i);
672
673 CbmTrdDigi::eCbmTrdAsicType trdDigiType = digi->GetType();
674 if (trdDigiType == CbmTrdDigi::eCbmTrdAsicType::kSPADIC) {
675 fHM->H1("fhTrd1dDigisTimeLog")->Fill(digi->GetTime() + TsTimeAfterStart);
676 fHM->H1("fhTrd1dDigisTimeLogZoom")->Fill(digi->GetTime() + TsTimeAfterStart);
677 fHM->H1("fhTrd1dDigisTimeLogZoom2")->Fill(digi->GetTime() + TsTimeAfterStart);
678 }
679 else if (trdDigiType == CbmTrdDigi::eCbmTrdAsicType::kFASP) {
680 fHM->H1("fhTrd2dDigisTimeLog")->Fill(digi->GetTime() + TsTimeAfterStart);
681 fHM->H1("fhTrd2dDigisTimeLogZoom")->Fill(digi->GetTime() + TsTimeAfterStart);
682 fHM->H1("fhTrd2dDigisTimeLogZoom2")->Fill(digi->GetTime() + TsTimeAfterStart);
683 }
684 }
685 }
686
687 {
688 Int_t nrBmonDigis = 0;
689 if (fBmonDigis) nrBmonDigis = fBmonDigis->size();
690 //else if ( fBmonDigiArr ) nrBmonDigis = fBmonDigiArr->GetEntriesFast();
691 LOG(debug) << "BmonDigis: " << nrBmonDigis;
692
693 for (Int_t iBmon = 0; iBmon < nrBmonDigis; ++iBmon) {
694 const CbmTofDigi* BmonDigi = nullptr;
695 if (fBmonDigis) BmonDigi = &(fBmonDigis->at(iBmon));
696 //else if ( fBmonDigiArr ) BmonDigi = dynamic_cast<const CbmTofDigi*>(fBmonDigiArr->At(iBmon));
697 assert(BmonDigi);
698 fHM->H1("fhBmonDigisTimeLog")->Fill(BmonDigi->GetTime() + TsTimeAfterStart);
699 fHM->H1("fhBmonDigisTimeLogZoom")->Fill(BmonDigi->GetTime() + TsTimeAfterStart);
700 fHM->H1("fhBmonDigisTimeLogZoom2")->Fill(BmonDigi->GetTime() + TsTimeAfterStart);
701 }
702 }
703 }
704
705 int nofRichHits = fRichHits->GetEntriesFast();
706 fHM->H1("fhNofRichHitsInTimeslice")->Fill(nofRichHits);
707 fHM->H1("fhHitsInTimeslice")->Fill(fEventNum, nofRichHits);
708
709 {
710 int nofRichDigis = fDigiMan->GetNofDigis(ECbmModuleId::kRich);
711 for (int i = 0; i < nofRichDigis; i++) {
712 const CbmRichDigi* richDigi = fDigiMan->Get<CbmRichDigi>(i);
713 fHM->H1("fhRichDigisToT")->Fill(richDigi->GetToT());
714
715 if (i > 0) {
716 const CbmRichDigi* richDigi_prev = fDigiMan->Get<CbmRichDigi>(i - 1);
717 fHM->H1("fhRichDigisConsecTime")->Fill(richDigi->GetTime() - richDigi_prev->GetTime());
718 if (doToT(richDigi) && doToT(richDigi_prev))
719 fHM->H1("fhRichDigisConsecTimeTOT")->Fill(richDigi->GetTime() - richDigi_prev->GetTime());
720 }
721
722 //fHM->H2("fhRichDigiPixelRate")->Fill(richDigi->GetX(),richDigi->GetY());
723 }
724 }
725
726 Double_t zPos_tmp = 0.;
727 for (int iH = 0; iH < nofRichHits; iH++) {
728 CbmRichHit* richHit = static_cast<CbmRichHit*>(fRichHits->At(iH));
729 fHM->H2("fhRichHitXY")->Fill(richHit->GetX(), richHit->GetY());
730 fHM->H1("fhRichHitToT")->Fill(richHit->GetToT());
731 zPos_tmp = ((zPos_tmp * iH) + richHit->GetZ()) / (iH + 1);
732 //printf("HitToT: %f \n", richHit->GetToT());
733 }
734 if (nofRichHits > 0) RichZPos = zPos_tmp;
735
736 //std::cout<<"[INFO] Mean Z-Position of RICH Hits: "<<RichZPos<<std::endl;
737 //CBMEVENT
738 auto fNCbmEvent = fCbmEvent->GetEntriesFast();
739
740 for (int i = 0; i < fNCbmEvent; i++) {
741 CbmEvent* ev = static_cast<CbmEvent*>(fCbmEvent->At(i));
742 if (fTriggerRichHits != 0 && (Int_t(ev->GetNofData(ECbmDataType::kRichHit)) < fTriggerRichHits)) continue;
743 fHM->H1("fhNofCbmEvents")->Fill(1);
744 //if (fTriggerTofHits != 0 && (ev->GetNofData(ECbmDataType::kTofHit) < fTriggerTofHits)) continue;
745
746 //if (ev->GetNofData(ECbmDataType::kTofHit) > (fTriggerTofHits+10) ) continue;
747
748 std::vector<int> ringIndx;
749 std::vector<int> evRichHitIndx;
750 std::array<uint32_t, 36> pmtHits;
751 for (auto& a : pmtHits)
752 a = 0;
753
754 fEventPnt = ev;
755 fCbmEventStartTime = ev->GetStartTime();
756
757 // Scan Event to find first Digi that triggered.
758 // std::cout<<"Sts Digis:"<< ev->GetNofData(kStsDigi)<<std::endl;
759 // std::cout<<"Much Digis:"<< ev->GetNofData(kMuchDigi)<<std::endl;
760 // std::cout<<"Tof Digis:"<< ev->GetNofData(kTofDigi)<<std::endl;
761 // std::cout<<"Rich Digis:"<< ev->GetNofData(kRichDigi)<<std::endl;
762 // std::cout<<"Psd Digis:"<< ev->GetNofData(kPsdDigi)<<std::endl;
763 // unsigned int flagRich = 0;
764 Double_t startTime = std::numeric_limits<Double_t>::max();
765
766 fHM->H1("fhBmonDigiMultiplicity")->Fill(ev->GetNofData(ECbmDataType::kBmonDigi));
767 //std::cout<<ev->GetNofData(ECbmDataType::kBmonDigi)<<std::endl;
768 for (size_t j = 0; j < ev->GetNofData(ECbmDataType::kBmonDigi); j++) {
769 auto iBmonDigi = ev->GetIndex(ECbmDataType::kBmonDigi, j);
770 const CbmTofDigi* BmonDigi = nullptr;
771 if (fBmonDigis) BmonDigi = &(fBmonDigis->at(iBmonDigi));
772 assert(BmonDigi);
773 fHM->H1("fhBmonDigiTimeEvent")->Fill(BmonDigi->GetTime() - fCbmEventStartTime);
774 }
775
776 //std::cout<<"NofBmonDigis in TS: "<< fBmonDigis->size() <<std::endl;
777 Double_t minT0TimeDiff = std::numeric_limits<Double_t>::max();
778 //Double_t T0Time = std::numeric_limits<Double_t>::max();
779 for (uint32_t j = 0; j < fBmonDigis->size(); j++) {
780 const CbmTofDigi* BmonDigi = nullptr;
781 if (fBmonDigis) BmonDigi = &(fBmonDigis->at(j));
782 assert(BmonDigi);
783 Double_t timeDiffBmon = BmonDigi->GetTime() - fCbmEventStartTime;
784 if (std::fabs(timeDiffBmon) < std::fabs(minT0TimeDiff)) {
785 minT0TimeDiff = timeDiffBmon;
786 //T0Time = BmonDigi->GetTime();
787 }
788 }
789 //std::cout<<"BmonDigistime: "<< T0Time << " EventStartTime:" << fCbmEventStartTime <<" Time DIff: "<< minT0TimeDiff <<std::endl;
790 fHM->H1("fhBmonDigiTime")->Fill(minT0TimeDiff);
791
792 Double_t meanRichHitTime = 0.;
793 if (fDoTimePlots) {
794 for (size_t j = 0; j < ev->GetNofData(ECbmDataType::kRichHit); j++) {
795 auto iRichHit = ev->GetIndex(ECbmDataType::kRichHit, j);
796 CbmRichHit* richHit = static_cast<CbmRichHit*>(fRichHits->At(iRichHit));
797 meanRichHitTime += richHit->GetTime();
798 }
799 if (ev->GetNofData(ECbmDataType::kRichHit) > 0) meanRichHitTime /= ev->GetNofData(ECbmDataType::kRichHit);
800
801 Double_t meanTofHitTime = 0.;
802 for (size_t j = 0; j < ev->GetNofData(ECbmDataType::kTofHit); j++) {
803 auto iTofHit = ev->GetIndex(ECbmDataType::kTofHit, j);
804 CbmTofHit* tofHit = static_cast<CbmTofHit*>(fTofHits->At(iTofHit));
805 meanTofHitTime += tofHit->GetTime();
806 }
807 if (ev->GetNofData(ECbmDataType::kTofHit) > 0) meanTofHitTime /= ev->GetNofData(ECbmDataType::kTofHit);
808
809 fHM->H1("fhHitTimeMeanRichHitVsEvent")->Fill(meanRichHitTime - fCbmEventStartTime);
810 fHM->H1("fhHitTimeMeanTofHitVsEvent")->Fill(meanTofHitTime - fCbmEventStartTime);
811 fHM->H1("fhHitTimeMeanRichHitVsMeanTof")->Fill(meanRichHitTime - meanTofHitTime);
812 }
813
814 for (size_t j = 0; j < ev->GetNofData(ECbmDataType::kRichHit); j++) {
815 auto iRichHit = ev->GetIndex(ECbmDataType::kRichHit, j);
816 evRichHitIndx.push_back(iRichHit);
817 CbmRichHit* richHit = static_cast<CbmRichHit*>(fRichHits->At(iRichHit));
818 uint32_t pmtId = (((richHit->GetAddress()) >> 24) & 0xF) * 9 + (((richHit->GetAddress()) >> 20) & 0xF);
819 fHM->H1("fhHitTimeEvent")->Fill(richHit->GetTime() - fCbmEventStartTime);
820
821 if (fDoTimePlots) {
822 uint32_t DiRichId = (((richHit->GetAddress()) >> 24) & 0xF) * 18 + (((richHit->GetAddress()) >> 20) & 0xF) * 2
823 + (((richHit->GetAddress()) >> 16) & 0xF);
824
825 fHM->H1(Form("/HitTime/fhHitTimeEvent_%u", DiRichId))->Fill(richHit->GetTime() - fCbmEventStartTime);
826 fHM->H1(Form("/HitTime/fhHitTimeMeanRichHit_%u", DiRichId))->Fill(richHit->GetTime() - meanRichHitTime);
827 fHM->H1("fhHitTimeMeanRichHit")->Fill(richHit->GetTime() - meanRichHitTime);
828
829 fHM->H2(Form("/HitTime_2D/fhHitTimeEvent_%u", DiRichId))
830 ->Fill(richHit->GetTime() - fCbmEventStartTime, richHit->GetToT());
831 if (DiRichId == 52)
832 fHM->H1(Form("/HitTime_chnl/fhHitTimeEvent_chnl_%u", richHit->GetAddress() & 0xFFFF))
833 ->Fill(richHit->GetTime() - fCbmEventStartTime);
834 }
835
836 fHM->H1("fhRichHitToTEvent")->Fill(richHit->GetToT());
837 fHM->H2("fhRichHitXYEvent")->Fill(richHit->GetX(), richHit->GetY());
838 //Blob finder
839 pmtHits[pmtId]++;
840
841 //std::cout<<"\t\t * "<<i<<". Event, Hit "<< j <<": "<< iRichHit <<"\t " << std::fixed << std::setprecision(5) << richHit->GetTime() <<std::endl;
842 if (richHit->GetTime() < startTime) {
843 startTime = richHit->GetTime(); /*flagRich = 1;*/
844 }
845 int nofRichRings2 = fRichRings->GetEntriesFast();
846 for (int l = 0; l < nofRichRings2; l++) {
847 CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(l));
848 auto NofRingHits = ring->GetNofHits();
849 for (int m = 0; m < NofRingHits; m++) {
850 auto RingHitIndx = ring->GetHit(m);
851 if (RingHitIndx == iRichHit) {
852 Bool_t used = false;
853 for (auto check : ringIndx) {
854 if (check == l) {
855 used = true;
856 break;
857 }
858 }
859 if (used == false) ringIndx.push_back(l);
860 break;
861 }
862 }
863 }
864
865 for (size_t k = 0; k < ev->GetNofData(ECbmDataType::kTofHit); k++) {
866 auto iTofHit = ev->GetIndex(ECbmDataType::kTofHit, k);
867 CbmTofHit* tofHit = static_cast<CbmTofHit*>(fTofHits->At(iTofHit));
868 if (tofHit->GetTime() < startTime) {
869 startTime = tofHit->GetTime(); /* flagRich = 0;*/
870 }
871 if (tofHit->GetZ() < 2.) continue; // Cut Bmon away!
872
873 auto TofModulId = (tofHit->GetAddress() >> 4) & 0x3F;
874 auto TofModulType = (tofHit->GetAddress() >> 11) & 0xF;
875 //std::cout<<std::hex<<tofHit->GetAddress()<<std::dec<<" Type: "<<TofModulType<<" Id: "<<TofModulId<<std::endl;
876 if (TofModulType != 0) continue;
877 //fHM->H2("fhTofRichX")->Fill(richHit->GetX(), tofHit->GetX());
878
879 fHM->H2(Form("fhTofHitXZ_Station_%u", TofModulId))->Fill(tofHit->GetZ(), tofHit->GetX());
880
881 //Befor tof_v20b
882 /*if (tofHit->GetZ()> 230. && tofHit->GetZ() < 250) fHM->H2("fhTofRichX_stack1")->Fill(richHit->GetX(),tofHit->GetX());
883 if (tofHit->GetZ()> 250. && tofHit->GetZ() < 265) fHM->H2("fhTofRichX_stack2")->Fill(richHit->GetX(),tofHit->GetX());
884 if (tofHit->GetZ()> 265. && tofHit->GetZ() < 285) fHM->H2("fhTofRichX_stack3")->Fill(richHit->GetX(),tofHit->GetX());
885 */
886 if (TofModulId == 0) { //(tofHit->GetZ() > 230. && tofHit->GetZ() < 255)
887 fHM->H2("fhTofRichX_stack1")->Fill(richHit->GetX(), tofHit->GetX());
888 fHM->H2("fhTofRichY_stack1")->Fill(richHit->GetY(), tofHit->GetY());
889 fHM->H2("fhTofRichX")->Fill(richHit->GetX(), tofHit->GetX());
890 fHM->H2("fhTofRichY")->Fill(richHit->GetY(), tofHit->GetY());
891 fHM->H2("fhTofHitsXY")->Fill(tofHit->GetX(), tofHit->GetY());
892 }
893 if (TofModulId == 1) { //(tofHit->GetZ() >= 255. && tofHit->GetZ() < 272)
894 fHM->H2("fhTofRichX_stack2")->Fill(richHit->GetX(), tofHit->GetX());
895 fHM->H2("fhTofRichY_stack2")->Fill(richHit->GetY(), tofHit->GetY());
896 fHM->H2("fhTofRichX")->Fill(richHit->GetX(), tofHit->GetX());
897 fHM->H2("fhTofRichY")->Fill(richHit->GetY(), tofHit->GetY());
898 fHM->H2("fhTofHitsXY")->Fill(tofHit->GetX(), tofHit->GetY());
899 }
900 if (TofModulId == 2) { //(tofHit->GetZ() >= 272. && tofHit->GetZ() < 290)
901 fHM->H2("fhTofRichX_stack3")->Fill(richHit->GetX(), tofHit->GetX());
902 fHM->H2("fhTofRichY_stack3")->Fill(richHit->GetY(), tofHit->GetY());
903 fHM->H2("fhTofRichX")->Fill(richHit->GetX(), tofHit->GetX());
904 fHM->H2("fhTofRichY")->Fill(richHit->GetY(), tofHit->GetY());
905 fHM->H2("fhTofHitsXY")->Fill(tofHit->GetX(), tofHit->GetY());
906 }
907
908 //fHM->H2("fhTofRichX_zoomed")->Fill(richHit->GetX(), tofHit->GetX());
909 //fHM->H2("fhTofRichY_zoomed")->Fill(richHit->GetY(), tofHit->GetY());
910
911 //fHM->H2("fhTofHitsXY")->Fill(tofHit->GetX(), tofHit->GetY());
912
913 fHM->H2(Form("fhTofHitsXY_%u", TofModulId))->Fill(tofHit->GetX(), tofHit->GetY());
914 fHM->H2(Form("fhTofHitsZX_%u", TofModulId))->Fill(tofHit->GetZ(), tofHit->GetX());
915 fHM->H2(Form("fhTofRichX_%u", TofModulId))->Fill(richHit->GetX(), tofHit->GetX());
916 fHM->H2(Form("fhTofRichY_%u", TofModulId))->Fill(richHit->GetY(), tofHit->GetY());
917 TVector3 hitExtr = extrapolate(tofHit, richHit->GetZ());
918 fHM->H2(Form("fhTofRichHitsResidual_%u", TofModulId))
919 ->Fill(richHit->GetX() - hitExtr.X(), richHit->GetY() - hitExtr.Y());
920 }
921 }
922
923 //std::cout<<"Diff in StartTime DigiToHit: "<< startTime - fCbmEventStartTime << "\t" <<flagRich<<std::endl;
924 fCbmEventStartTime = startTime;
925
926 if (bSeDisplayRingOnly) {
927 if (ringIndx.size() > 0) fSeDisplay->DrawEvent(ev, ringIndx, 1);
928 }
929 else {
930 fSeDisplay->DrawEvent(ev, ringIndx, 1);
931 }
932
933 // std::cout<<DrawCbmEvent<<std::endl;
934 // for (int j=0;j<ev->GetNofData(ECbmDataType::kRichDigi);j++){
935 // auto iRichDigi = ev->GetIndex(ECbmDataType::kRichDigi, j);
936 // CbmRichDigi* richDigi = static_cast<CbmRichDigi*>(fRichDigis->At(iRichDigi));
937 // std::cout<<"\t\t * "<<i<<". Event, Digi "<< j <<": "<< iRichDigi <<"\t " << std::fixed << std::setprecision(5) << richDigi->GetTime()<<std::endl;
938 // }
939
940 //std::vector<int> evTofTrack;
941
942 //*** Tracks in CbmEvent -> Here Trigger is on! This is seen in Track Position
943 //std::cout<<"TRACKS in CbmEvent: "<<ev->GetNofData(ECbmDataType::kTofTrack)<<std::endl;
944 auto noftofTracks = ev->GetNofData(ECbmDataType::kTofTrack);
945 fHM->H1("fhTofTracksPerEvent")->Fill(noftofTracks);
946
947 for (size_t j = 0; j < noftofTracks; j++) {
948 auto iTofTrack = ev->GetIndex(ECbmDataType::kTofTrack, j);
949 CbmTofTracklet* tTrack = static_cast<CbmTofTracklet*>(fTofTracks->At(iTofTrack));
950 if (tTrack == nullptr) continue;
951
952 fHM->H1("fhTracksWithRings")->Fill(0);
953 fHM->H2("fhTofTracksXY")->Fill(tTrack->GetFitX(RichZPos), tTrack->GetFitY(RichZPos));
954 fHM->H2("fhTofTracksXY_Target")->Fill(tTrack->GetFitX(0.), tTrack->GetFitY(0.));
955 fHM->H1("fhNofTofTracks")->Fill(0.5); // 1: All 2: left; 3: right; 4: RICH
956 fHM->H1("fhTofBetaAllFullAcc")->Fill(getBeta(tTrack));
957 //std::cout<<"beta Track "<< j <<": "<<getBeta(tTrack)<<std::endl;
958
959 if (tTrack->GetFitX(RichZPos) > -10. && tTrack->GetFitX(RichZPos) < +10. && tTrack->GetFitY(RichZPos) > -25.
960 && tTrack->GetFitY(RichZPos) < +25. && isOnTarget(tTrack)) {
961 //Track in RICH
962 fTracksinRich++;
963 Int_t goodHit = 0;
964 for (size_t k = 0; k < ev->GetNofData(ECbmDataType::kRichHit); k++) {
965 auto iRichHit = ev->GetIndex(ECbmDataType::kRichHit, k);
966 CbmRichHit* richHit = static_cast<CbmRichHit*>(fRichHits->At(iRichHit));
967 if (richHit == nullptr) continue;
968 if (std::fabs(richHit->GetY() - tTrack->GetFitY(RichZPos)) < 5.
969 && std::fabs(richHit->GetX() - tTrack->GetFitX(RichZPos)) < 9.)
970 goodHit++;
971 }
972 if (goodHit > 0) fTracksinRichWithRichHits[0]++;
973 if (goodHit > 5) fTracksinRichWithRichHits[1]++;
974 if (goodHit > 10) fTracksinRichWithRichHits[2]++;
975 if (goodHit > 15) fTracksinRichWithRichHits[3]++;
976 }
977
978 if (isAccmRICH(tTrack)) {
979 if (RestrictToFullAcc(tTrack)) {
980 fHM->H2("fhTofTracksXYRICH")
981 ->Fill(tTrack->GetFitX(RichZPos),
982 tTrack->GetFitY(RichZPos)); // projected in RICH Plane
983 fHM->H1("fhNofTofTracks")->Fill(3.5); // 1: All 2: left; 3: right; 4: RICH
984 std::vector<int> evTofTrack;
985 evTofTrack.push_back(iTofTrack);
986 DrawRichTofEv(evRichHitIndx, evTofTrack);
987
988 if (ringIndx.size() == 0 && evRichHitIndx.size() > 0)
989 fHM->H1("fhTofBetaTracksWithHitsNoRing")->Fill(getBeta(tTrack)); // no Ring in CbmEvent found
990 if (evRichHitIndx.size() > 0) fHM->H1("fhTofBetaTracksWithHits")->Fill(getBeta(tTrack));
991 if (ringIndx.size() == 0) fHM->H1("fhTofBetaTracksNoRing")->Fill(getBeta(tTrack));
992
993 if ((tTrack->GetNofHits() == 4 && (getBeta(tTrack) > 0.90 && getBeta(tTrack) < 1.10))) {
994 //tracks after cut
995 Double_t trackXpos = tTrack->GetFitX(RichZPos);
996 Double_t trackYpos = tTrack->GetFitY(RichZPos);
997
998 if (trackXpos > -8 && trackXpos < 13 && trackYpos > -21 && trackYpos < 24) {
999 if (!(trackXpos > -8 && trackXpos < -3 && trackYpos > 5 && trackYpos < 7.5)
1000 && !(trackXpos > 7.8 && trackXpos < 13 && trackYpos > 5 && trackYpos < 7.5)
1001 && !(trackXpos > -8 && trackXpos < 2 && trackYpos > 21 && trackYpos < 24)
1002 && !(trackXpos > 7.8 && trackXpos < 13 && trackYpos > 21 && trackYpos < 24)
1003 && !(trackXpos > 2.2 && trackXpos < 13 && trackYpos > 21 && trackYpos < 16)) {
1004 fHM->H2("fhTofTracksXYRICH_Accectance")->Fill(trackXpos, trackYpos);
1005 fHM->H1("fhTracksWithRings")->Fill(2);
1006 if (ringIndx.size() > 0) fHM->H1("fhTracksWithRings")->Fill(4);
1007 if (FindClosestRing(tTrack, ringIndx).first > -1) fHM->H1("fhTracksWithRings")->Fill(3);
1008 }
1009 }
1010
1011 // filter on Rich Acc.
1012 // filter on
1013 }
1014
1015 std::pair<int, double> closeRing = FindClosestRing(tTrack, ringIndx);
1016 if (closeRing.first > -1) {
1017 fHM->H1("fhRingTrackDistance")->Fill(closeRing.second);
1018 fHM->H1("fhTracksWithRings")->Fill(1);
1019 {
1020 const CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(ringIndx[closeRing.first]));
1021
1022 const int ringX = ring->GetCenterX();
1023 const int ringY = ring->GetCenterY();
1024 const double xDist = (tTrack->GetFitX(RichZPos) - ringX);
1025 const double yDist = (tTrack->GetFitY(RichZPos) - ringY);
1026 fHM->H1("fhRingTrackDistance_X")->Fill(xDist);
1027 fHM->H1("fhRingTrackDistance_Y")->Fill(yDist);
1028 fHM->H2("fhRingTrackDistance_XY")->Fill(xDist, yDist);
1029
1030 if (closeRing.second < ring->GetRadius() * 1.2)
1031 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->Fill(getBeta(tTrack));
1032 }
1033 }
1034 //if (ringIndx.size() > 0)fHM->H1("fhTofBetaTrackswithRing")->Fill(getBeta(tTrack)); // ring is somewehere in Acc
1035 fHM->H1("fhTofBetaAll")->Fill(getBeta(tTrack));
1036 }
1037 }
1038 if (tTrack->GetFitX(RichZPos) > 30) { // right
1039 fHM->H1("fhNofTofTracks")->Fill(2.5); // 1: All 2: left; 3: right; 4: RICH
1040 }
1041 else { //left
1042 fHM->H1("fhNofTofTracks")->Fill(1.5);
1043 }
1044 }
1045
1046
1047 std::vector<TVector3> RichTofEv;
1048
1049 for (size_t j = 0; j < ev->GetNofData(ECbmDataType::kTofHit); j++) {
1050 auto iTofHit = ev->GetIndex(ECbmDataType::kTofHit, j);
1051 CbmTofHit* tofHit = static_cast<CbmTofHit*>(fTofHits->At(iTofHit));
1052 if (tofHit->GetZ() < 2.) continue; // Cut Bmon away!
1053
1054 fHM->H1("fhTofHitsZ")->Fill(tofHit->GetZ());
1055 fHM->H2("fhTofHitsXZ")->Fill(tofHit->GetZ(), tofHit->GetX());
1056 //fHM->H2("fhTofHitsXY")->Fill(tofHit->GetX(),tofHit->GetY());
1057 fHM->H3("fhTofXYZ")->Fill(tofHit->GetX(), tofHit->GetZ(), tofHit->GetY());
1058
1059 if (ringIndx.size() > 0) {
1060 //fHM->H2("fhTofRichRingXZ")->Fill(tofHit->GetZ(),tofHit->GetX());
1061 //RichTofEv.emplace_back(tofHit->GetX(),tofHit->GetY(),tofHit->GetZ());
1062 for (unsigned int rings = 0; rings < ringIndx.size(); rings++) {
1063 CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(ringIndx[rings]));
1064 fHM->H2("fhTofRichRingX")->Fill(ring->GetCenterX(), tofHit->GetX());
1065 fHM->H2("fhTofRichRingY")->Fill(ring->GetCenterY(), tofHit->GetY());
1066 for (int k = 0; k < ring->GetNofHits(); k++) {
1067 Int_t hitInd = ring->GetHit(k);
1068 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
1069 if (nullptr == hit) continue;
1070 fHM->H2("fhTofHitRichRingHitX")->Fill(hit->GetX(), tofHit->GetX());
1071 fHM->H2("fhTofHitRichRingHitY")->Fill(hit->GetY(), tofHit->GetY());
1072 }
1073 //fhTofRichRingHitX here loop over hits in ring.
1074 }
1075 }
1076 }
1077
1078 if (ringIndx.size() > 0) { // Ring in CbmEvent
1079 std::vector<CbmTofTracklet*> TracksOfEvnt;
1080 //TRACKS
1081 auto nofTofTracks = ev->GetNofData(ECbmDataType::kTofTrack);
1082 fHM->H1("fhTofTracksPerRichEvent")->Fill(nofTofTracks);
1083 for (size_t j = 0; j < nofTofTracks; j++) {
1084 auto iTofTrack = ev->GetIndex(ECbmDataType::kTofTrack, j);
1085 CbmTofTracklet* track = static_cast<CbmTofTracklet*>(fTofTracks->At(iTofTrack));
1086 if (track == nullptr) continue;
1087 if (track->GetNofHits() <= 3) continue;
1088 TracksOfEvnt.emplace_back(track);
1089 if (!isOnTarget(track)) continue;
1090 fHM->H2("fhTofTrackRichRingXY")->Fill(track->GetFitX(RichZPos), track->GetFitY(RichZPos));
1091 for (size_t k = 0; k < ev->GetNofData(ECbmDataType::kRichHit); k++) {
1092 auto iRichHit = ev->GetIndex(ECbmDataType::kRichHit, k);
1093 CbmRichHit* richHit = static_cast<CbmRichHit*>(fRichHits->At(iRichHit));
1094 if (richHit == nullptr) continue;
1095 fHM->H2("fhTofTrackRichHitX")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1096 fHM->H2("fhTofTrackRichHitY")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1097
1098 //cuts:
1099 // >3 hits /track
1100 // if (track->GetNofHits() > 3) {
1101 fHM->H2("fhTofTrackRichHitX_cuts")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1102 fHM->H2("fhTofTrackRichHitY_cuts")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1103 if (getBeta(track) > 0.90 && getBeta(track) < 1.10) {
1104 fHM->H2("fhTofTrackRichHitX_oBetacuts")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1105 fHM->H2("fhTofTrackRichHitY_oBetacuts")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1106 double deltatime = richHit->GetTime() - track->GetTime();
1107 fHM->H1("fhTofTrackRichHitTime_oBetacuts")->Fill(deltatime);
1108 if (deltatime > -10 && deltatime < +40) {
1109 if (track->GetNofHits() == 4) {
1110 fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1111 fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1112 }
1113
1114 if (track->GetNofHits() > 4) {
1115 fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_4")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1116 fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_4")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1117 }
1118 else if (track->GetNofHits() > 6) {
1119 fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_6")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1120 fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_6")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1121 }
1122 else if (track->GetNofHits() > 8) {
1123 fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_8")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1124 fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_8")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1125 }
1126 else if (track->GetNofHits() > 10) {
1127 fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_10")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1128 fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_10")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1129 }
1130 // if (track->GetNofHits() == 4) {
1131 // for (int l = 0; l < track->GetNofHits(); ++l) {
1132 // size_t hitIndex = track->GetHitIndex(l);
1133 // size_t iTofHit = ev->GetIndex(ECbmDataType::kTofHit, hitIndex);
1134 // //if (fEventNum == 88) continue; // TODO: workaround for run 2060
1135 // if (fEventNum == 4) continue;
1136 // if (iTofHit > -1) continue;
1137 // const CbmTofHit* tofHit = static_cast<CbmTofHit*>(fTofHits->At(iTofHit));
1138 // if (tofHit->GetZ() < 2.) continue; // Cut Bmon away!
1139 // fHM->H2("fhTofTrackHitRichHitX_oBetacuts_dtime")->Fill(richHit->GetX(), tofHit->GetX());
1140 // fHM->H2("fhTofTrackHitRichHitY_oBetacuts_dtime")->Fill(richHit->GetY(), tofHit->GetY());
1141 // }
1142 // }
1143 }
1144 }
1145 else {
1146 fHM->H2("fhTofTrackRichHitX_uBetacuts")->Fill(richHit->GetX(), track->GetFitX(RichZPos));
1147 fHM->H2("fhTofTrackRichHitY_uBetacuts")->Fill(richHit->GetY(), track->GetFitY(RichZPos));
1148 }
1149 //}
1150 }
1151 }
1152
1153 //rings
1154 //std::cout<< "Found Rings in CbmEvent: "<< ringIndx.size() <<std::endl;
1155 fRingsWithTrack[1] += ringIndx.size();
1156 fRingsWithTrack[2] += nofTofTracks;
1157 fRingsWithTrack[5] += ringIndx.size() * nofTofTracks;
1158
1159 for (unsigned int rings = 0; rings < ringIndx.size(); rings++) {
1160 const CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(ringIndx[rings]));
1161 if (nullptr == ring) continue;
1162
1163 fHM->H1("fhRichRingChi2")->Fill(ring->GetChi2());
1164
1165 if (!cutRadius(ring)) continue;
1166 fRingsWithTrack[3]++; // Rings After Cut
1167 //DEFAULT: //DrawRing(ring,TracksOfEvnt,true); // here normally; now only Rings with high BETA
1168
1169 fHM->H1("fhRichRingBeta")->Fill(getBeta(ring));
1170
1171 auto clTrack = FindClosestTrack(ring, TracksOfEvnt); // has no cut on distance
1172 analyseRing(ring, ev, clTrack);
1173
1174 for (size_t j = 0; j < nofTofTracks; j++) {
1175 auto iTofTrack = ev->GetIndex(ECbmDataType::kTofTrack, j);
1176 CbmTofTracklet* track = static_cast<CbmTofTracklet*>(fTofTracks->At(iTofTrack));
1177 if (track == nullptr) continue;
1178 if (!(track->GetNofHits() == 4 && (getBeta(track) > 0.90 && getBeta(track) < 1.10))) continue;
1179 if (rings == 0) {
1180 fRingsWithTrack[4]++;
1181 if (ring->GetChi2() < 4.)
1182 fSeDsply_TR->DrawEvent(ev, ringIndx, 1); //Some will be drawn double, but for now ok
1183 }
1184 fHM->H2("fhTofTrackRichRingX")->Fill(ring->GetCenterX(), track->GetFitX(RichZPos));
1185 fHM->H2("fhTofTrackRichRingY")->Fill(ring->GetCenterY(), track->GetFitY(RichZPos));
1186
1187 const double xDist = (track->GetFitX(RichZPos) - ring->GetCenterX());
1188 const double yDist = (track->GetFitY(RichZPos) - ring->GetCenterY());
1189 const double rDist = std::sqrt(xDist * xDist + yDist * yDist);
1190 fHM->H1("fhTrackRingDistance_corr")->Fill(rDist);
1191
1192 fRingsWithTrack[0]++;
1193
1194 for (int k = 0; k < ring->GetNofHits(); k++) {
1195 Int_t hitInd = ring->GetHit(k);
1196 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
1197 if (nullptr == hit) continue;
1198 fHM->H2("fhTofTrackRichRingHitX")->Fill(hit->GetX(), track->GetFitX(RichZPos));
1199 fHM->H2("fhTofTrackRichRingHitY")->Fill(hit->GetY(), track->GetFitY(RichZPos));
1200 }
1201 }
1202
1203 if (clTrack.first > -1) {
1204 // first: TrackIndex; second: Distance;
1205 //FIXME
1206 //if (getBeta(TracksOfEvnt[clTrack.first]) > 0.9) DrawRing(ring,TracksOfEvnt,true);
1207 fHM->H1("fhTrackRingDistance")->Fill(clTrack.second);
1208 CbmTofTracklet* track =
1209 TracksOfEvnt[clTrack.first]; //static_cast<CbmTofTracklet *>(fTofTracks->At(clTrack.first));
1210 if (track == nullptr) continue;
1211 if (isOnTarget(track)) {
1212 fHM->H1("fhTrackRingDistanceOnTarget")->Fill(clTrack.second);
1213 }
1214 else {
1215 fHM->H1("fhTrackRingDistanceOffTarget")->Fill(clTrack.second);
1216 }
1217 fHM->H2("fhTrackRingDistanceVSRingradius")->Fill(clTrack.second, ring->GetRadius());
1218 fHM->H2("fhTrackRingDistanceVSRingChi2")->Fill(clTrack.second, ring->GetChi2());
1219 //if ( (clTrack.second < 20.0 )) {
1220 fHM->H2("fhRichRingXY_goodTrack")->Fill(ring->GetCenterX(), ring->GetCenterY());
1221 fHM->H2("fhRichRing_goodTrackXY")->Fill(track->GetFitX(RichZPos), track->GetFitY(RichZPos));
1222 //}
1223 fHM->H2("fhClosTrackRingX")->Fill(ring->GetCenterX(), track->GetFitX(RichZPos));
1224 fHM->H2("fhClosTrackRingY")->Fill(ring->GetCenterY(), track->GetFitY(RichZPos));
1225 fHM->H2("fhTofClosTrackRichRingXY")->Fill(track->GetFitX(RichZPos), track->GetFitY(RichZPos));
1226 if ((clTrack.second < (ring->GetRadius() * 1.2))) { //Good Ring
1227 fHM->H2("fhGoodRingsXY_TargetPos")->Fill(track->GetFitX(0.), track->GetFitY(0.));
1228 fHM->H1("fhRichRingChi2_goodRing")->Fill(ring->GetChi2());
1229 fHM->H2("fhTrackRingDistanceVSRingChi2_goodRing")->Fill(clTrack.second, ring->GetChi2());
1230 fHM->H1("fhTofBetaRing")->Fill(getBeta(track));
1231 fHM->H2("fhTofBetaRingDist")->Fill(getBeta(track), clTrack.second);
1232 fHM->H2("fhTofBetaVsRadius")->Fill(getBeta(track), ring->GetRadius());
1233 //Ring properties of "Good rings"
1234 fHM->H1("fhRichRingRadius_goodRing")->Fill(ring->GetRadius());
1235 fHM->H1("fhNofHitsInRing_goodRing")->Fill(ring->GetNofHits());
1236 fHM->H1("fhRichRingBeta_GoodRing")->Fill(getBeta(ring));
1237 }
1238 }
1239
1240 fHM->H2("fhTofRichRingXZ")
1241 ->Fill(RichZPos,
1242 ring->GetCenterX()); //Z Axis by Hand because ring has no Z component
1243 RichTofEv.emplace_back(ring->GetCenterX(), ring->GetCenterY(), RichZPos);
1244 // Draw XY position of center of rings; later add the Tracks in Tof
1245 fHM->H2("fhTofTrackRichRingXY")
1246 ->Fill(ring->GetCenterX(), ring->GetCenterY(),
1247 3); // 3 to change color for Rings
1248 }
1249
1250 //DrawRichTofEv(RichTofEv);
1251 fHM->H1("fhNofCbmEventsRing")->Fill(1);
1252 }
1253
1254
1255 // std::cout<< "TOF Digis:\t" << ev->GetNofData(ECbmDataType::kTofDigi) <<std::endl;
1256 // std::cout<< "TOF Hits:\t" << ev->GetNofData(ECbmDataType::kTofHit) <<std::endl;
1257 // std::cout<< "TOF Tracks:\t" << ev->GetNofData(ECbmDataType::kTofTrack) <<std::endl;
1258
1259
1260 //Select and Analyse Blobs
1261 uint32_t blob = 0;
1262 for (unsigned int j = 0; j < pmtHits.size(); ++j) {
1263 if (pmtHits[j] > 30) {
1264 blob++;
1265 // Blob found
1266 double xBlob = -7.95 + (int((j / 9)) * 5.3) + fXOffsetHisto;
1267 double yBlob = 21.2 - ((j % 9) * 5.3);
1268 //std::cout<<"BLOB X:" << i << " "<< xBlob << std::endl;
1269 for (size_t k = 0; k < ev->GetNofData(ECbmDataType::kTofTrack); k++) {
1270 auto iTofTrack = ev->GetIndex(ECbmDataType::kTofTrack, k);
1271 CbmTofTracklet* track = static_cast<CbmTofTracklet*>(fTofTracks->At(iTofTrack));
1272 if (track == nullptr) continue;
1273 double xBlobTrack = track->GetFitX(RichZPos) - xBlob;
1274 double yBlobTrack = track->GetFitY(RichZPos) - yBlob;
1275 fHM->H1("fhBlobTrackDistX")->Fill(std::fabs(xBlobTrack));
1276 fHM->H1("fhBlobTrackDistY")->Fill(std::fabs(yBlobTrack));
1277 fHM->H1("fhBlobTrackDist")->Fill(std::sqrt(xBlobTrack * xBlobTrack + yBlobTrack * yBlobTrack));
1278 }
1279 }
1280 }
1281 if (blob > 0) {
1282 fHM->H1("fhNofBlobEvents")->Fill(1);
1283 fHM->H1("fhNofBlobsInEvent")->Fill(blob);
1284 }
1285
1286 } //End CbmEvent loop
1287
1288
1289 RichRings();
1290}
1291
1292void CbmRichMCbmQaReal::RichRings()
1293{
1294 int nofRichRings = fRichRings->GetEntriesFast();
1295 fHM->H1("fhNofRichRingsInTimeslice")->Fill(nofRichRings);
1296 for (int i = 0; i < nofRichRings; i++) {
1297 CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(i));
1298 if (ring == nullptr) continue;
1299 //DrawRing(ring);
1300 fHM->H2("fhRichRingXY")->Fill(ring->GetCenterX(), ring->GetCenterY());
1301 fHM->H1("fhRichRingRadius")->Fill(ring->GetRadius());
1302 fHM->H1("fhNofHitsInRing")->Fill(ring->GetNofHits());
1303 fHM->H2("fhRichRingRadiusY")->Fill(ring->GetRadius(), ring->GetCenterY());
1304 fHM->H2("fhRichHitsRingRadius")->Fill(ring->GetNofHits(), ring->GetRadius());
1305 }
1306}
1307
1308std::pair<int, double> CbmRichMCbmQaReal::FindClosestTrack(const CbmRichRing* ring,
1309 const std::vector<CbmTofTracklet*> track)
1310{
1311 int ringX = ring->GetCenterX();
1312 int ringY = ring->GetCenterY();
1313
1314 int closTrack = -1;
1315 double closDist = -999999.99;
1316
1317 for (unsigned int indx = 0; indx < track.size(); ++indx) {
1318
1319 //Calc if Track is in Ring (+20% )
1320 if (track[indx]->GetNofHits() <= 3) continue;
1321 const double xDist = (track[indx]->GetFitX(RichZPos) - ringX);
1322 const double yDist = (track[indx]->GetFitY(RichZPos) - ringY);
1323 const double rDist = std::sqrt(xDist * xDist + yDist * yDist);
1324 const double RadiusFactor = 1.2; // Factor of how big radius of acceptance should
1325
1326 if (rDist < ring->GetRadius() * RadiusFactor) {
1327 //std::cout<<"Track in defined Ring range ("<<ring->GetRadius()*RadiusFactor<<"cm) (RingRadius: "<<ring->GetRadius()<<"cm). ";
1328 }
1329 //if (rDist < ring->GetRadius()*RadiusFactor && ring->GetRadius() > 2. && ring->GetRadius() < 4.2) {
1330 if (indx == 0) {
1331 closDist = rDist;
1332 closTrack = indx;
1333 }
1334 else {
1335 if (closDist > rDist) {
1336 closDist = rDist;
1337 closTrack = indx;
1338 }
1339 }
1340 //}
1341 }
1342 //if (closTrack > -1 ) std::cout<< "closestTrack to ring "<< ring <<": "<<closTrack<<" " << static_cast<CbmTofTracklet *>(fTofTracks->At(closTrack)) <<std::endl;
1343 std::pair<int, double> p;
1344 p.first = closTrack;
1345 p.second = closDist;
1346
1347 return p;
1348}
1349
1350std::pair<int, double> CbmRichMCbmQaReal::FindClosestRing(CbmTofTracklet* track, std::vector<int>& ringIndx)
1351{
1352 // Closest Ring to Track in +20% Ring Radius!
1353 const double x_track = track->GetFitX(RichZPos);
1354 const double y_track = track->GetFitY(RichZPos);
1355
1356 int closTrack = -1;
1357 double closDist = -999999.99;
1358
1359 for (unsigned int indx = 0; indx < ringIndx.size(); ++indx) {
1360 const CbmRichRing* ring = static_cast<CbmRichRing*>(fRichRings->At(ringIndx[indx]));
1361
1362 int ringX = ring->GetCenterX();
1363 int ringY = ring->GetCenterY();
1364
1365 //Calc if Track is in Ring (+20% )
1366 const double xDist = (x_track - ringX);
1367 const double yDist = (y_track - ringY);
1368 const double rDist = std::sqrt(xDist * xDist + yDist * yDist);
1369 //const double RadiusFactor = 1.2; // Factor of how big radius of acceptance should
1370
1371 if (/*rDist < ring->GetRadius() * RadiusFactor &&*/ cutRadius(ring)) {
1372 //std::cout<<"Track in defined Ring range ("<<ring->GetRadius()*RadiusFactor<<"cm) (RingRadius: "<<ring->GetRadius()<<"cm). ";
1373
1374 if (indx == 0) {
1375 closDist = rDist;
1376 closTrack = indx;
1377 }
1378 else {
1379 if (closDist > rDist) {
1380 closDist = rDist;
1381 closTrack = indx;
1382 }
1383 }
1384 }
1385 }
1386
1387 //if (closTrack > -1 ) std::cout<< "closestRing to Track "<< track <<": "<<closTrack <<" "<< static_cast<CbmRichRing *>(fRichRings->At(ringIndx[closTrack])) <<std::endl;
1388 std::pair<int, double> p;
1389 p.first = closTrack;
1390 p.second = closDist;
1391
1392 return p;
1393}
1394
1395void CbmRichMCbmQaReal::DrawHist()
1396{
1397 cout.precision(4);
1398
1399 //SetDefaultDrawStyle();
1400 double nofEvents = fHM->H1("fhNofCbmEvents")->GetEntries();
1401 fHM->ScaleByPattern("fh_.*", 1. / nofEvents);
1402
1403 {
1404 fHM->CreateCanvas("rich_mcbm_fhNofCbmEvents", "rich_mcbm_fhNofCbmEvents", 600, 600);
1405 DrawH1(fHM->H1("fhNofCbmEvents"));
1406 }
1407
1408 {
1409 fHM->CreateCanvas("rich_mcbm_fhNofCbmEventsRing", "rich_mcbm_fhNofCbmEventsRing", 600, 600);
1410 DrawH1(fHM->H1("fhNofCbmEventsRing"));
1411 }
1412
1413 {
1414 fHM->CreateCanvas("rich_mcbm_fhNofEvents", "rich_mcbm_fhNofEvents", 600, 600);
1415 DrawH1(fHM->H1("fhNofEvents"));
1416 }
1417
1418 {
1419 fHM->CreateCanvas("HitsInTimeslice", "HitsInTimeslice", 600, 600);
1420 DrawH1(fHM->H1("fhHitsInTimeslice"));
1421 }
1422
1423 {
1424 fHM->CreateCanvas("RichDigisConsecTime", "RichDigisConsecTime", 600, 600);
1425 DrawH1(fHM->H1("fhRichDigisConsecTime"), kLinear, kLog);
1426 }
1427
1428
1429 {
1430 fHM->CreateCanvas("RichDigisConsecTimeTOT", "RichDigisConsecTimeTOT", 600, 600);
1431 DrawH1(fHM->H1("fhRichDigisConsecTimeTOT"), kLinear, kLog);
1432 }
1433
1434
1435 /*{ // NO position info for Digis :(
1436 fHM->CreateCanvas("Pixelrate","Pixelrate", 600 , 600);
1437 double time = nofEvents * 0.0128; //seconds
1438 fHM->H1("fhRichDigiPixelRate")->Scale(1./time);
1439 DrawH1(fHM->H1("fhRichDigiPixelRate"));
1440 }*/
1441
1442 {
1443 TCanvas* c = fHM->CreateCanvas("RichRingXY_goodTrack", "RichRingXY_goodTrack", 1200, 600);
1444 c->Divide(2, 1);
1445 c->cd(1);
1446 DrawH2(fHM->H2("fhRichRingXY_goodTrack"));
1447 c->cd(2);
1448 DrawH2(fHM->H2("fhRichRing_goodTrackXY"));
1449 }
1450
1451
1452 {
1453 TCanvas* c = fHM->CreateCanvas("rich_mcbm_nofObjectsInTimeslice", "rich_mcbm_nofObjectsInTimeslice", 1500, 500);
1454 c->Divide(3, 1);
1455 c->cd(1);
1456 DrawH1(fHM->H1("fhNofRichDigisInTimeslice"), kLinear, kLog);
1457 c->cd(2);
1458 DrawH1(fHM->H1("fhNofRichHitsInTimeslice"), kLinear, kLog);
1459 c->cd(3);
1460 DrawH1(fHM->H1("fhNofRichRingsInTimeslice"), kLinear, kLog);
1461 }
1462
1463 {
1464 TCanvas* c = fHM->CreateCanvas("rich_mcbm_XY", "rich_mcbm_XY", 1200, 600);
1465 c->Divide(2, 1);
1466 c->cd(1);
1467 DrawH2(fHM->H2("fhRichHitXY"));
1468 c->cd(2);
1469 DrawH2(fHM->H2("fhRichRingXY"));
1470 }
1471
1472
1473 {
1474 TCanvas* c = fHM->CreateCanvas("rich_tof_XY", "rich_tof_XY", 1200, 600);
1475 c->Divide(2, 1);
1476 c->cd(1);
1477 DrawH2(fHM->H2("fhTofRichX"));
1478 c->cd(2);
1479 DrawH2(fHM->H2("fhTofRichY"));
1480 }
1481
1482
1483 {
1484 TCanvas* c = fHM->CreateCanvas("rich_tof_XY_zoomed", "rich_tof_XY_zoomed", 1200, 600);
1485 c->Divide(2, 1);
1486 c->cd(1);
1487 DrawH2(fHM->H2("fhTofRichX_zoomed"));
1488 c->cd(2);
1489 DrawH2(fHM->H2("fhTofRichY_zoomed"));
1490 }
1491
1492
1493 {
1494 TCanvas* c = fHM->CreateCanvas("rich_mcbm_richDigisTimeLog", "rich_mcbm_richDigisTimeLog", 1200, 1200);
1495 c->Divide(1, 2);
1496 c->cd(1);
1497 DrawH1({fHM->H1("fhRichDigisTimeLog"), fHM->H1("fhTofDigisTimeLog"), fHM->H1("fhBmonDigisTimeLog"),
1498 fHM->H1("fhStsDigisTimeLog"), fHM->H1("fhTrd1dDigisTimeLog"), fHM->H1("fhTrd2dDigisTimeLog")},
1499 {"RICH", "TOF", "Bmon", "STS", "TRD", "TRD2D"}, kLinear, kLog, true, 0.87, 0.75, 0.99, 0.99);
1500 gPad->SetLeftMargin(0.1);
1501 gPad->SetRightMargin(0.10);
1502 fHM->H1("fhStsDigisTimeLog")->GetYaxis()->SetTitleOffset(0.7);
1503 fHM->H1("fhStsDigisTimeLog")->SetMinimum(0.9);
1504 c->cd(2);
1505 DrawH1({fHM->H1("fhRichDigisTimeLogZoom"), fHM->H1("fhTofDigisTimeLogZoom"), fHM->H1("fhBmonDigisTimeLogZoom"),
1506 fHM->H1("fhStsDigisTimeLogZoom"), fHM->H1("fhTrd1dDigisTimeLogZoom"), fHM->H1("fhTrd2dDigisTimeLogZoom")},
1507 {"RICH", "TOF", "Bmon", "STS", "TRD", "TRD2D"}, kLinear, kLog, true, 0.87, 0.75, 0.99, 0.99);
1508 gPad->SetLeftMargin(0.1);
1509 gPad->SetRightMargin(0.1);
1510 fHM->H1("fhStsDigisTimeLogZoom")->GetYaxis()->SetTitleOffset(0.7);
1511 fHM->H1("fhStsDigisTimeLogZoom")->SetMinimum(0.9);
1512 }
1513
1514 {
1515 fHM->CreateCanvas("rich_mcbm_richDigisTimeLog2", "rich_mcbm_richDigisTimeLog2", 1200, 600);
1516 DrawH1({fHM->H1("fhRichDigisTimeLogZoom2"), fHM->H1("fhTofDigisTimeLogZoom2"), fHM->H1("fhBmonDigisTimeLogZoom2"),
1517 fHM->H1("fhStsDigisTimeLogZoom2"), fHM->H1("fhTrd1dDigisTimeLogZoom2"),
1518 fHM->H1("fhTrd2dDigisTimeLogZoom2")},
1519 {"RICH", "TOF", "Bmon", "STS", "TRD", "TRD2D"}, kLinear, kLog, true, 0.87, 0.75, 0.99, 0.99);
1520 gPad->SetLeftMargin(0.1);
1521 gPad->SetRightMargin(0.1);
1522 fHM->H1("fhStsDigisTimeLogZoom2")->GetYaxis()->SetTitleOffset(0.7);
1523 fHM->H1("fhStsDigisTimeLogZoom2")->SetMinimum(0.9);
1524 }
1525
1526 {
1527 fHM->CreateCanvas("rich_mcbm_richDigisRingTimeLog", "rich_mcbm_richDigisRingTimeLog", 1200, 600);
1528 TH1D* copyRichDigi = (TH1D*) fHM->H1("fhRichDigisTimeLog")->Clone();
1529 TH1D* copyRichRing = (TH1D*) fHM->H1("fhRichRingsTimeLog")->Clone();
1530 DrawH1({copyRichDigi, fHM->H1("fhTofDigisTimeLog"), fHM->H1("fhBmonDigisTimeLog"), copyRichRing,
1531 fHM->H1("fhStsDigisTimeLog"), fHM->H1("fhTrd1dDigisTimeLog"), fHM->H1("fhTrd2dDigisTimeLog")},
1532 {"RICH", "TOF", "Bmon", "RICH RING", "STS", "TRD", "TRD2D"}, kLinear, kLog, true, 0.83, 0.75, 0.99, 0.99);
1533 gPad->SetLeftMargin(0.1);
1534 gPad->SetRightMargin(0.1);
1535 copyRichDigi->GetYaxis()->SetTitleOffset(0.7);
1536 copyRichDigi->SetMinimum(0.9);
1537 }
1538
1539 {
1540
1541 TCanvas* c = fHM->CreateCanvas("rich_mcbm_richRingsTimeLog", "rich_mcbm_richRingsTimeLog", 1200, 1200);
1542 c->Divide(1, 2);
1543 c->cd(1);
1544 DrawH1({fHM->H1("fhRichDigisTimeLog"), fHM->H1("fhRichRingsTimeLog")}, {"Digis", "Rings"}, kLinear, kLog, true,
1545 0.87, 0.75, 0.99, 0.99);
1546 gPad->SetLeftMargin(0.1);
1547 gPad->SetRightMargin(0.10);
1548 fHM->H1("fhRichDigisTimeLog")->GetYaxis()->SetTitleOffset(0.7);
1549 fHM->H1("fhRichDigisTimeLog")->SetMinimum(0.9);
1550 c->cd(2);
1551 DrawH1({fHM->H1("fhRichDigisTimeLogZoom"), fHM->H1("fhRichRingsTimeLogZoom")}, {"Digis", "Rings"}, kLinear, kLog,
1552 true, 0.87, 0.75, 0.99, 0.99);
1553 gPad->SetLeftMargin(0.1);
1554 gPad->SetRightMargin(0.1);
1555 fHM->H1("fhRichDigisTimeLogZoom")->GetYaxis()->SetTitleOffset(0.7);
1556 fHM->H1("fhRichDigisTimeLogZoom")->SetMinimum(0.9);
1557 }
1558
1559 {
1560 fHM->CreateCanvas("rich_mcbm_richRingsTimeLog2", "rich_mcbm_richRingsTimeLog2", 1200, 600);
1561 DrawH1({fHM->H1("fhRichDigisTimeLogZoom2"), fHM->H1("fhRichRingsTimeLogZoom2")}, {"Digis", "Rings"}, kLinear, kLog,
1562 true, 0.87, 0.75, 0.99, 0.99);
1563 gPad->SetLeftMargin(0.1);
1564 gPad->SetRightMargin(0.1);
1565 fHM->H1("fhRichDigisTimeLogZoom2")->GetYaxis()->SetTitleOffset(0.7);
1566 fHM->H1("fhRichDigisTimeLogZoom2")->SetMinimum(0.9);
1567 }
1568
1569
1570 {
1571 TCanvas* c = fHM->CreateCanvas("rich_ToT", "rich_ToT", 1200, 600);
1572 c->Divide(2, 1);
1573 c->cd(1);
1574 DrawH1(fHM->H1("fhRichDigisToT"));
1575 c->cd(2);
1576 DrawH1(fHM->H1("fhRichHitToT"));
1577 }
1578
1579 {
1580 TCanvas* c = fHM->CreateCanvas("rich_BlobTrackDist", "rich_BlobTrackDist", 1800, 600);
1581 c->Divide(3, 1);
1582 c->cd(1);
1583 DrawH1(fHM->H1("fhBlobTrackDistX"));
1584 c->cd(2);
1585 DrawH1(fHM->H1("fhBlobTrackDistY"));
1586 c->cd(3);
1587 DrawH1(fHM->H1("fhBlobTrackDist"));
1588 }
1589
1590 {
1591 fHM->CreateCanvas("ToF_XYZ", "ToF_XYZ", 1200, 1200);
1592 fHM->H3("fhTofXYZ")->Draw();
1593 }
1594
1595
1596 {
1597 TCanvas* c = fHM->CreateCanvas("rich_mcbm_rings", "rich_mcbm_rings", 1200, 600);
1598 c->Divide(2, 1);
1599 c->cd(1);
1600 DrawH1(fHM->H1("fhRichRingRadius"));
1601 c->cd(2);
1602 DrawH1(fHM->H1("fhNofHitsInRing"));
1603 }
1604
1605 {
1606 fHM->CreateCanvas("TofHitsZ", "TofHitsZ", 1200, 1200);
1607 fHM->H1("fhTofHitsZ")->Draw();
1608 }
1609
1610 {
1611 fHM->CreateCanvas("TofTracksPerEvent", "TofTracksPerEvent", 1200, 1200);
1612 DrawH1(fHM->H1("fhTofTracksPerEvent"), kLinear, kLog);
1613 }
1614
1615 {
1616 fHM->CreateCanvas("TofTracksPerRichEvent", "TofTracksPerRichEvent", 1200, 1200);
1617 DrawH1(fHM->H1("fhTofTracksPerRichEvent"), kLinear, kLog);
1618 }
1619
1620 {
1621 TCanvas* c = fHM->CreateCanvas("TofRichRingX_Y", "TofRichRingX_Y", 1200, 1200);
1622 c->Divide(2, 1);
1623 c->cd(1);
1624 DrawH2(fHM->H2("fhTofRichRingX"));
1625 c->cd(2);
1626 DrawH2(fHM->H2("fhTofRichRingY"));
1627 }
1628
1629 {
1630 TCanvas* c = fHM->CreateCanvas("TofRichX_Stacks", "TofRichX_Stacks", 1800, 600);
1631 c->Divide(3, 1);
1632 c->cd(1);
1633 DrawH2(fHM->H2("fhTofRichX_stack1"));
1634 c->cd(2);
1635 DrawH2(fHM->H2("fhTofRichX_stack2"));
1636 c->cd(3);
1637 DrawH2(fHM->H2("fhTofRichX_stack3"));
1638 }
1639
1640 {
1641 TCanvas* c = fHM->CreateCanvas("TofRichY_Stacks", "TofRichY_Stacks", 1800, 600);
1642 c->Divide(3, 1);
1643 c->cd(1);
1644 DrawH2(fHM->H2("fhTofRichY_stack1"));
1645 c->cd(2);
1646 DrawH2(fHM->H2("fhTofRichY_stack2"));
1647 c->cd(3);
1648 DrawH2(fHM->H2("fhTofRichY_stack3"));
1649 }
1650
1651 {
1652 fHM->CreateCanvas("TofRichRingXZ", "TofRichRingXZ", 1200, 1200);
1653
1654 DrawH2(fHM->H2("fhTofRichRingXZ"));
1655 }
1656
1657 {
1658 fHM->CreateCanvas("TofHitsXZ", "TofHitsXZ", 1200, 1200);
1659
1660 DrawH2(fHM->H2("fhTofHitsXZ"));
1661 }
1662
1663 {
1664 fHM->CreateCanvas("TofHitsXY", "TofHitsXY", 1200, 1200);
1665
1666 DrawH2(fHM->H2("fhTofHitsXY"));
1667 }
1668
1669 {
1670 TCanvas* c = fHM->CreateCanvas("TofHitsXY_moduleIds", "TofHitsXY_moduleIds", 2500, 500);
1671
1672 c->Divide(5, 1);
1673 c->cd(1);
1674 DrawH2(fHM->H2("fhTofHitsXY_0"));
1675 c->cd(2);
1676 DrawH2(fHM->H2("fhTofHitsXY_1"));
1677 c->cd(3);
1678 DrawH2(fHM->H2("fhTofHitsXY_2"));
1679 c->cd(4);
1680 DrawH2(fHM->H2("fhTofHitsXY_3"));
1681 c->cd(5);
1682 DrawH2(fHM->H2("fhTofHitsXY_4"));
1683 }
1684
1685 {
1686 TCanvas* c = fHM->CreateCanvas("TofHitsZX_moduleIds", "TofHitsZX_moduleIds", 2500, 500);
1687
1688 c->Divide(5, 1);
1689 c->cd(1);
1690 DrawH2(fHM->H2("fhTofHitsZX_0"));
1691 c->cd(2);
1692 DrawH2(fHM->H2("fhTofHitsZX_1"));
1693 c->cd(3);
1694 DrawH2(fHM->H2("fhTofHitsZX_2"));
1695 c->cd(4);
1696 DrawH2(fHM->H2("fhTofHitsZX_3"));
1697 c->cd(5);
1698 DrawH2(fHM->H2("fhTofHitsZX_4"));
1699 }
1700
1701 {
1702 TCanvas* c = fHM->CreateCanvas("TofRichHitsX_moduleIds", "TofRichHitsX_moduleIds", 2500, 500);
1703
1704 c->Divide(5, 1);
1705 c->cd(1);
1706 DrawH2(fHM->H2("fhTofRichX_0"));
1707 c->cd(2);
1708 DrawH2(fHM->H2("fhTofRichX_1"));
1709 c->cd(3);
1710 DrawH2(fHM->H2("fhTofRichX_2"));
1711 c->cd(4);
1712 DrawH2(fHM->H2("fhTofRichX_3"));
1713 c->cd(5);
1714 DrawH2(fHM->H2("fhTofRichX_4"));
1715 }
1716
1717 {
1718 TCanvas* c = fHM->CreateCanvas("TofRichHitsY_moduleIds", "TofRichHitsY_moduleIds", 2500, 500);
1719
1720 c->Divide(5, 1);
1721 c->cd(1);
1722 DrawH2(fHM->H2("fhTofRichY_0"));
1723 c->cd(2);
1724 DrawH2(fHM->H2("fhTofRichY_1"));
1725 c->cd(3);
1726 DrawH2(fHM->H2("fhTofRichY_2"));
1727 c->cd(4);
1728 DrawH2(fHM->H2("fhTofRichY_3"));
1729 c->cd(5);
1730 DrawH2(fHM->H2("fhTofRichY_4"));
1731 }
1732
1733 {
1734 TCanvas* c = fHM->CreateCanvas("fhTofRichHitsResidual_moduleIds", "fhTofRichHitsResidual_moduleIds", 2500, 500);
1735
1736 c->Divide(5, 1);
1737 c->cd(1);
1738 DrawH2(fHM->H2("fhTofRichHitsResidual_0"));
1739 c->cd(2);
1740 DrawH2(fHM->H2("fhTofRichHitsResidual_1"));
1741 c->cd(3);
1742 DrawH2(fHM->H2("fhTofRichHitsResidual_2"));
1743 c->cd(4);
1744 DrawH2(fHM->H2("fhTofRichHitsResidual_3"));
1745 c->cd(5);
1746 DrawH2(fHM->H2("fhTofRichHitsResidual_4"));
1747 }
1748
1749 {
1750 fHM->CreateCanvas("TofTrackRichRingXY", "TofTrackRichRingXY", 1200, 1200);
1751
1752 DrawH2(fHM->H2("fhTofTrackRichRingXY"));
1753 }
1754
1755 {
1756 fHM->CreateCanvas("TofClosTrackRichRingXY", "TofClosTrackRichRingXY", 1200, 1200);
1757
1758 DrawH2(fHM->H2("fhTofClosTrackRichRingXY"));
1759 }
1760
1761 {
1762 TCanvas* c = fHM->CreateCanvas("TrackRingDist", "TrackRingDist", 1200, 800);
1763 c->Divide(2, 1);
1764 c->cd(1);
1765 DrawH1(fHM->H1("fhTrackRingDistance"));
1766 c->cd(2);
1767 DrawH2(fHM->H2("fhTrackRingDistanceVSRingradius"));
1768 }
1769
1770 {
1771 fHM->CreateCanvas("RingTrackDist", "RingTrackDist", 1200, 800);
1772 DrawH1(fHM->H1("fhRingTrackDistance"));
1773 }
1774
1775 {
1776 TCanvas* c = fHM->CreateCanvas("RingTrackDist_all", "RingTrackDist_all", 1800, 800);
1777 c->Divide(3, 1);
1778 c->cd(1);
1779 DrawH1(fHM->H1("fhRingTrackDistance_X"));
1780 c->cd(2);
1781 DrawH1(fHM->H1("fhRingTrackDistance_Y"));
1782 c->cd(3);
1783 DrawH2(fHM->H2("fhRingTrackDistance_XY"));
1784 }
1785
1786 {
1787 TCanvas* c = fHM->CreateCanvas("ClosTrackRingXY", "ClosTrackRingXY", 1200, 800);
1788 c->Divide(2, 1);
1789 c->cd(1);
1790 DrawH2(fHM->H2("fhClosTrackRingX"));
1791 c->cd(2);
1792 DrawH2(fHM->H2("fhClosTrackRingY"));
1793 }
1794
1795 {
1796 TCanvas* c = fHM->CreateCanvas("TrackRingXY", "TrackRingXY", 1200, 800);
1797 c->Divide(2, 1);
1798 c->cd(1);
1799 DrawH2(fHM->H2("fhTofTrackRichRingX"));
1800 c->cd(2);
1801 DrawH2(fHM->H2("fhTofTrackRichRingY"));
1802 }
1803
1804 {
1805 TCanvas* c = fHM->CreateCanvas("TofTracksXY", "TofTracksXY", 1200, 800);
1806 c->Divide(2, 1);
1807 c->cd(1);
1808 DrawH2(fHM->H2("fhTofTracksXY"));
1809 c->cd(2);
1810 DrawH2(fHM->H2("fhTofTracksXYRICH"));
1811 }
1812
1813 {
1814 fHM->CreateCanvas("TofTracksXY_Target", "TofTracksXY_Target", 800, 800);
1815 DrawH2(fHM->H2("fhTofTracksXY_Target"));
1816 }
1817
1818 {
1819 fHM->CreateCanvas("GoodRingsXY_TargetPos", "GoodRingsXY_TargetPos", 800, 800);
1820 DrawH2(fHM->H2("fhGoodRingsXY_TargetPos"));
1821 }
1822
1823 {
1824 fHM->CreateCanvas("TofBeta", "TofBeta", 800, 800);
1825 gStyle->SetOptStat(0);
1826 fHM->H1("fhTofBetaAll")->Draw("HIST");
1827 fHM->H1("fhTofBetaTracksWithHitsNoRing")->SetLineColorAlpha(kGreen, 1);
1828 fHM->H1("fhTofBetaTracksWithHitsNoRing")->Draw("HIST SAME");
1829
1830 //fHM->H1("fhTofBetaTracksNoRing")->SetLineColorAlpha(8, 1);
1831 //fHM->H1("fhTofBetaTracksNoRing")->Draw("HIST SAME");
1832
1833 //fHM->H1("fhTofBetaTracksWithHits")->SetLineColorAlpha(44, 1);
1834 //fHM->H1("fhTofBetaTracksWithHits")->Draw("HIST SAME");
1835
1836 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->SetLineColorAlpha(44, 1);
1837 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->Draw("HIST SAME");
1838
1839 fHM->H1("fhTofBetaRing")->SetLineColorAlpha(kRed, 1);
1840 fHM->H1("fhTofBetaRing")->Draw("HIST SAME");
1841
1842 auto legend = new TLegend(0.1, 0.75, 0.4, 0.9);
1843 legend->AddEntry(fHM->H1("fhTofBetaTracksWithHitsNoRing"), "Tracks with RichHits and no Ring", "l");
1844 //legend->AddEntry(fHM->H1("fhTofBetaTracksWithHits"),"Tracks with RichHits","l");
1845 //legend->AddEntry(fHM->H1("fhTofBetaTracksNoRing"),"Tracks with no Ring","l");
1846 legend->AddEntry(fHM->H1("fhTofBetaTrackswithClosestRingInRange"), "Tracks with clos. Ring in +20% Radius", "l");
1847 legend->AddEntry(fHM->H1("fhTofBetaRing"), "Tracks in good ring", "l");
1848 if (fRestrictToAcc) {
1849 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks in mRICH Acc.", "l");
1850 }
1851 else if (fRestrictToFullAcc) {
1852 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks in full mRICH Acc.", "l");
1853 }
1854 else {
1855 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks", "l");
1856 }
1857 legend->Draw();
1858 }
1859
1860 {
1861 TCanvas* c = fHM->CreateCanvas("TofBetaLog", "TofBetaLog", 1000, 1000);
1862 c->SetLogy();
1863
1864 Double_t max = fHM->H1("fhTofBetaAll")->GetMaximum();
1865 fHM->H1("fhTofBetaAll")->Draw("HIST");
1866
1867 if (fHM->H1("fhTofBetaTracksWithHitsNoRing")->GetMaximum() > max)
1868 max = fHM->H1("fhTofBetaTracksWithHitsNoRing")->GetMaximum();
1869 fHM->H1("fhTofBetaTracksWithHitsNoRing")->SetLineColorAlpha(kGreen, 1);
1870 fHM->H1("fhTofBetaTracksWithHitsNoRing")->Draw("HIST SAME");
1871
1872 //fHM->H1("fhTofBetaTracksNoRing")->SetLineColorAlpha(8, 1);
1873 //fHM->H1("fhTofBetaTracksNoRing")->Draw("HIST SAME");
1874
1875 //fHM->H1("fhTofBetaTracksWithHits")->SetLineColorAlpha(44, 1);
1876 //fHM->H1("fhTofBetaTracksWithHits")->Draw("HIST SAME");
1877
1878 if (fHM->H1("fhTofBetaTrackswithClosestRingInRange")->GetMaximum() > max)
1879 max = fHM->H1("fhTofBetaTrackswithClosestRingInRange")->GetMaximum();
1880 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->SetLineColorAlpha(12, 1);
1881 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->Draw("HIST SAME");
1882
1883 if (fHM->H1("fhTofBetaRing")->GetMaximum() > max) max = fHM->H1("fhTofBetaRing")->GetMaximum();
1884 fHM->H1("fhTofBetaRing")->SetLineColorAlpha(kRed, 1);
1885 fHM->H1("fhTofBetaRing")->Draw("HIST SAME");
1886
1887 fHM->H1("fhTofBetaAll")->SetAxisRange(1., max * 1.8, "Y");
1888
1889 auto legend = new TLegend(0.75, 0.77, 0.99, 0.96);
1890 legend->AddEntry(fHM->H1("fhTofBetaTracksWithHitsNoRing"), "Tracks with RichHits and no Ring", "l");
1891 //legend->AddEntry(fHM->H1("fhTofBetaTracksWithHits"),"Tracks with RichHits","l");
1892 //legend->AddEntry(fHM->H1("fhTofBetaTracksNoRing"),"Tracks with no Ring","l");
1893 legend->AddEntry(fHM->H1("fhTofBetaTrackswithClosestRingInRange"), "Tracks with clos. Ring in +20% Radius", "l");
1894 legend->AddEntry(fHM->H1("fhTofBetaRing"), "Tracks in good ring", "l");
1895 if (fRestrictToAcc) {
1896 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks in mRICH Acc.", "l");
1897 }
1898 else if (fRestrictToFullAcc) {
1899 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks in full mRICH Acc.", "l");
1900 }
1901 else {
1902 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks", "l");
1903 }
1904 legend->Draw();
1905 }
1906
1907 {
1908 TCanvas* c = fHM->CreateCanvas("TofBetaLog_pos", "TofBetaLog_pos", 1000, 1000);
1909 c->SetLogy();
1910
1911 TH1D* copyTofBetaAll = (TH1D*) fHM->H1("fhTofBetaAll")->Clone();
1912
1913 Double_t max = copyTofBetaAll->GetMaximum();
1914
1915 copyTofBetaAll->GetXaxis()->SetRangeUser(0.0, 1.2);
1916 copyTofBetaAll->Draw("HIST");
1917
1918 if (fHM->H1("fhTofBetaTracksWithHitsNoRing")->GetMaximum() > max)
1919 max = fHM->H1("fhTofBetaTracksWithHitsNoRing")->GetMaximum();
1920 fHM->H1("fhTofBetaTracksWithHitsNoRing")->SetLineColorAlpha(kGreen, 1);
1921 fHM->H1("fhTofBetaTracksWithHitsNoRing")->Draw("HIST SAME");
1922
1923 //fHM->H1("fhTofBetaTracksNoRing")->SetLineColorAlpha(8, 1);
1924 //fHM->H1("fhTofBetaTracksNoRing")->Draw("HIST SAME");
1925
1926 //fHM->H1("fhTofBetaTracksWithHits")->SetLineColorAlpha(44, 1);
1927 //fHM->H1("fhTofBetaTracksWithHits")->Draw("HIST SAME");
1928
1929 if (fHM->H1("fhTofBetaTrackswithClosestRingInRange")->GetMaximum() > max)
1930 max = fHM->H1("fhTofBetaTrackswithClosestRingInRange")->GetMaximum();
1931 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->SetLineColorAlpha(12, 1);
1932 fHM->H1("fhTofBetaTrackswithClosestRingInRange")->Draw("HIST SAME");
1933
1934 if (fHM->H1("fhTofBetaRing")->GetMaximum() > max) max = fHM->H1("fhTofBetaRing")->GetMaximum();
1935 fHM->H1("fhTofBetaRing")->SetLineColorAlpha(kRed, 1);
1936 fHM->H1("fhTofBetaRing")->Draw("HIST SAME");
1937
1938 copyTofBetaAll->SetAxisRange(1., max * 1.8, "Y");
1939
1940 auto legend = new TLegend(0.75, 0.77, 0.99, 0.96);
1941 legend->AddEntry(fHM->H1("fhTofBetaTracksWithHitsNoRing"), "Tracks with RichHits and no Ring", "l");
1942 //legend->AddEntry(fHM->H1("fhTofBetaTracksWithHits"),"Tracks with RichHits","l");
1943 //legend->AddEntry(fHM->H1("fhTofBetaTracksNoRing"),"Tracks with no Ring","l");
1944 legend->AddEntry(fHM->H1("fhTofBetaTrackswithClosestRingInRange"), "Tracks with clos. Ring in +20% Radius", "l");
1945 legend->AddEntry(fHM->H1("fhTofBetaRing"), "Tracks in good ring", "l");
1946 if (fRestrictToAcc) {
1947 legend->AddEntry(fHM->H1("fhTofBetaAll"), "All Tracks in mRICH Acc.", "l");
1948 }
1949 else if (fRestrictToFullAcc) {
1950 legend->AddEntry(copyTofBetaAll, "All Tracks in full mRICH Acc.", "l");
1951 }
1952 else {
1953 legend->AddEntry(copyTofBetaAll, "All Tracks", "l");
1954 }
1955 legend->Draw();
1956 }
1957
1958 {
1959 fHM->CreateCanvas("TofBetaVsRadius", "TofBetaVsRadius", 800, 800);
1960 DrawH2(fHM->H2("fhTofBetaVsRadius"));
1961 }
1962
1963 {
1964 fHM->CreateCanvas("TofBetaRingDist", "TofBetaRingDist", 800, 800);
1965 DrawH2(fHM->H2("fhTofBetaRingDist"));
1966 }
1967
1968 {
1969 fHM->CreateCanvas("TofBetaAllFullAcc", "TofBetaAllFullAcc", 800, 800);
1970 DrawH1(fHM->H1("fhTofBetaAllFullAcc"));
1971 }
1972
1973 {
1974 TCanvas* c = fHM->CreateCanvas("TofBetaAllFullAccLog", "TofBetaAllFullAccLog", 800, 800);
1975 c->SetLogy();
1976 DrawH1(fHM->H1("fhTofBetaAllFullAcc"));
1977 }
1978
1979 {
1980 TCanvas* c = fHM->CreateCanvas("RingAnalysis", "RingAnalysis", 1000, 1000);
1981 //c->SetLogy();
1982 c->Divide(2, 2);
1983 c->cd(1);
1984 DrawH1(fHM->H1("fhRingDeltaTime"));
1985 c->cd(2);
1986 DrawH1(fHM->H1("fhRingToTs"));
1987 c->cd(3);
1988 DrawH1(
1989 {fHM->H1("fhRingLE"), fHM->H1("fhRingNoClTrackLE"), fHM->H1("fhRingClTrackFarAwayLE"), fHM->H1("fhGoodRingLE")},
1990 {"all Rings", "Rings w/o closest Track", "Rings w/ closest Track >5cm", "Good Rings"}, kLinear, kLinear, true,
1991 0.70, 0.75, 0.95, 0.99);
1992 c->cd(4);
1993 DrawH2(fHM->H2("fhRingLEvsToT"));
1994 }
1995
1996 {
1997 TCanvas* c = fHM->CreateCanvas("InnerRingAnalysis", "InnerRingAnalysis", 1000, 1200);
1998 //c->SetLogy();
1999 c->Divide(2, 3);
2000 c->cd(1);
2001 DrawH1(fHM->H1("fhInnerRingDeltaTime"));
2002 c->cd(2);
2003 DrawH1(fHM->H1("fhInnerRingToTs"));
2004 c->cd(3);
2005 DrawH1({fHM->H1("fhInnerRingLE"), fHM->H1("fhInnerRingNoClTrackLE"), fHM->H1("fhInnerRingClTrackFarAwayLE"),
2006 fHM->H1("fhInnerGoodRingLE")},
2007 {"all Rings", "Rings w/o closest Track", "Rings w/ closest Track >5cm", "Good Rings"}, kLinear, kLinear,
2008 true, 0.70, 0.75, 0.95, 0.99);
2009 c->cd(4);
2010 DrawH1(fHM->H1("fhInnerRingFlag"));
2011 c->cd(5);
2012 DrawH1(fHM->H1("fhNofInnerHits"));
2013 }
2014
2015 {
2016 fHM->CreateCanvas("DiRICHInRegion", "DiRICHInRegion", 800, 800);
2017 //c->SetLogy();
2018 DrawH1(fHM->H1("fhDiRICHsInRegion"));
2019 }
2020
2021 {
2022 fHM->CreateCanvas("RichRingRadiusVsY", "RichRingRadiusVsY", 800, 800);
2023 //c->SetLogy();
2024 DrawH2(fHM->H2("fhRichRingRadiusY"));
2025 }
2026
2027 {
2028 fHM->CreateCanvas("RichRingHitsVsRadius", "RichRingHitsVsRadius", 800, 800);
2029 //c->SetLogy();
2030 DrawH2(fHM->H2("fhRichHitsRingRadius"));
2031 }
2032
2033 {
2034 fHM->CreateCanvas("RichHitToTEvent", "RichHitToTEvent", 800, 800);
2035 DrawH1(fHM->H1("fhRichHitToTEvent"));
2036 }
2037
2038 {
2039 fHM->CreateCanvas("RichHitXYEvent", "RichHitXYEvent", 800, 800);
2040 DrawH2(fHM->H2("fhRichHitXYEvent"));
2041 }
2042
2043 {
2044 fHM->CreateCanvas("rich_mcbm_fhBlobEvents", "rich_mcbm_fhBlobEvents", 600, 600);
2045 DrawH1(fHM->H1("fhNofBlobEvents"));
2046 }
2047
2048 {
2049 fHM->CreateCanvas("rich_mcbm_fhBlobsInCbmEvent", "rich_mcbm_fhBlobsInCbmEvent", 600, 600);
2050 DrawH1(fHM->H1("fhNofBlobsInEvent"));
2051 }
2052
2053 {
2054 TCanvas* c = fHM->CreateCanvas("TofTrackRichHitXY", "TofTrackRichHitXY", 1200, 800);
2055 c->Divide(2, 1);
2056 c->cd(1);
2057 DrawH2(fHM->H2("fhTofTrackRichHitX"));
2058 c->cd(2);
2059 DrawH2(fHM->H2("fhTofTrackRichHitY"));
2060 }
2061
2062 {
2063 TCanvas* c = fHM->CreateCanvas("TofTrackRichRingHitXY", "TofTrackRichRingHitXY", 1200, 800);
2064 c->Divide(2, 1);
2065 c->cd(1);
2066 DrawH2(fHM->H2("fhTofTrackRichRingHitX"));
2067 c->cd(2);
2068 DrawH2(fHM->H2("fhTofTrackRichRingHitY"));
2069 }
2070
2071 {
2072 TCanvas* c = fHM->CreateCanvas("TofHitRichRingHitXY", "TofHitRichRingHitXY", 1200, 800);
2073 c->Divide(2, 1);
2074 c->cd(1);
2075 DrawH2(fHM->H2("fhTofHitRichRingHitX"));
2076 c->cd(2);
2077 DrawH2(fHM->H2("fhTofHitRichRingHitY"));
2078 }
2079
2080 {
2081 TCanvas* c = fHM->CreateCanvas("TrackRingDistance_Target", "TrackRingDistance_Target", 1200, 800);
2082 c->Divide(2, 1);
2083 c->cd(1);
2084 DrawH1(fHM->H1("fhTrackRingDistanceOnTarget"));
2085 c->cd(2);
2086 DrawH1(fHM->H1("fhTrackRingDistanceOffTarget"));
2087 }
2088
2089 {
2090 TCanvas* c = fHM->CreateCanvas("TofTrackRichHitXY_cut", "TofTrackRichHitXY_cut", 1200, 800);
2091 c->Divide(2, 1);
2092 c->cd(1);
2093 DrawH2(fHM->H2("fhTofTrackRichHitX_cuts"));
2094 c->cd(2);
2095 DrawH2(fHM->H2("fhTofTrackRichHitY_cuts"));
2096 }
2097
2098 {
2099 TCanvas* c = fHM->CreateCanvas("TofTrackRichHitXY_overBetaCut", "TofTrackRichHitXY_overBetaCut", 1200, 800);
2100 c->Divide(2, 1);
2101 c->cd(1);
2102 DrawH2(fHM->H2("fhTofTrackRichHitX_oBetacuts"));
2103 c->cd(2);
2104 DrawH2(fHM->H2("fhTofTrackRichHitY_oBetacuts"));
2105 }
2106
2107 {
2108 TCanvas* c = fHM->CreateCanvas("TofTrackRichHitXY_underBetaCut", "TofTrackRichHitXY_underBetaCut", 1200, 800);
2109 c->Divide(2, 1);
2110 c->cd(1);
2111 DrawH2(fHM->H2("fhTofTrackRichHitX_uBetacuts"));
2112 c->cd(2);
2113 DrawH2(fHM->H2("fhTofTrackRichHitY_uBetacuts"));
2114 }
2115
2116 {
2117 TCanvas* c = fHM->CreateCanvas("TofTrackRichHitXY_oBetacuts_dtime", "TofTrackRichHitXY_oBetacuts_dtime", 1200, 800);
2118 c->Divide(2, 1);
2119 c->cd(1);
2120 DrawH2(fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime"));
2121 c->cd(2);
2122 DrawH2(fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime"));
2123 }
2124
2125 {
2126 TCanvas* c =
2127 fHM->CreateCanvas("TofTrackHitRichHitXY_oBetacuts_dtime", "TofTrackHitRichHitXY_oBetacuts_dtime", 1200, 800);
2128 c->Divide(2, 1);
2129 c->cd(1);
2130 DrawH2(fHM->H2("fhTofTrackHitRichHitX_oBetacuts_dtime"));
2131 c->cd(2);
2132 DrawH2(fHM->H2("fhTofTrackHitRichHitY_oBetacuts_dtime"));
2133 }
2134
2135 {
2136 fHM->CreateCanvas("TofTrackRichHitTime_oBetacuts", "TofTrackRichHitTime_oBetacuts", 600, 600);
2137 DrawH1(fHM->H1("fhTofTrackRichHitTime_oBetacuts"));
2138 }
2139
2140
2141 {
2142 TCanvas* c = fHM->CreateCanvas("TofTrackHitRichHitXY_oBetacuts_dtime_evo",
2143 "TofTrackHitRichHitXY_oBetacuts_dtime_evo", 1200, 3200);
2144 c->Divide(2, 4);
2145 c->cd(1);
2146 DrawH2(fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_4"));
2147 c->cd(2);
2148 DrawH2(fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_4"));
2149
2150 c->cd(3);
2151 DrawH2(fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_6"));
2152 c->cd(4);
2153 DrawH2(fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_6"));
2154
2155 c->cd(5);
2156 DrawH2(fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_8"));
2157 c->cd(6);
2158 DrawH2(fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_8"));
2159
2160 c->cd(7);
2161 DrawH2(fHM->H2("fhTofTrackRichHitX_oBetacuts_dtime_10"));
2162 c->cd(8);
2163 DrawH2(fHM->H2("fhTofTrackRichHitY_oBetacuts_dtime_10"));
2164 }
2165
2166 {
2167 fHM->CreateCanvas("TrackRingDistance_AfterCorr", "TrackRingDistance_AfterCorr", 600, 600);
2168 DrawH1(fHM->H1("fhTrackRingDistance_corr"));
2169 }
2170
2171 {
2172 fHM->CreateCanvas("TracksWithRings", "TracksWithRings", 600, 600);
2173 DrawH1(fHM->H1("fhTracksWithRings"));
2174 }
2175
2176 {
2177 TCanvas* c = fHM->CreateCanvas("GoodRings", "GoodRings", 1200, 800);
2178 c->Divide(2, 1);
2179 c->cd(1);
2180 DrawH1(fHM->H1("fhRichRingRadius_goodRing"));
2181 c->cd(2);
2182 DrawH1(fHM->H1("fhNofHitsInRing_goodRing"));
2183 }
2184
2185 {
2186 TCanvas* c = fHM->CreateCanvas("richRingBeta", "richRingBeta", 1200, 800);
2187 c->Divide(2, 1);
2188 c->cd(1);
2189 DrawH1(fHM->H1("fhRichRingBeta"));
2190 c->cd(2);
2191 DrawH1(fHM->H1("fhRichRingBeta_GoodRing"));
2192 }
2193
2194 {
2195 TCanvas* c = fHM->CreateCanvas("TrackRingDistanceVSRingChi2", "TrackRingDistanceVSRingChi2", 1200, 800);
2196 c->Divide(2, 1);
2197 c->cd(1);
2198 DrawH2(fHM->H2("fhTrackRingDistanceVSRingChi2"));
2199 c->cd(2);
2200 DrawH2(fHM->H2("fhTrackRingDistanceVSRingChi2_goodRing"));
2201 }
2202
2203
2204 {
2205 TCanvas* c = fHM->CreateCanvas("RichRingChi2", "RichRingChi2", 1600, 800);
2206 //c->SetLogy();
2207 c->Divide(2, 1);
2208 c->cd(1);
2209 DrawH1(fHM->H1("fhRichRingChi2"));
2210 c->cd(2);
2211 DrawH1(fHM->H1("fhRichRingChi2_goodRing"));
2212 }
2213
2214 {
2215 fHM->CreateCanvas("TofTracksXYRICH_Accectance", "TofTracksXYRICH_Accectance", 1200, 1200);
2216 DrawH2(fHM->H2("fhTofTracksXYRICH_Accectance"));
2217 }
2218
2219 {
2220 fHM->CreateCanvas("HitTimeEvent", "HitTimeEvent", 1200, 1200);
2221 DrawH1(fHM->H1("fhHitTimeEvent"));
2222 }
2223
2224 {
2225 TCanvas* c = fHM->CreateCanvas("Bmon", "Bmon", 2400, 800);
2226 //c->SetLogy();
2227 c->Divide(3, 1);
2228 c->cd(1);
2229 DrawH1(fHM->H1("fhBmonDigiMultiplicity"));
2230 c->cd(2);
2231 DrawH1(fHM->H1("fhBmonDigiTime"));
2232 c->cd(3);
2233 DrawH1(fHM->H1("fhBmonDigiTimeEvent"));
2234 }
2235}
2236
2237void CbmRichMCbmQaReal::DrawRing(CbmRichRing* ring)
2238{
2239 std::vector<CbmTofTracklet*> track;
2240 this->DrawRing(ring, track);
2241}
2242
2243void CbmRichMCbmQaReal::DrawRing(CbmRichRing* ring, std::vector<CbmTofTracklet*> track, bool full)
2244{
2245 //std::cout<<"#!#DRAW!!!"<<std::endl;
2246 if (fNofDrawnRings > 20) return;
2247 fNofDrawnRings++;
2248 stringstream ss;
2249 ss << "Event" << fNofDrawnRings;
2250 //fNofDrawnRings++;
2251 TCanvas* c = nullptr;
2252 if (full == true) {
2253 c = fHM->CreateCanvas(ss.str().c_str(), ss.str().c_str(), 800, 800);
2254 }
2255 else {
2256 c = fHM->CreateCanvas(ss.str().c_str(), ss.str().c_str(), 500, 500);
2257 }
2258 c->SetGrid(true, true);
2259 TH2D* pad = nullptr;
2260 if (full == true) {
2261 pad = new TH2D(ss.str().c_str(), (ss.str() + ";X [cm];Y [cm]").c_str(), 1, -15., 10., 1, -5., 20);
2262 }
2263 else {
2264 pad = new TH2D(ss.str().c_str(), (ss.str() + ";X [cm];Y [cm]").c_str(), 1, -5., 5., 1, -5., 5);
2265 }
2266
2267 pad->SetStats(false);
2268 pad->Draw();
2269
2270 if (full == true) {
2271 //rough Drawing of RichDetectorAcceptance
2272 TLine* line0 = new TLine(-6.25, 8, -6.25, 15.9);
2273 line0->Draw();
2274 TLine* line1 = new TLine(-6.25, 15.9, -1.05, 15.9);
2275 line1->Draw();
2276 TLine* line2 = new TLine(-1.05, 15.9, -1.05, 13.2);
2277 line2->Draw();
2278 TLine* line3 = new TLine(-1.05, 13.2, +4.25, 13.2);
2279 line3->Draw();
2280 TLine* line4 = new TLine(4.25, 13.2, +4.25, 8);
2281 line4->Draw();
2282 TLine* line5 = new TLine(4.25, 8, -6.25, 8);
2283 line5->Draw();
2284 }
2285
2286 // find min and max x and y positions of the hits
2287 // in order to shift drawing
2288 double xCur = 0.;
2289 double yCur = 0.;
2290
2291 if (full == false) {
2292 double xmin = 99999., xmax = -99999., ymin = 99999., ymax = -99999.;
2293 for (int i = 0; i < ring->GetNofHits(); i++) {
2294 Int_t hitInd = ring->GetHit(i);
2295 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
2296 if (nullptr == hit) continue;
2297 if (xmin > hit->GetX()) xmin = hit->GetX();
2298 if (xmax < hit->GetX()) xmax = hit->GetX();
2299 if (ymin > hit->GetY()) ymin = hit->GetY();
2300 if (ymax < hit->GetY()) ymax = hit->GetY();
2301 }
2302 xCur = (xmin + xmax) / 2.;
2303 yCur = (ymin + ymax) / 2.;
2304 }
2305
2306 //Draw circle and center
2307 TEllipse* circle = new TEllipse(ring->GetCenterX() - xCur, ring->GetCenterY() - yCur, ring->GetRadius());
2308 circle->SetFillStyle(0);
2309 circle->SetLineWidth(3);
2310 circle->Draw();
2311 TEllipse* center = new TEllipse(ring->GetCenterX() - xCur, ring->GetCenterY() - yCur, .1);
2312 center->Draw();
2313
2314
2315 double hitZ = 0;
2316 uint nofDrawHits = 0;
2317
2318 // Draw hits
2319 for (int i = 0; i < ring->GetNofHits(); i++) {
2320 Int_t hitInd = ring->GetHit(i);
2321 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
2322 if (nullptr == hit) continue;
2323 TEllipse* hitDr = new TEllipse(hit->GetX() - xCur, hit->GetY() - yCur, .25);
2324 //std::cout<<"LE of Hit: "<< hit->GetTime()- fCbmEventStartTime << "\t" << hit->GetTime() << "\t" << fCbmEventStartTime <<std::endl;
2325 if (doToT(hit)) { // Good ToT selection
2326 hitDr->SetFillColor(kRed);
2327 }
2328 else {
2329 hitDr->SetFillColor(kBlue);
2330 }
2331 hitZ += hit->GetZ();
2332 nofDrawHits++;
2333 hitDr->Draw();
2334 }
2335 hitZ /= nofDrawHits;
2336
2337 int Tc = 0;
2338
2339 //Draw Tracks
2340 if (track.size() > 0) {
2341 stringstream ss3;
2342 std::string sTrackLabel;
2343 double dist = -99999.999;
2344 for (auto trackInd : track) {
2345 TEllipse* hitDr = new TEllipse(trackInd->GetFitX(hitZ) - xCur, trackInd->GetFitY(hitZ) - yCur, .25);
2346 hitDr->SetFillColor(kGreen);
2347 hitDr->Draw();
2348 //ss3 << "\\beta : "<< getBeta(trackInd); //inVel <<"x10^7 m/s";
2349 if (trackInd->GetFitX(hitZ) < 30.0) { // Track on correct side of ToF
2350 Tc++;
2351 double tmp_dist = std::sqrt(trackInd->GetFitX(hitZ) * trackInd->GetFitX(hitZ)
2352 + trackInd->GetFitY(hitZ) * trackInd->GetFitY(hitZ));
2353 if (dist < -99999.0) {
2354 dist = tmp_dist;
2355 sTrackLabel = "\\beta : " + std::to_string((double) getBeta(trackInd));
2356 }
2357 else if (dist > tmp_dist) {
2358 dist = tmp_dist;
2359 sTrackLabel = "\\beta : " + std::to_string((double) getBeta(trackInd));
2360 }
2361 }
2362 }
2363 ss3 << sTrackLabel;
2364 TLatex* latex1 = new TLatex(-4., 0.5, ss3.str().c_str());
2365 latex1->Draw();
2366 }
2367 else {
2368 //std::cout<<"No Tracks to Draw."<<std::endl;
2369 }
2370
2371
2372 //Draw information
2373 stringstream ss2;
2374 if (full == false) {
2375 ss2 << "(x,y,r,n)=(" << setprecision(3) << ring->GetCenterX() << ", " << ring->GetCenterY() << ", "
2376 << ring->GetRadius() << ", " << ring->GetNofHits() << ")";
2377 }
2378 else {
2379 ss2 << "(x,y,r,n,T,Tc)=(" << setprecision(3) << ring->GetCenterX() << ", " << ring->GetCenterY() << ", "
2380 << ring->GetRadius() << ", " << ring->GetNofHits() << ", " << track.size() << ", " << Tc << ")";
2381 }
2382 TLatex* latex = nullptr;
2383 if (full == true) {
2384 latex = new TLatex(ring->GetCenterX() - 13., ring->GetCenterY() + 5., ss2.str().c_str());
2385 }
2386 else {
2387 latex = new TLatex(-4., 4., ss2.str().c_str());
2388 }
2389 latex->Draw();
2390}
2391
2392void CbmRichMCbmQaReal::DrawRichTofEv(const std::vector<int> richHitIndx, const std::vector<int> tofTrackIndx)
2393{
2394 if (richHitIndx.size() < 1 || tofTrackIndx.size() < 1) return;
2395 if (fNofDrawnRichTofEv > 30) return;
2396 fNofDrawnRichTofEv++;
2397 std::string dir = "./" + fOutputDir + "/png/TREv/";
2398 gSystem->mkdir(dir.c_str(), true); // create directory if it does not exist
2399 stringstream ss;
2400 ss << "TREv/TofRichEvent" << fNofDrawnRichTofEv;
2401 TCanvas* c = nullptr;
2402 c = fHM->CreateCanvas(ss.str().c_str(), ss.str().c_str(), 800, 800);
2403 c->SetGrid(true, true);
2404
2405 TH2D* pad = new TH2D(ss.str().c_str(), (ss.str() + ";X [cm];Y [cm]").c_str(), 1, -15., 10., 1, -5., 20);
2406
2407 pad->SetStats(false);
2408 pad->Draw();
2409
2410 //rough Drawing of RichDetectorAcceptance
2411 TLine* line0 = new TLine(-6.25, 8, -6.25, 15.9);
2412 line0->Draw();
2413 TLine* line1 = new TLine(-6.25, 15.9, -1.05, 15.9);
2414 line1->Draw();
2415 TLine* line2 = new TLine(-1.05, 15.9, -1.05, 13.2);
2416 line2->Draw();
2417 TLine* line3 = new TLine(-1.05, 13.2, +4.25, 13.2);
2418 line3->Draw();
2419 TLine* line4 = new TLine(4.25, 13.2, +4.25, 8);
2420 line4->Draw();
2421 TLine* line5 = new TLine(4.25, 8, -6.25, 8);
2422 line5->Draw();
2423
2424 int nofDrawHits = 0;
2425 double hitZ = 0.;
2426
2427 for (unsigned int i = 0; i < richHitIndx.size(); i++) {
2428 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(richHitIndx[i]);
2429 if (nullptr == hit) continue;
2430 TEllipse* hitDr = new TEllipse(hit->GetX(), hit->GetY(), .25);
2431 if (doToT(hit)) { // Good ToT selection
2432 hitDr->SetFillColor(kRed);
2433 }
2434 else {
2435 hitDr->SetFillColor(kBlue);
2436 }
2437 hitZ += hit->GetZ();
2438 nofDrawHits++;
2439 hitDr->Draw();
2440 }
2441 if (nofDrawHits != 0) {
2442 hitZ /= nofDrawHits;
2443 }
2444 else {
2445 hitZ = RichZPos;
2446 }
2447
2448 stringstream ss2;
2449
2450 for (unsigned int i = 0; i < tofTrackIndx.size(); i++) {
2451 CbmTofTracklet* track = (CbmTofTracklet*) fTofTracks->At(tofTrackIndx[i]);
2452 if (track == nullptr) continue;
2453 TEllipse* trDr = new TEllipse(track->GetFitX(hitZ), track->GetFitY(hitZ), .25);
2454 trDr->SetFillColor(kGreen);
2455 trDr->Draw();
2456
2457 ss2 << "\\beta: " << getBeta(track);
2458 }
2459
2460 TLatex* latex = new TLatex(-4., 4., ss2.str().c_str());
2461
2462 latex->Draw();
2463}
2464
2465
2466void CbmRichMCbmQaReal::Finish()
2467{
2468 //std::cout<<"Tracks: "<< fTofTracks->GetEntriesFast() <<std::endl;
2469 std::cout << "Drawing Hists...";
2470 DrawHist();
2471 std::cout << "DONE!" << std::endl;
2472
2473 if (this->fDoDrawCanvas) {
2474 fHM->SaveCanvasToImage(fOutputDir, "png");
2475 std::cout << "Canvas saved to Images!" << std::endl;
2476 }
2477
2478 if (this->fDoWriteHistToFile) {
2480 TFile* oldFile = gFile;
2481 TDirectory* oldir = gDirectory;
2482
2483 std::string s = fOutputDir + "/RecoHists.root";
2484 TFile* outFile = new TFile(s.c_str(), "RECREATE");
2485 if (outFile->IsOpen()) {
2486 fHM->WriteToFile();
2487 std::cout << "Written to Root-file \"" << s << "\" ...";
2488 outFile->Close();
2489 std::cout << "Done!" << std::endl;
2490 }
2492 gFile = oldFile;
2493 gDirectory->cd(oldir->GetPath());
2494 }
2495
2496 std::cout << "fTracksinRich: " << fTracksinRich << std::endl;
2497 Double_t result = (static_cast<Double_t>(fTracksinRichWithRichHits[0]) / static_cast<Double_t>(fTracksinRich)) * 100.;
2498 std::cout << "fTracksinRichWithRichHits > 0: " << fTracksinRichWithRichHits[0] << "\t Percent: " << result << "%"
2499 << std::endl;
2500 result = (static_cast<Double_t>(fTracksinRichWithRichHits[1]) / static_cast<Double_t>(fTracksinRich)) * 100.;
2501 std::cout << "fTracksinRichWithRichHits > 5: " << fTracksinRichWithRichHits[1] << "\t Percent: " << result << "%"
2502 << std::endl;
2503 result = (static_cast<Double_t>(fTracksinRichWithRichHits[2]) / static_cast<Double_t>(fTracksinRich)) * 100.;
2504 std::cout << "fTracksinRichWithRichHits > 10: " << fTracksinRichWithRichHits[2] << "\t Percent: " << result << "%"
2505 << std::endl;
2506 result = (static_cast<Double_t>(fTracksinRichWithRichHits[3]) / static_cast<Double_t>(fTracksinRich)) * 100.;
2507 std::cout << "fTracksinRichWithRichHits > 15: " << fTracksinRichWithRichHits[3] << "\t Percent: " << result << "%"
2508 << std::endl;
2509
2510
2511 std::cout << "RingsWithTrack: " << fRingsWithTrack[0] << " Rings: " << fRingsWithTrack[1]
2512 << " Tracks: " << fRingsWithTrack[2] << std::endl;
2513 std::cout << "\t \t Rings Cutted: " << fRingsWithTrack[3] << " Tracks Cutted: " << fRingsWithTrack[4]
2514 << " Possible Combinations: " << fRingsWithTrack[5] << std::endl;
2515}
2516
2517
2518void CbmRichMCbmQaReal::DrawFromFile(const string& fileName, const string& outputDir)
2519{
2520 fOutputDir = outputDir;
2521
2523 TFile* oldFile = gFile;
2524 TDirectory* oldDir = gDirectory;
2525
2526 if (fHM != nullptr) delete fHM;
2527
2528 fHM = new CbmHistManager();
2529 TFile* file = new TFile(fileName.c_str());
2530 fHM->ReadFromFile(file);
2531 DrawHist();
2532
2533 fHM->SaveCanvasToImage(fOutputDir);
2534
2536 gFile = oldFile;
2537 gDirectory = oldDir;
2538}
2539
2540bool CbmRichMCbmQaReal::isAccmRICH(CbmTofTracklet* track)
2541{
2542 //check if Track is in mRICH acceptance
2543
2544 bool inside = false;
2545 if (!fRestrictToAcc) return true;
2546 double x = track->GetFitX(RichZPos);
2547 double y = track->GetFitY(RichZPos);
2548 if (x >= -6.25 && x <= -1.05) {
2549 // left part of mRICH
2550 if (y > 8 && y < 15.9) {
2551 inside = true;
2552 }
2553 }
2554 else if (x > -1.05 && x < 4.25) {
2555 //right part
2556 if (y > 8 && y < 13.2) {
2557 inside = true;
2558 }
2559 }
2560
2561 return inside;
2562}
2563
2564
2565Double_t CbmRichMCbmQaReal::getBeta(CbmTofTracklet* track)
2566{
2567 Double_t inVel = 1e7 / (track->GetTt()); // in m/s
2568 Double_t beta = inVel / TMath::C();
2569
2570 return beta;
2571}
2572
2573Double_t CbmRichMCbmQaReal::getBeta(const CbmRichRing* ring)
2574{
2575
2576 // calculate distance of ring center to penetration point in aerogel with assumption,
2577 // that particle is from target.
2578 // INFO: use center of Aerogel as reference -> 11.5cm to MAPMT (TODO: get this from GEO-File)
2579 const Double_t Aerogel_Dist = 11.5;
2580 const Double_t aeroPenetr_Y = ring->GetCenterY() * (1. - Aerogel_Dist / (RichZPos));
2581 const Double_t aeroPenetr_X = ring->GetCenterX() * (1. - Aerogel_Dist / (RichZPos));
2582
2583 const Double_t dist = std::sqrt((ring->GetCenterX() - aeroPenetr_X) * (ring->GetCenterX() - aeroPenetr_X)
2584 + (ring->GetCenterY() - aeroPenetr_Y) * (ring->GetCenterY() - aeroPenetr_Y)
2585 + Aerogel_Dist * Aerogel_Dist);
2586
2587 const Double_t ioR = 1.05; // Index of Reflection
2588
2589 Double_t beta = std::sqrt((((ring->GetRadius() * ring->GetRadius()) / dist * dist) + 1) / (ioR * ioR));
2590
2591 //std::cout<<" beta:"<<beta<<std::endl;
2592
2593 return beta;
2594}
2595
2596bool CbmRichMCbmQaReal::RestrictToFullAcc(CbmTofTracklet* track)
2597{
2598 //check if Track is in mRICH acceptance
2599
2600 double x = track->GetFitX(RichZPos);
2601 double y = track->GetFitY(RichZPos);
2602 return this->RestrictToFullAcc(x, y);
2603}
2604
2605bool CbmRichMCbmQaReal::RestrictToFullAcc(TVector3& pos)
2606{
2607 Double_t x = pos.X();
2608 Double_t y = pos.Y();
2609
2610 return this->RestrictToFullAcc(x, y);
2611}
2612
2613bool CbmRichMCbmQaReal::RestrictToFullAcc(Double_t x, Double_t y)
2614{ //check if Track is in mRICH acceptance
2615 if (fRestrictToFullAcc == false) return true;
2616 bool inside = false;
2617 if (x >= -16.85 && x <= 4.25) { //TODO:check values
2618 // left part of mRICH
2619 if (y >= -23.8 && y <= 23.8) {
2620 inside = true;
2621 }
2622 }
2623
2624 return inside;
2625}
2626
2627void CbmRichMCbmQaReal::analyseRing(const CbmRichRing* ring, CbmEvent* ev, std::pair<int, double>& clTrack)
2628{
2629
2630 //std::cout<<"analyse a Ring"<<std::endl;
2631
2632 Double_t meanTime = 0.;
2633 unsigned int hitCnt = 0;
2634 Double_t minRHit2 = std::numeric_limits<Double_t>::max();
2635 for (int i = 0; i < ring->GetNofHits(); i++) {
2636 Int_t hitInd = ring->GetHit(i);
2637 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
2638 if (nullptr == hit) continue;
2639
2640 meanTime += hit->GetTime();
2641 hitCnt++;
2642
2643 const Float_t diffX = hit->GetX() - ring->GetCenterX();
2644 const Float_t diffY = hit->GetY() - ring->GetCenterY();
2645 const Float_t tmpHitRadius2 = (diffX * diffX + diffY * diffY);
2646
2647 if (tmpHitRadius2 < minRHit2) {
2648 minRHit2 = tmpHitRadius2;
2649 }
2650 }
2651 meanTime = meanTime / hitCnt;
2652
2653 //std::cout<<"mean: "<<meanTime<<std::endl;
2654 for (int i = 0; i < ring->GetNofHits(); i++) {
2655 Int_t hitInd = ring->GetHit(i);
2656 CbmRichHit* hit = (CbmRichHit*) fRichHits->At(hitInd);
2657 if (nullptr == hit) continue;
2658 //std::cout<<"DeltatTime: "<< meanTime - hit->GetTime()<<std::endl;
2659 //fHM->H1("fhRingDeltaTime")->Fill(static_cast<Double_t>(meanTime - hit->GetTime()));
2660
2661 fHM->H1("fhRingToTs")->Fill(hit->GetToT());
2662 fHM->H1("fhRingLE")->Fill(static_cast<Double_t>(hit->GetTime() - ev->GetStartTime()));
2663 fHM->H2("fhRingLEvsToT")->Fill(static_cast<Double_t>(hit->GetTime() - ev->GetStartTime()), hit->GetToT());
2664 //std::vector<int> tmpRingIndx;
2665 //tmpRingIndx.push_back(ring->GetIndex);
2666 const Double_t Tdiff_ring = (hit->GetTime() - ev->GetStartTime());
2667 if ((Tdiff_ring > 20.) && (Tdiff_ring < 30.)) {
2668 // std::cout<<ev->GetNumber()<<" Address_ring: "<<std::hex<< CbmRichUtil::GetDirichId(hit->GetAddress())<<std::dec<<" "<< CbmRichUtil::GetDirichChannel(hit->GetAddress()) <<" "<< hit->GetToT()<<" "<<ring->GetRadius()<<std::endl;
2669 //fHM->H1("fhDiRICHsInRegion")->Fill(CbmRichUtil::GetDirichId(hit->GetAddress()));
2670 }
2671
2672 if (clTrack.first == -1)
2673 fHM->H1("fhRingNoClTrackLE")->Fill(static_cast<Double_t>(hit->GetTime() - ev->GetStartTime()));
2674 if ((clTrack.first >= 0) && !(clTrack.second < 10.))
2675 fHM->H1("fhRingClTrackFarAwayLE")->Fill(static_cast<Double_t>(hit->GetTime() - ev->GetStartTime()));
2676 if (cutDistance(clTrack) && cutRadius(ring)) { //Good Ring
2677 fHM->H1("fhGoodRingLE")->Fill(static_cast<Double_t>(hit->GetTime() - ev->GetStartTime()));
2678 fHM->H1("fhRingDeltaTime")->Fill(static_cast<Double_t>(meanTime - hit->GetTime()));
2679 }
2680 }
2681
2682 int InnerHitCnt = 0;
2683 int InnerHitCnt_cut = 0;
2684 for (size_t j = 0; j < ev->GetNofData(ECbmDataType::kRichHit); j++) {
2685 auto iRichHit = ev->GetIndex(ECbmDataType::kRichHit, j);
2686 CbmRichHit* richHit = static_cast<CbmRichHit*>(fRichHits->At(iRichHit));
2687 if (nullptr == richHit) continue;
2688 const Float_t diffX = richHit->GetX() - ring->GetCenterX();
2689 const Float_t diffY = richHit->GetY() - ring->GetCenterY();
2690 //select inner Part of Ring
2691 if (diffX * diffX + diffY * diffY < minRHit2) {
2692 InnerHitCnt++;
2693 const Double_t Tdiff_inner = (richHit->GetTime() - ev->GetStartTime());
2694 if ((Tdiff_inner > 20.) && (Tdiff_inner < 30.)) {
2695 InnerHitCnt_cut++;
2696 //if (InnerHitCnt_cut == 1) {DrawRing(ring);}
2697 //std::cout<<ev->GetNumber()<<" Address_inner: "<<std::hex<< CbmRichUtil::GetDirichId(richHit->GetAddress())<<std::dec<<" "<< CbmRichUtil::GetDirichChannel(richHit->GetAddress()) <<" "<< richHit->GetToT()<<" "<<ring->GetRadius()<<std::endl;
2698 fHM->H1("fhDiRICHsInRegion")->Fill(CbmRichUtil::GetDirichId(richHit->GetAddress()));
2699 }
2700
2701 fHM->H1("fhInnerRingDeltaTime")->Fill(static_cast<Double_t>(meanTime - richHit->GetTime()));
2702 fHM->H1("fhInnerRingToTs")->Fill(richHit->GetToT());
2703 fHM->H1("fhInnerRingLE")->Fill(static_cast<Double_t>(richHit->GetTime() - ev->GetStartTime()));
2704 if (clTrack.first == -1)
2705 fHM->H1("fhInnerRingNoClTrackLE")->Fill(static_cast<Double_t>(richHit->GetTime() - ev->GetStartTime()));
2706 if ((clTrack.first >= 0) && !(clTrack.second < 5.))
2707 fHM->H1("fhInnerRingClTrackFarAwayLE")->Fill(static_cast<Double_t>(richHit->GetTime() - ev->GetStartTime()));
2708 if (cutDistance(clTrack) && cutRadius(ring)) { //Good Ring
2709 fHM->H1("fhInnerGoodRingLE")->Fill(static_cast<Double_t>(richHit->GetTime() - ev->GetStartTime()));
2710 }
2711 }
2712 }
2713 if (InnerHitCnt == 0) {
2714 fHM->H1("fhInnerRingFlag")->Fill(1);
2715 }
2716 else {
2717 fHM->H1("fhInnerRingFlag")->Fill(0);
2718 }
2719 fHM->H1("fhNofInnerHits")->Fill(InnerHitCnt);
2720}
2721
2722
2723Bool_t CbmRichMCbmQaReal::cutRadius(const CbmRichRing* ring)
2724{
2725 if (ring->GetRadius() > 2. && ring->GetRadius() < 4.2) return true;
2726
2727 return false;
2728}
2729
2730
2731Bool_t CbmRichMCbmQaReal::cutDistance(std::pair<int, double>& clTrack)
2732{
2733 if ((clTrack.first >= 0) && (clTrack.second < 10.)) return true;
2734
2735 return false;
2736}
2737
2738
2739TVector3 CbmRichMCbmQaReal::extrapolate(CbmTofHit* tofHit, Double_t Z)
2740{
2741 TVector3 extVec(0, 0, 0);
2742 TVector3 vertex(0, 0, 0);
2743 Double_t factor = (Z - vertex.Z()) / (tofHit->GetZ() - vertex.Z());
2744 Double_t x = vertex.X() + factor * (tofHit->GetX() - vertex.X());
2745 Double_t y = vertex.Y() + factor * (tofHit->GetY() - vertex.Y());
2746 extVec.SetXYZ(x, y, Z);
2747
2748 return extVec;
2749}
2750
2751ClassImp(CbmRichMCbmQaReal)
rings
TClonesArray * rings
Definition Analyze_matching.h:25
ClassImp
ClassImp(CbmConverterManager)
ECbmModuleId::kTrd
@ kTrd
Transition Radiation Detector.
ECbmModuleId::kTof
@ kTof
Time-of-flight Detector.
ECbmModuleId::kSts
@ kSts
Silicon Tracking System.
ECbmModuleId::kRich
@ kRich
Ring-Imaging Cherenkov Detector.
DrawH1
void DrawH1(TH1 *hist, HistScale logx, HistScale logy, const string &drawOpt, Int_t color, Int_t lineWidth, Int_t lineStyle, Int_t markerSize, Int_t markerStyle)
Definition CbmDrawHist.cxx:54
DrawH2
void DrawH2(TH2 *hist, HistScale logx, HistScale logy, HistScale logz, const string &drawOpt)
Definition CbmDrawHist.cxx:83
CbmDrawHist.h
Helper functions for drawing 1D and 2D histograms and graphs.
kLinear
@ kLinear
Definition CbmDrawHist.h:69
kLog
@ kLog
Definition CbmDrawHist.h:68
fTofTracks
TClonesArray * fTofTracks
Definition CbmHadronAnalysis.cxx:60
CbmHistManager.h
Histogram manager.
CbmMatchRecoToMC.h
FairTask for matching RECO data to MC.
CbmRichConverter.h
Convert internal data classes to cbmroot common data classes.
RichZPos
#define RichZPos
Definition CbmRichMCbmAerogelAna.cxx:55
RichZPos
double RichZPos
Definition CbmRichMCbmQaReal.cxx:64
CbmRichRingFinderHoughImpl.h
Ring finder implementation based on Hough Transform method.
first
bool first
Definition LKFMinuit.cxx:149
CbmDigiManager::GetNofDigis
static Int_t GetNofDigis(ECbmModuleId systemId)
Definition CbmDigiManager.cxx:67
CbmDigiManager::IsPresent
static Bool_t IsPresent(ECbmModuleId systemId)
Presence of a digi branch.
Definition CbmDigiManager.cxx:121
CbmDigiManager::Init
InitStatus Init()
Initialisation.
Definition CbmDigiManager.cxx:77
CbmDigiManager::Get
const Digi * Get(Int_t index) const
Get a digi object.
Definition CbmDigiManager.h:57
CbmDigiManager::Instance
static CbmDigiManager * Instance()
Static instance.
Definition CbmDigiManager.h:126
CbmEvent
Class characterising one event by a collection of links (indices) to data objects,...
Definition CbmEvent.h:34
CbmEvent::GetNofData
size_t GetNofData() const
Definition CbmEvent.cxx:58
CbmEvent::GetStartTime
double GetStartTime() const
Definition CbmEvent.h:140
CbmEvent::GetIndex
uint32_t GetIndex(ECbmDataType type, uint32_t iData) const
Definition CbmEvent.cxx:42
CbmHistManager
Histogram manager.
Definition CbmHistManager.h:48
CbmHistManager::CreateCanvas
TCanvas * CreateCanvas(const std::string &name, const std::string &title, Int_t width, Int_t height)
Create and draw TCanvas and store pointer to it.
Definition core/base/CbmHistManager.cxx:303
CbmHistManager::SaveCanvasToImage
void SaveCanvasToImage(const std::string &outputDir, const std::string &options="png,eps")
Save all stored canvases to images.
Definition core/base/CbmHistManager.cxx:310
CbmHistManager::H2
TH2 * H2(const std::string &name) const
Return pointer to TH2 histogram.
Definition CbmHistManager.h:243
CbmHistManager::Create2
void Create2(const std::string &name, const std::string &title, Int_t nofBinsX, Double_t minBinX, Double_t maxBinX, Int_t nofBinsY, Double_t minBinY, Double_t maxBinY)
Helper function for creation of 2-dimensional histograms and profiles. Template argument is a real ob...
Definition CbmHistManager.h:123
CbmHistManager::ReadFromFile
void ReadFromFile(TFile *file)
Read histograms from file.
Definition core/base/CbmHistManager.cxx:131
CbmHistManager::ScaleByPattern
void ScaleByPattern(const std::string &pattern, Double_t scale)
Scale histograms which name matches specified pattern.
Definition core/base/CbmHistManager.cxx:251
CbmHistManager::WriteToFile
void WriteToFile()
Write all objects to current opened file.
Definition core/base/CbmHistManager.cxx:116
CbmHistManager::H3
TH3 * H3(const std::string &name) const
Return pointer to TH3 histogram.
Definition CbmHistManager.h:278
CbmHistManager::Create1
void Create1(const std::string &name, const std::string &title, Int_t nofBins, Double_t minBin, Double_t maxBin)
Helper function for creation of 1-dimensional histograms and profiles. Template argument is a real ob...
Definition CbmHistManager.h:88
CbmHistManager::Create3
void Create3(const std::string &name, const std::string &title, Int_t nofBinsX, Double_t minBinX, Double_t maxBinX, Int_t nofBinsY, Double_t minBinY, Double_t maxBinY, Int_t nofBinsZ, Double_t minBinZ, Double_t maxBinZ)
Helper function for creation of 3-dimensional histograms and profiles. Template argument is a real ob...
Definition CbmHistManager.h:164
CbmHistManager::H1
TH1 * H1(const std::string &name) const
Return pointer to TH1 histogram.
Definition CbmHistManager.h:207
CbmHit::GetTime
double GetTime() const
Definition CbmHit.h:76
CbmHit::GetAddress
int32_t GetAddress() const
Definition CbmHit.h:74
CbmHit::GetZ
double GetZ() const
Definition CbmHit.h:71
CbmPixelHit::GetY
double GetY() const
Definition CbmPixelHit.h:74
CbmPixelHit::GetX
double GetX() const
Definition CbmPixelHit.h:73
CbmRichDigi::GetToT
double GetToT() const
Definition CbmRichDigi.h:78
CbmRichDigi::GetTime
double GetTime() const
Definition CbmRichDigi.h:72
CbmRichHit::GetToT
double GetToT() const
Definition CbmRichHit.h:67
CbmRichMCbmQaReal::isAccmRICH
bool isAccmRICH(CbmTofTracklet *track)
Definition CbmRichMCbmQaReal.cxx:2540
CbmRichMCbmQaReal::fBmonDigis
const std::vector< CbmTofDigi > * fBmonDigis
Definition CbmRichMCbmQaReal.h:145
CbmRichMCbmQaReal::Finish
virtual void Finish()
Inherited from FairTask.
Definition CbmRichMCbmQaReal.cxx:2466
CbmRichMCbmQaReal::fTracksinRichWithRichHits
Int_t fTracksinRichWithRichHits[4]
Definition CbmRichMCbmQaReal.h:185
CbmRichMCbmQaReal::RestrictToFullAcc
bool RestrictToFullAcc(CbmTofTracklet *track)
Definition CbmRichMCbmQaReal.cxx:2596
CbmRichMCbmQaReal::cutDistance
Bool_t cutDistance(std::pair< int, double > &clTrack)
Definition CbmRichMCbmQaReal.cxx:2731
CbmRichMCbmQaReal::getBeta
Double_t getBeta(CbmTofTracklet *track)
Definition CbmRichMCbmQaReal.cxx:2565
CbmRichMCbmQaReal::fTofHits
TClonesArray * fTofHits
Definition CbmRichMCbmQaReal.h:151
CbmRichMCbmQaReal::FindClosestTrack
std::pair< int, double > FindClosestTrack(const CbmRichRing *ring, const std::vector< CbmTofTracklet * > track)
Definition CbmRichMCbmQaReal.cxx:1308
CbmRichMCbmQaReal::DrawRichTofEv
void DrawRichTofEv(const std::vector< int > richHitIndx, const std::vector< int > tofTrackIndx)
Definition CbmRichMCbmQaReal.cxx:2392
CbmRichMCbmQaReal::fDigiMan
CbmDigiManager * fDigiMan
Definition CbmRichMCbmQaReal.h:142
CbmRichMCbmQaReal::DrawFromFile
void DrawFromFile(const string &fileName, const string &outputDir)
Draw histogram from file.
Definition CbmRichMCbmQaReal.cxx:2518
CbmRichMCbmQaReal::Exec
virtual void Exec(Option_t *option)
Inherited from FairTask.
Definition CbmRichMCbmQaReal.cxx:567
CbmRichMCbmQaReal::DrawHist
void DrawHist()
Draw histograms.
Definition CbmRichMCbmQaReal.cxx:1395
CbmRichMCbmQaReal::InitHistograms
void InitHistograms()
Initialize histograms.
Definition CbmRichMCbmQaReal.cxx:176
CbmRichMCbmQaReal::fRichRings
TClonesArray * fRichRings
Definition CbmRichMCbmQaReal.h:149
CbmRichMCbmQaReal::fHM
CbmHistManager * fHM
Definition CbmRichMCbmQaReal.h:160
CbmRichMCbmQaReal::CbmRichMCbmQaReal
CbmRichMCbmQaReal()
Standard constructor.
Definition CbmRichMCbmQaReal.cxx:66
CbmRichMCbmQaReal::fRichHits
TClonesArray * fRichHits
Definition CbmRichMCbmQaReal.h:147
CbmRichMCbmQaReal::fTSHeader
const CbmTsEventHeader * fTSHeader
Definition CbmRichMCbmQaReal.h:155
CbmRichMCbmQaReal::extrapolate
TVector3 extrapolate(CbmTofHit *tofHit, Double_t Z)
Definition CbmRichMCbmQaReal.cxx:2739
CbmRichMCbmQaReal::fSeDisplay
CbmRichMCbmSEDisplay * fSeDisplay
Definition CbmRichMCbmQaReal.h:216
CbmRichMCbmQaReal::fTofTracks
TClonesArray * fTofTracks
Definition CbmRichMCbmQaReal.h:153
CbmRichMCbmQaReal::FindClosestRing
std::pair< int, double > FindClosestRing(CbmTofTracklet *track, std::vector< int > &ringIndx)
Definition CbmRichMCbmQaReal.cxx:1350
CbmRichMCbmQaReal::fCbmEvent
TClonesArray * fCbmEvent
Definition CbmRichMCbmQaReal.h:157
CbmRichMCbmQaReal::analyseRing
void analyseRing(const CbmRichRing *ring, CbmEvent *ev, std::pair< int, double > &clTrack)
Definition CbmRichMCbmQaReal.cxx:2627
CbmRichMCbmQaReal::fSeDsply_TR
CbmRichMCbmSEDisplay * fSeDsply_TR
Definition CbmRichMCbmQaReal.h:218
CbmRichMCbmQaReal::isOnTarget
bool isOnTarget(CbmTofTracklet *tTrack)
Definition CbmRichMCbmQaReal.h:132
CbmRichMCbmQaReal::DrawRing
void DrawRing(CbmRichRing *ring)
Definition CbmRichMCbmQaReal.cxx:2237
CbmRichMCbmQaReal::cutRadius
Bool_t cutRadius(const CbmRichRing *ring)
Definition CbmRichMCbmQaReal.cxx:2723
CbmRichMCbmQaReal::Init
virtual InitStatus Init()
Inherited from FairTask.
Definition CbmRichMCbmQaReal.cxx:89
CbmRichMCbmSEDisplay::SetOutDir
void SetOutDir(std::string dir)
Definition CbmRichMCbmSEDisplay.h:99
CbmRichMCbmSEDisplay::DrawEvent
void DrawEvent(CbmEvent *ev, std::vector< int > &ringIndx, bool full)
Draw histograms.
Definition CbmRichMCbmSEDisplay.cxx:58
CbmRichMCbmSEDisplay::SetRichRings
void SetRichRings(TClonesArray *ring=nullptr)
Definition CbmRichMCbmSEDisplay.h:77
CbmRichMCbmSEDisplay::SetMaxNofDrawnEvents
void SetMaxNofDrawnEvents(Int_t val=100)
Definition CbmRichMCbmSEDisplay.h:87
CbmRichMCbmSEDisplay::SetCanvasDir
void SetCanvasDir(std::string dir)
Definition CbmRichMCbmSEDisplay.h:105
CbmRichMCbmSEDisplay::SetTofTracks
void SetTofTracks(TClonesArray *track=nullptr)
Definition CbmRichMCbmSEDisplay.h:82
CbmRichMCbmSEDisplay::SetRichHits
void SetRichHits(TClonesArray *hits=nullptr)
Definition CbmRichMCbmSEDisplay.h:72
CbmRichMCbmSEDisplay::SetTotRich
void SetTotRich(Double_t min, Double_t max)
Definition CbmRichMCbmSEDisplay.h:54
CbmRichMCbmSEDisplay::SetLELimits
void SetLELimits(Double_t min, Double_t max)
Definition CbmRichMCbmSEDisplay.h:63
CbmRichMCbmSEDisplay::XOffsetHistos
void XOffsetHistos(Double_t val=0.)
Definition CbmRichMCbmSEDisplay.h:49
CbmRichRing::GetHit
uint32_t GetHit(int32_t i) const
Definition CbmRichRing.h:39
CbmRichRing::GetRadius
float GetRadius() const
Definition CbmRichRing.h:79
CbmRichRing::GetTime
double GetTime() const
Definition CbmRichRing.h:99
CbmRichRing::GetNofHits
int32_t GetNofHits() const
Definition CbmRichRing.h:37
CbmRichRing::GetCenterX
float GetCenterX() const
Definition CbmRichRing.h:77
CbmRichRing::GetChi2
double GetChi2() const
Definition CbmRichRing.h:92
CbmRichRing::GetCenterY
float GetCenterY() const
Definition CbmRichRing.h:78
CbmRichUtil::GetDirichId
static uint16_t GetDirichId(int Address)
Definition CbmRichUtil.h:31
CbmStsDigi
Data class for a single-channel message in the STS.
Definition CbmStsDigi.h:40
CbmTofDigi
Data class for expanded digital TOF information.
Definition CbmTofDigi.h:47
CbmTofDigi::GetTime
double GetTime() const
Inherited from CbmDigi.
Definition CbmTofDigi.h:131
CbmTofTracklet
Provides information on attaching a TofHit to a TofTrack.
Definition CbmTofTracklet.h:30
CbmTofTracklet::GetFitY
double GetFitY(double Z)
Definition CbmTofTracklet.cxx:505
CbmTofTracklet::GetTt
double GetTt() const
Definition CbmTofTracklet.h:59
CbmTofTracklet::GetNofHits
int32_t GetNofHits() const
Definition CbmTofTracklet.h:53
CbmTofTracklet::GetTime
double GetTime() const
Definition CbmTofTracklet.h:108
CbmTofTracklet::GetFitX
double GetFitX(double Z)
Definition CbmTofTracklet.cxx:503
CbmTrdDigi::GetType
eCbmTrdAsicType GetType() const
Channel FEE SPADIC/FASP according to CbmTrdAsicType.
Definition CbmTrdDigi.h:173
CbmTrdDigi::GetTime
double GetTime() const
Getter for physical time [ns]. Accounts for clock representation of each ASIC. In SPADIC case physica...
Definition CbmTrdDigi.h:153
CbmTsEventHeader::GetTsStartTime
uint64_t GetTsStartTime() const
Definition CbmTsEventHeader.h:63
std
Hash for CbmL1LinkKey.
Definition algo/base/Options.cxx:21