CbmRoot
CbmTofGeometryQa.cxx
Go to the documentation of this file.
1 
6 #include "CbmTofGeometryQa.h"
7 
8 // TOF Classes and includes
9 #include "CbmTofAddress.h" // in cbmdata/tof
10 #include "CbmTofCell.h" // in tof/TofData
11 #include "CbmTofDetectorId_v12b.h" // in cbmdata/tof
12 #include "CbmTofDetectorId_v14a.h" // in cbmdata/tof
13 #include "CbmTofGeoHandler.h" // in tof/TofTools
14 #include "CbmTofPoint.h" // in cbmdata/tof
15 
16 // CBMroot classes and includes
17 #include "CbmMCTrack.h"
18 #include "CbmMatch.h"
19 
20 // FAIR classes and includes
21 #include "FairLogger.h"
22 #include "FairMCEventHeader.h"
23 #include "FairRootManager.h"
24 #include "FairRunAna.h"
25 #include "FairRuntimeDb.h"
26 
27 // ROOT Classes and includes
28 #include "Riostream.h"
29 #include "TClonesArray.h"
30 #include "TFile.h"
31 #include "TH1.h"
32 #include "TH2.h"
33 #include "TH3.h"
34 #include "TMath.h"
35 #include "TProfile2D.h"
36 #include "TROOT.h"
37 #include "TRandom.h"
38 #include "TString.h"
39 
40 using std::cout;
41 using std::endl;
42 
43 //___________________________________________________________________
44 // Constants definitions: Particles list
45 const Int_t kiNbPart = 13;
46 const TString ksPartTag[kiNbPart] = {"others",
47  "ep",
48  "em",
49  "pip",
50  "pim",
51  "kp",
52  "km",
53  "p",
54  "pbar",
55  "d",
56  "t",
57  "he",
58  "a"};
59 const Int_t kiPartPdgCode[kiNbPart] = {0,
60  11,
61  -11,
62  211,
63  -211,
64  321,
65  -321,
66  2212,
67  -2212,
68  1000010020,
69  1000010030,
70  1000020030,
71  1000020040};
72 const TString ksPartName[kiNbPart] = {"any other part.",
73  "e+",
74  "e-",
75  "#pi+",
76  "#pi-",
77  "k+",
78  "k-",
79  "p",
80  "anti-p",
81  "d",
82  "t",
83  "he",
84  "#alpha"};
85 const Int_t kiMinNbStsPntAcc =
86  3; // Number of STS Pnt for Trk to be reconstructable
87 const Int_t kiMinNbMuchPntAcc =
88  10; // Number of MUCH Pnt for Trk to be reconstructable
89 //___________________________________________________________________
90 
91 
92 //___________________________________________________________________
93 //
94 // CbmTofGeometryQa
95 //
96 // Task for QA of TOF geometry
97 //
98 // ------------------------------------------------------------------
99 CbmTofGeometryQa::CbmTofGeometryQa()
100  : FairTask("CbmTofGeometryQa")
101  , fEvents(0)
102  , fGeoHandler(new CbmTofGeoHandler())
103  , fTofId(NULL)
104  , fChannelInfo(NULL)
105  , iNbSmTot(0)
106  , fvTypeSmOffs()
107  , iNbRpcTot(0)
108  , fvSmRpcOffs()
109  , fiNbChTot(0)
110  , fvRpcChOffs()
111  , fMCEventHeader(NULL)
112  , fTofPointsColl(NULL)
113  , fMcTracksColl(NULL)
114  , fRealTofPointsColl(NULL)
115  , fRealTofMatchColl(NULL)
116  , fbRealPointAvail(kFALSE)
117  , fsHistoOutFilename("./tofQa.hst.root")
118  , fdWallPosZ(1000)
119  , fbCentDepOn(kFALSE)
120  , fvhTrackAllStartZCent()
121  , // Beam pipe check
122  fvhTrackSecStartZCent()
123  , // Beam pipe check
124  fvhTrackAllStartXZCent()
125  , // Beam pipe check
126  fvhTofPntAllAngCent()
127  , // Beam pipe check
128  fvhTrackAllStartXZ()
129  , // Beam pipe check
130  fvhTrackAllStartYZ()
131  , // Beam pipe check
132  fhTrackMapXY(NULL)
133  , // Only when creating normalization histos
134  fhTrackMapXZ(NULL)
135  , // Only when creating normalization histos
136  fhTrackMapYZ(NULL)
137  , // Only when creating normalization histos
138  fhTrackMapAng(NULL)
139  , // Only when creating normalization histos
140  fhTrackMapSph(NULL)
141  , // Only when creating normalization histos
142  fhTrackMapAngPrimAll(NULL)
143  , // For angular acceptance study
144  fhTrackMapAngPrimSts(NULL)
145  , // For angular acceptance study
146  fhTrackMapAngPrimRich(NULL)
147  , // For angular acceptance study
148  fhTrackMapAngPrimMuch(NULL)
149  , // For angular acceptance study
150  fhTrackMapAngPrimTrd(NULL)
151  , // For angular acceptance study
152  fhTrackMapAngPrimTof(NULL)
153  , // For angular acceptance study
154  fhPointMapXY(NULL)
155  , fhPointMapXZ(NULL)
156  , fhPointMapYZ(NULL)
157  , fhPointMapAng(NULL)
158  , fhPointMapSph(NULL)
159  , fhRealPointMapXY(NULL)
160  , fhRealPointMapXZ(NULL)
161  , fhRealPointMapYZ(NULL)
162  , fhRealPointMapAng(NULL)
163  , fhRealPointMapSph(NULL)
164  , fhPointMapAngWithSts(NULL)
165  , fhPointMapAngWithRich(NULL)
166  , fhPointMapAngWithMuch(NULL)
167  , fhPointMapAngWithTrd(NULL)
168  , fbSphAppOn(kFALSE)
169  , fhPointSphAprRadiusErrMapXY(NULL)
170  , fhPointSphAprRadiusErrMapXZ(NULL)
171  , fhPointSphAprRadiusErrMapYZ(NULL)
172  , fhPointSphAprRadiusErrMapAng(NULL)
173  , fhPointSphAprRadiusErrMapSph(NULL)
174  , fhPointSphAprZposErrMapXY(NULL)
175  , fhPointSphAprZposErrMapXZ(NULL)
176  , fhPointSphAprZposErrMapYZ(NULL)
177  , fhPointSphAprZposErrMapAng(NULL)
178  , fhPointSphAprZposErrMapSph(NULL)
179  , fvhPtmRapGenTrk()
180  , fvhPtmRapStsPnt()
181  , fvhPtmRapTofPnt()
182  , fvhPtmRapSecGenTrk()
183  , fvhPtmRapSecStsPnt()
184  , fvhPtmRapSecTofPnt()
185  , fvhPlabGenTrk()
186  , fvhPlabStsPnt()
187  , fvhPlabTofPnt()
188  , fvhPlabSecGenTrk()
189  , fvhPlabSecStsPnt()
190  , fvhPlabSecTofPnt()
191  , fvhPtmRapGenTrkTofPnt()
192  , fvhPlabGenTrkTofPnt()
193  , fvhPlabStsTrkTofPnt()
194  , fvhPtmRapSecGenTrkTofPnt()
195  , fvhPlabSecGenTrkTofPnt()
196  , fvhPlabSecStsTrkTofPnt() {
197  cout << "CbmTofGeometryQa: Task started " << endl;
198 }
199 // ------------------------------------------------------------------
200 
201 // ------------------------------------------------------------------
202 CbmTofGeometryQa::CbmTofGeometryQa(const char* name, Int_t verbose)
203  : FairTask(name, verbose)
204  , fEvents(0)
205  , fGeoHandler(new CbmTofGeoHandler())
206  , fTofId(NULL)
207  , fChannelInfo(NULL)
208  , iNbSmTot(0)
209  , fvTypeSmOffs()
210  , iNbRpcTot(0)
211  , fvSmRpcOffs()
212  , fiNbChTot(0)
213  , fvRpcChOffs()
214  , fMCEventHeader(NULL)
215  , fTofPointsColl(NULL)
216  , fMcTracksColl(NULL)
217  , fRealTofPointsColl(NULL)
218  , fRealTofMatchColl(NULL)
219  , fbRealPointAvail(kFALSE)
220  , fsHistoOutFilename("./tofQa.hst.root")
221  , fdWallPosZ(1000)
222  , fbCentDepOn(kFALSE)
223  , fvhTrackAllStartZCent()
224  , // Beam pipe check
225  fvhTrackSecStartZCent()
226  , // Beam pipe check
227  fvhTrackAllStartXZCent()
228  , // Beam pipe check
229  fvhTofPntAllAngCent()
230  , // Beam pipe check
231  fvhTrackAllStartXZ()
232  , // Beam pipe check
233  fvhTrackAllStartYZ()
234  , // Beam pipe check
235  fhTrackMapXY(NULL)
236  , // Only when creating normalization histos
237  fhTrackMapXZ(NULL)
238  , // Only when creating normalization histos
239  fhTrackMapYZ(NULL)
240  , // Only when creating normalization histos
241  fhTrackMapAng(NULL)
242  , // Only when creating normalization histos
243  fhTrackMapSph(NULL)
244  , // Only when creating normalization histos
245  fhTrackMapAngPrimAll(NULL)
246  , // For angular acceptance study
247  fhTrackMapAngPrimSts(NULL)
248  , // For angular acceptance study
249  fhTrackMapAngPrimRich(NULL)
250  , // For angular acceptance study
251  fhTrackMapAngPrimMuch(NULL)
252  , // For angular acceptance study
253  fhTrackMapAngPrimTrd(NULL)
254  , // For angular acceptance study
255  fhTrackMapAngPrimTof(NULL)
256  , // For angular acceptance study
257  fhPointMapXY(NULL)
258  , fhPointMapXZ(NULL)
259  , fhPointMapYZ(NULL)
260  , fhPointMapAng(NULL)
261  , fhPointMapSph(NULL)
262  , fhRealPointMapXY(NULL)
263  , fhRealPointMapXZ(NULL)
264  , fhRealPointMapYZ(NULL)
265  , fhRealPointMapAng(NULL)
266  , fhRealPointMapSph(NULL)
267  , fhPointMapAngWithSts(NULL)
268  , fhPointMapAngWithRich(NULL)
269  , fhPointMapAngWithMuch(NULL)
270  , fhPointMapAngWithTrd(NULL)
271  , fbSphAppOn(kFALSE)
272  , fhPointSphAprRadiusErrMapXY(NULL)
273  , fhPointSphAprRadiusErrMapXZ(NULL)
274  , fhPointSphAprRadiusErrMapYZ(NULL)
275  , fhPointSphAprRadiusErrMapAng(NULL)
276  , fhPointSphAprRadiusErrMapSph(NULL)
277  , fhPointSphAprZposErrMapXY(NULL)
278  , fhPointSphAprZposErrMapXZ(NULL)
279  , fhPointSphAprZposErrMapYZ(NULL)
280  , fhPointSphAprZposErrMapAng(NULL)
281  , fhPointSphAprZposErrMapSph(NULL)
282  , fvhPtmRapGenTrk()
283  , fvhPtmRapStsPnt()
284  , fvhPtmRapTofPnt()
285  , fvhPtmRapSecGenTrk()
286  , fvhPtmRapSecStsPnt()
287  , fvhPtmRapSecTofPnt()
288  , fvhPlabGenTrk()
289  , fvhPlabStsPnt()
290  , fvhPlabTofPnt()
291  , fvhPlabSecGenTrk()
292  , fvhPlabSecStsPnt()
293  , fvhPlabSecTofPnt()
294  , fvhPtmRapGenTrkTofPnt()
295  , fvhPlabGenTrkTofPnt()
296  , fvhPlabStsTrkTofPnt()
297  , fvhPtmRapSecGenTrkTofPnt()
298  , fvhPlabSecGenTrkTofPnt()
299  , fvhPlabSecStsTrkTofPnt() {}
300 // ------------------------------------------------------------------
301 
302 // ------------------------------------------------------------------
303 CbmTofGeometryQa::~CbmTofGeometryQa() {
304  // Destructor
305 }
306 // ------------------------------------------------------------------
307 /************************************************************************************/
308 // FairTasks inherited functions
309 InitStatus CbmTofGeometryQa::Init() {
310  if (kFALSE == RegisterInputs()) return kFATAL;
311 
312  // Initialize the TOF GeoHandler
313  Bool_t isSimulation = kFALSE;
314  Int_t iGeoVersion = fGeoHandler->Init(isSimulation);
315  LOG(info) << "CbmTofGeometryQa::Init with GeoVersion " << iGeoVersion;
316 
317  if (k12b > iGeoVersion) {
318  LOG(error) << "CbmTofGeometryQa::Init => Only compatible with geometries "
319  "after v12b !!!";
320  return kFATAL;
321  } // if( k12b > iGeoVersion )
322 
323  if (NULL != fTofId)
324  LOG(info) << "CbmTofGeometryQa::Init with GeoVersion "
325  << fGeoHandler->GetGeoVersion();
326  else {
327  switch (iGeoVersion) {
328  case k12b: fTofId = new CbmTofDetectorId_v12b(); break;
329  case k14a: fTofId = new CbmTofDetectorId_v14a(); break;
330  default:
331  LOG(error) << "CbmTofGeometryQa::Init => Invalid geometry!!!"
332  << iGeoVersion;
333  return kFATAL;
334  } // switch(iGeoVersion)
335  } // else of if(NULL != fTofId)
336 
337  if (kFALSE == LoadGeometry()) return kFATAL;
338 
339  if (kFALSE == CreateHistos()) return kFATAL;
340 
341  return kSUCCESS;
342 }
343 
344 void CbmTofGeometryQa::SetParContainers() {
345  LOG(info) << " CbmTofGeometryQa => Get the digi parameters for tof";
346 
347  // Get Base Container
348  /*
349  FairRunAna* ana = FairRunAna::Instance();
350  FairRuntimeDb* rtdb=ana->GetRuntimeDb();
351 */
352 }
353 
354 void CbmTofGeometryQa::Exec(Option_t* /*option*/) {
355  // Task execution
356 
357  LOG(debug) << " CbmTofGeometryQa => New event";
358 
359  FillHistos();
360 
361  if (0 == (fEvents % 1000) && 0 < fEvents) {
362  LOG(info) << "CbmTofGeometryQa::Exec : "
363  << "event " << fEvents << " processed." << endl;
364  }
365  fEvents += 1;
366 }
367 
368 void CbmTofGeometryQa::Finish() {
369  // Normalisations
370  cout << "CbmTofGeometryQa::Finish up with " << fEvents << " analyzed events "
371  << endl;
372 
373  WriteHistos();
374  // Prevent them from being sucked in by the CbmHadronAnalysis WriteHistograms method
375  DeleteHistos();
376 }
377 
378 /************************************************************************************/
379 // Functions common for all clusters approximations
380 Bool_t CbmTofGeometryQa::RegisterInputs() {
381  FairRootManager* fManager = FairRootManager::Instance();
382 
383  fMCEventHeader = (FairMCEventHeader*) fManager->GetObject("MCEventHeader.");
384  if (NULL == fMCEventHeader) {
385  LOG(error) << "CbmTofGeometryQa::RegisterInputs => Could not get the "
386  "MCEventHeader object!!!";
387  return kFALSE;
388  }
389 
390  fTofPointsColl = (TClonesArray*) fManager->GetObject("TofPoint");
391  if (NULL == fTofPointsColl) {
392  LOG(error) << "CbmTofGeometryQa::RegisterInputs => Could not get the "
393  "TofPoint TClonesArray!!!";
394  return kFALSE;
395  } // if( NULL == fTofPointsColl)
396 
397  fMcTracksColl = (TClonesArray*) fManager->GetObject("MCTrack");
398  if (NULL == fMcTracksColl) {
399  LOG(error) << "CbmTofGeometryQa::RegisterInputs => Could not get the "
400  "MCTrack TClonesArray!!!";
401  return kFALSE;
402  } // if( NULL == fMcTracksColl)
403 
404  fRealTofPointsColl = (TClonesArray*) fManager->GetObject("RealisticTofPoint");
405  fRealTofMatchColl = (TClonesArray*) fManager->GetObject("TofRealPntMatch");
406  if (NULL != fRealTofPointsColl && NULL != fRealTofMatchColl) {
407  fbRealPointAvail = kTRUE;
408  LOG(info)
409  << "CbmTofGeometryQa::RegisterInputs => Both fRealTofPointsColl & "
410  "fRealTofMatchColl there, realistic mean TOF MC point used for QA";
411  } // if( NULL != fRealTofPointsColl && NULL != fRealTofMatchColl )
412 
413  return kTRUE;
414 }
415 /************************************************************************************/
416 Bool_t CbmTofGeometryQa::LoadGeometry() {
417  /*
418  Type 0: 5 RPC/SM, 24 SM, 32 ch/RPC => 3840 ch , 120 RPC ,
419  Type 1: 5 RPC/SM, 142 SM, 32 ch/RPC => 22720 ch => 26560 , 710 RPC => 830 , => 166
420  Type 3: 3 RPC/SM, 50 SM, 56 ch/RPC => 8400 ch => 34960 , 150 RPC => 980 , => 216
421  Type 4: 5 RPC/SM, 8 SM, 96 ch/RPC => 3840 ch => 38800 , 40 RPC => 1020 , => 224
422  Type 5: 5 RPC/SM, 8 SM, 96 ch/RPC => 3840 ch => 42640 , 40 RPC => 1060 , => 232
423  Type 6: 2 RPC/SM, 10 SM, 96 ch/RPC => 1920 ch => 44560 , 20 RPC => 1080 , => 242
424  */
425  /*
426  // Count the total number of channels and
427  // generate an array with the global channel index of the first channe in each RPC
428  Int_t iNbSmTypes = fDigiBdfPar->GetNbSmTypes();
429  fvTypeSmOffs.resize( iNbSmTypes );
430  fvSmRpcOffs.resize( iNbSmTypes );
431  fvRpcChOffs.resize( iNbSmTypes );
432  iNbSmTot = 0;
433  iNbRpcTot = 0;
434  fiNbChTot = 0;
435  for( Int_t iSmType = 0; iSmType < iNbSmTypes; iSmType++ )
436  {
437  Int_t iNbSm = fDigiBdfPar->GetNbSm( iSmType);
438  Int_t iNbRpc = fDigiBdfPar->GetNbRpc( iSmType);
439 
440  fvTypeSmOffs[iSmType] = iNbSmTot;
441  iNbSmTot += iNbSm;
442 
443  fvSmRpcOffs[iSmType].resize( iNbSm );
444  fvRpcChOffs[iSmType].resize( iNbSm );
445 
446  for( Int_t iSm = 0; iSm < iNbSm; iSm++ )
447  {
448  fvSmRpcOffs[iSmType][iSm] = iNbRpcTot;
449  iNbRpcTot += iNbRpc;
450 
451  fvRpcChOffs[iSmType][iSm].resize( iNbRpc );
452  for( Int_t iRpc = 0; iRpc < iNbRpc; iRpc++ )
453  {
454  fvRpcChOffs[iSmType][iSm][iRpc] = fiNbChTot;
455  fiNbChTot += fDigiBdfPar->GetNbChan( iSmType, iRpc );
456  } // for( Int_t iRpc = 0; iRpc < iNbRpc; iRpc++ )
457  } // for( Int_t iSm = 0; iSm < iNbSm; iSm++ )
458  } // for( Int_t iSmType = 0; iSmType < iNbSmTypes; iSmType++ )
459 */
460  return kTRUE;
461 }
462 /************************************************************************************/
463 // ------------------------------------------------------------------
464 Bool_t CbmTofGeometryQa::SetWallPosZ(Double_t dWallPosCm) {
465  fdWallPosZ = dWallPosCm;
466  LOG(info)
467  << "CbmTofGeometryQa::SetWallPosZ => Change histograms center on Z axis to "
468  << dWallPosCm << " cm";
469  return kTRUE;
470 }
471 Bool_t CbmTofGeometryQa::CreateHistos() {
472  // Create histogramms
473 
474  TDirectory* oldir =
475  gDirectory; // <= To prevent histos from being sucked in by the param file of the TRootManager!
476  gROOT
477  ->cd(); // <= To prevent histos from being sucked in by the param file of the TRootManager !
478  /*
479  Double_t ymin=-1.;
480  Double_t ymax=4.;
481  Double_t ptmmax=2.5;
482  Int_t ptm_nbx=30;
483  Int_t ptm_nby=30;
484 
485  Double_t v1_nbx=20.;
486  Double_t v1_nby=20.;
487  Double_t yvmax=1.3;
488 */
489  // xy - hit densities and rates
490  Int_t nbinx = 1500;
491  Int_t nbiny = 1000;
492  Int_t nbinz = 1500;
493  Double_t xrange = 750.;
494  Double_t yrange = 500.;
495  Double_t zmin = fdWallPosZ - 50.;
496  Double_t zmax = fdWallPosZ + 200.;
497 
498  // angular densities for overlap check
499  Int_t iNbBinThetaX = 1200;
500  Double_t dThetaXMin = -60.0;
501  Double_t dThetaXMax = 60.0;
502  Int_t iNbBinThetaY = 900;
503  Double_t dThetaYMin = -45.0;
504  Double_t dThetaYMax = 45.0;
505 
506  Int_t iNbBinTheta = 180;
507  Double_t dThetaMin = 0;
508  Double_t dThetaMax = TMath::Pi() * 90 / 180;
509  Int_t iNbBinPhi = 180;
510  Double_t dPhiMin = -TMath::Pi();
511  Double_t dPhiMax = TMath::Pi();
512 
513  // Mapping
514  // Dependence of Track origin on centrality
515  Int_t iNbBinsStartZ = 1250;
516  Double_t dMinStartZ = -50.0;
517  Double_t dMaxStartZ = 1200.0;
518  Int_t iNbBinsStartXY = 1200;
519  Double_t dMinStartXY = -600.0;
520  Double_t dMaxStartXY = 600.0;
521  Int_t iNbBinsCentr = 16;
522  Double_t dNbMinCentr = 0.0;
523  Double_t dNbMaxCentr = 16.0;
524 
525  if (kTRUE == fbCentDepOn) {
526  fvhTrackAllStartZCent.resize(kiNbPart);
527  fvhTrackSecStartZCent.resize(kiNbPart);
528  fvhTrackAllStartXZCent.resize(kiNbPart);
529  fvhTofPntAllAngCent.resize(kiNbPart);
530  } // if( kTRUE == fbCentDepOn )
531  fvhTrackAllStartXZ.resize(kiNbPart);
532  fvhTrackAllStartYZ.resize(kiNbPart);
533  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
534  // Track origin for tracks reaching TOF
535  if (kTRUE == fbCentDepOn) {
536  fvhTrackAllStartZCent[iPartIdx] = new TH2D(
537  Form("TofTests_TrackAllStartZCent_%s", ksPartTag[iPartIdx].Data()),
538  Form("Centrality vs Start Z distribution for MC tracks w/ TOF Pnt, %s, "
539  "all tracks; Start Z [cm]; B [fm]; # []",
540  ksPartName[iPartIdx].Data()),
541  iNbBinsStartZ,
542  dMinStartZ,
543  dMaxStartZ,
544  iNbBinsCentr,
545  dNbMinCentr,
546  dNbMaxCentr);
547  fvhTrackSecStartZCent[iPartIdx] = new TH2D(
548  Form("TofTests_TrackSecStartZCent_%s", ksPartTag[iPartIdx].Data()),
549  Form("Centrality vs Start Z distribution for MC tracks w/ TOF Pnt, %s, "
550  "secondary tracks; Start Z [cm]; B [fm]; # []",
551  ksPartName[iPartIdx].Data()),
552  iNbBinsStartZ,
553  dMinStartZ,
554  dMaxStartZ,
555  iNbBinsCentr,
556  dNbMinCentr,
557  dNbMaxCentr);
558  if (2 == iPartIdx) // 3D plot only for e-
559  fvhTrackAllStartXZCent[iPartIdx] = new TH3D(
560  Form("TofTests_TrackAllStartXZCent_%s", ksPartTag[iPartIdx].Data()),
561  Form("Centrality vs Start Z distribution for MC tracks w/ TOF Pnt, "
562  "%s, all tracks; Start X [cm]; Start Z [cm]; B [fm];",
563  ksPartName[iPartIdx].Data()),
564  iNbBinsStartXY / 2,
565  dMinStartXY,
566  dMaxStartXY,
567  iNbBinsStartZ / 2,
568  dMinStartZ,
569  dMaxStartZ,
570  iNbBinsCentr,
571  dNbMinCentr,
572  dNbMaxCentr);
573  fvhTofPntAllAngCent[iPartIdx] = new TH3D(
574  Form("TofTests_TofPntAllAngCent_%s", ksPartTag[iPartIdx].Data()),
575  Form("Centrality vs Angular position of TOF Pnt, %s, all tracks; "
576  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; B [fm];",
577  ksPartName[iPartIdx].Data()),
578  iNbBinThetaX / 2,
579  dThetaXMin,
580  dThetaXMax,
581  iNbBinThetaY / 2,
582  dThetaYMin,
583  dThetaYMax,
584  iNbBinsCentr,
585  dNbMinCentr,
586  dNbMaxCentr);
587  } // if( kTRUE == fbCentDepOn )
588  fvhTrackAllStartXZ[iPartIdx] =
589  new TH2D(Form("TofTests_TrackAllStartXZ_%s", ksPartTag[iPartIdx].Data()),
590  Form("Start X vs Z distribution for MC tracks w/ TOF Pnt, %s, "
591  "all tracks; Start Z [cm]; Start X [cm]; # []",
592  ksPartName[iPartIdx].Data()),
593  iNbBinsStartZ / 2,
594  dMinStartZ,
595  dMaxStartZ,
596  iNbBinsStartXY,
597  dMinStartXY,
598  dMaxStartXY);
599  fvhTrackAllStartYZ[iPartIdx] =
600  new TH2D(Form("TofTests_TrackAllStartYZ_%s", ksPartTag[iPartIdx].Data()),
601  Form("Start Y vs Z distribution for MC tracks w/ TOF Pnt, %s, "
602  "all tracks; Start Z [cm]; Start Y [cm]; # []",
603  ksPartName[iPartIdx].Data()),
604  iNbBinsStartZ / 2,
605  dMinStartZ,
606  dMaxStartZ,
607  iNbBinsStartXY,
608  dMinStartXY,
609  dMaxStartXY);
610  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
611 
612  // tracks
613  fhTrackMapXY = new TH2D(
614  "TofTests_TracksMapXY",
615  "Position of the MC Tracks assuming along Z axis; X[cm]; Y[cm]; # [Tracks]",
616  nbinx,
617  -xrange,
618  xrange,
619  nbiny,
620  -yrange,
621  yrange);
622  fhTrackMapXZ = new TH2D(
623  "TofTests_TracksMapXZ",
624  "Position of the MC Tracks assuming along Z axis; X[cm]; Z[cm]; # [Tracks]",
625  nbinx,
626  -xrange,
627  xrange,
628  nbinz,
629  zmin,
630  zmax);
631  fhTrackMapYZ = new TH2D(
632  "TofTests_TracksMapYZ",
633  "Position of the MC Tracks assuming along Z axis; Y[cm]; Z[cm]; # [Tracks]",
634  nbiny,
635  -yrange,
636  yrange,
637  nbinz,
638  zmin,
639  zmax);
640  fhTrackMapAng = new TH2D("TofTests_TracksMapAng",
641  "Position of the MC Tracks assuming from origin; "
642  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
643  iNbBinThetaX,
644  dThetaXMin,
645  dThetaXMax,
646  iNbBinThetaY,
647  dThetaYMin,
648  dThetaYMax);
649  fhTrackMapSph = new TH2D("TofTests_TracksMapSph",
650  "Position of the MC Tracks assuming from origin; "
651  "#theta[rad.]; #phi[rad.]; # [Tracks]",
652  iNbBinTheta,
653  dThetaMin,
654  dThetaMax,
655  iNbBinPhi,
656  dPhiMin,
657  dPhiMax);
658  // Tracks in angular coordinates with detectors points, For angular acceptance study
659  fhTrackMapAngPrimAll =
660  new TH2D("TofTests_TracksMapAngPrimAll",
661  "Position of the MC Tracks assuming from origin, primary only; "
662  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
663  iNbBinThetaX,
664  dThetaXMin,
665  dThetaXMax,
666  iNbBinThetaY,
667  dThetaYMin,
668  dThetaYMax);
669  fhTrackMapAngPrimSts =
670  new TH2D("TofTests_TracksMapAngPrimSts",
671  "Position of the MC Tracks w/ STS Pnts assuming from origin, "
672  "primary only; #theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
673  iNbBinThetaX,
674  dThetaXMin,
675  dThetaXMax,
676  iNbBinThetaY,
677  dThetaYMin,
678  dThetaYMax);
679  fhTrackMapAngPrimRich =
680  new TH2D("TofTests_TracksMapAngPrimRich",
681  "Position of the MC Tracks w/ RICH Pnts assuming from origin, "
682  "primary only; #theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
683  iNbBinThetaX,
684  dThetaXMin,
685  dThetaXMax,
686  iNbBinThetaY,
687  dThetaYMin,
688  dThetaYMax);
689  fhTrackMapAngPrimMuch =
690  new TH2D("TofTests_TracksMapAngPrimMuch",
691  "Position of the MC Tracks w/ MUCH Pnts assuming from origin, "
692  "primary only; #theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
693  iNbBinThetaX,
694  dThetaXMin,
695  dThetaXMax,
696  iNbBinThetaY,
697  dThetaYMin,
698  dThetaYMax);
699  fhTrackMapAngPrimTrd =
700  new TH2D("TofTests_TracksMapAngPrimTrd",
701  "Position of the MC Tracks w/ TRD Pnts assuming from origin, "
702  "primary only; #theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
703  iNbBinThetaX,
704  dThetaXMin,
705  dThetaXMax,
706  iNbBinThetaY,
707  dThetaYMin,
708  dThetaYMax);
709  fhTrackMapAngPrimTof =
710  new TH2D("TofTests_TracksMapAngPrimTof",
711  "Position of the MC Tracks w/ TOF Pnts assuming from origin, "
712  "primary only; #theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Tracks]",
713  iNbBinThetaX,
714  dThetaXMin,
715  dThetaXMax,
716  iNbBinThetaY,
717  dThetaYMin,
718  dThetaYMax);
719  // points
720  fhPointMapXY =
721  new TH2D("TofTests_PointsMapXY",
722  "Position of the Tof Points; X[cm]; Y[cm]; # [Points]",
723  nbinx,
724  -xrange,
725  xrange,
726  nbiny,
727  -yrange,
728  yrange);
729  fhPointMapXZ =
730  new TH2D("TofTests_PointsMapXZ",
731  "Position of the Tof Points; X[cm]; Z[cm]; # [Points]",
732  nbinx,
733  -xrange,
734  xrange,
735  nbinz,
736  zmin,
737  zmax);
738  fhPointMapYZ =
739  new TH2D("TofTests_PointsMapYZ",
740  "Position of the Tof Points; Y[cm]; Z[cm]; # [Points]",
741  nbiny,
742  -yrange,
743  yrange,
744  nbinz,
745  zmin,
746  zmax);
747  fhPointMapAng = new TH2D("TofTests_PointsMapAng",
748  "Position of the Tof Points; #theta_{x}[Deg.]; "
749  "#theta_{y}[Deg.]; # [Points]",
750  iNbBinThetaX,
751  dThetaXMin,
752  dThetaXMax,
753  iNbBinThetaY,
754  dThetaYMin,
755  dThetaYMax);
756  fhPointMapSph =
757  new TH2D("TofTests_PointsMapSph",
758  "Position of the Tof Points; #theta[rad.]; #phi[rad.]; # [Points]",
759  iNbBinTheta,
760  dThetaMin,
761  dThetaMax,
762  iNbBinPhi,
763  dPhiMin,
764  dPhiMax);
765  // real (mean over all gaps) points
766  fhRealPointMapXY = new TH2D(
767  "TofTests_RealPointsMapXY",
768  "Position of the Tof Points (mean o/ gaps); X[cm]; Y[cm]; # [Points]",
769  nbinx,
770  -xrange,
771  xrange,
772  nbiny,
773  -yrange,
774  yrange);
775  fhRealPointMapXZ = new TH2D(
776  "TofTests_RealPointsMapXZ",
777  "Position of the Tof Points (mean o/ gaps); X[cm]; Z[cm]; # [Points]",
778  nbinx,
779  -xrange,
780  xrange,
781  nbinz,
782  zmin,
783  zmax);
784  fhRealPointMapYZ = new TH2D(
785  "TofTests_RealPointsMapYZ",
786  "Position of the Tof Points (mean o/ gaps); Y[cm]; Z[cm]; # [Points]",
787  nbiny,
788  -yrange,
789  yrange,
790  nbinz,
791  zmin,
792  zmax);
793  fhRealPointMapAng = new TH2D("TofTests_RealPointsMapAng",
794  "Position of the Tof Points (mean o/ gaps); "
795  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Points]",
796  iNbBinThetaX,
797  dThetaXMin,
798  dThetaXMax,
799  iNbBinThetaY,
800  dThetaYMin,
801  dThetaYMax);
802  fhRealPointMapSph = new TH2D("TofTests_RealPointsMapSph",
803  "Position of the Tof Points (mean o/ gaps); "
804  "#theta[rad.]; #phi[rad.]; # [Points]",
805  iNbBinTheta,
806  dThetaMin,
807  dThetaMax,
808  iNbBinPhi,
809  dPhiMin,
810  dPhiMax);
811  // Pints in angular coordinates with other detectors points in track, For angular acceptance study
812  fhPointMapAngWithSts =
813  new TH2D("TofTests_PointsMapAngWithSts",
814  "Position of the Tof Points with enough STS points in Track; "
815  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Points]",
816  iNbBinThetaX,
817  dThetaXMin,
818  dThetaXMax,
819  iNbBinThetaY,
820  dThetaYMin,
821  dThetaYMax);
822  fhPointMapAngWithRich =
823  new TH2D("TofTests_PointsMapAngWithRich",
824  "Position of the Tof Points with RICH points in Track; "
825  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Points]",
826  iNbBinThetaX,
827  dThetaXMin,
828  dThetaXMax,
829  iNbBinThetaY,
830  dThetaYMin,
831  dThetaYMax);
832  fhPointMapAngWithMuch =
833  new TH2D("TofTests_PointsMapAngWithMuch",
834  "Position of the Tof Points with enough MUCH points in Track; "
835  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Points]",
836  iNbBinThetaX,
837  dThetaXMin,
838  dThetaXMax,
839  iNbBinThetaY,
840  dThetaYMin,
841  dThetaYMax);
842  fhPointMapAngWithTrd =
843  new TH2D("TofTests_PointsMapAngWithTrd",
844  "Position of the Tof Points with TRD points in Track; "
845  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; # [Points]",
846  iNbBinThetaX,
847  dThetaXMin,
848  dThetaXMax,
849  iNbBinThetaY,
850  dThetaYMin,
851  dThetaYMax);
852 
853  // Errors relative to spherical approx
854  if (kTRUE == fbSphAppOn) {
855  // Radius error (distance from target)
856  fhPointSphAprRadiusErrMapXY =
857  new TProfile2D("TofTests_PointSphAprRadiusErrMapXY",
858  "Radius error (distance from target) in spherical approx. "
859  "(mean o/ gaps); X[cm]; Y[cm]; Rp - Rwall [cm]",
860  nbinx,
861  -xrange,
862  xrange,
863  nbiny,
864  -yrange,
865  yrange);
866  fhPointSphAprRadiusErrMapXZ =
867  new TProfile2D("TofTests_PointSphAprRadiusErrMapXZ",
868  "Radius error (distance from target) in spherical approx. "
869  "(mean o/ gaps); X[cm]; Z[cm]; Rp - Rwall [cm]",
870  nbinx,
871  -xrange,
872  xrange,
873  nbinz,
874  zmin,
875  zmax);
876  fhPointSphAprRadiusErrMapYZ =
877  new TProfile2D("TofTests_PointSphAprRadiusErrMapYZ",
878  "Radius error (distance from target) in spherical approx. "
879  "(mean o/ gaps); Y[cm]; Z[cm]; Rp - Rwall [cm]",
880  nbiny,
881  -yrange,
882  yrange,
883  nbinz,
884  zmin,
885  zmax);
886  fhPointSphAprRadiusErrMapAng = new TProfile2D(
887  "TofTests_PointSphAprRadiusErrMapAng",
888  "Radius error (distance from target) in spherical approx. (mean o/ "
889  "gaps); #theta_{x}[Deg.]; #theta_{y}[Deg.]; Rp - Rwall [cm]",
890  iNbBinThetaX,
891  dThetaXMin,
892  dThetaXMax,
893  iNbBinThetaY,
894  dThetaYMin,
895  dThetaYMax);
896  fhPointSphAprRadiusErrMapSph = new TProfile2D(
897  "TofTests_PointSphAprRadiusErrMapSph",
898  "Radius error (distance from target) in spherical approx. (mean o/ "
899  "gaps); #theta[rad.]; #phi[rad.]; Rp - Rwall [cm]",
900  iNbBinTheta,
901  dThetaMin,
902  dThetaMax,
903  iNbBinPhi,
904  dPhiMin,
905  dPhiMax);
906  // Z position error
907  fhPointSphAprZposErrMapXY =
908  new TProfile2D("TofTests_PointSphAprZposErrMapXY",
909  "Z Position error of the Tof Points in spherical approx. "
910  "(mean o/ gaps); X[cm]; Y[cm]; Zp - Zsph(X,Y) [cm]",
911  nbinx,
912  -xrange,
913  xrange,
914  nbiny,
915  -yrange,
916  yrange);
917  fhPointSphAprZposErrMapXZ =
918  new TProfile2D("TofTests_PointSphAprZposErrMapXZ",
919  "Position of the Tof Points in spherical approx. (mean o/ "
920  "gaps); X[cm]; Z[cm]; Zp - Zsph(X,Y) [cm]",
921  nbinx,
922  -xrange,
923  xrange,
924  nbinz,
925  zmin,
926  zmax);
927  fhPointSphAprZposErrMapYZ =
928  new TProfile2D("TofTests_PointSphAprZposErrMapYZ",
929  "Position of the Tof Points in spherical approx. (mean o/ "
930  "gaps); Y[cm]; Z[cm]; Zp - Zsph(X,Y) [cm]",
931  nbiny,
932  -yrange,
933  yrange,
934  nbinz,
935  zmin,
936  zmax);
937  fhPointSphAprZposErrMapAng = new TProfile2D(
938  "TofTests_PointSphAprZposErrMapAng",
939  "Position of the Tof Points in spherical approx. (mean o/ gaps); "
940  "#theta_{x}[Deg.]; #theta_{y}[Deg.]; Zp - Zsph(X,Y) [cm]",
941  iNbBinThetaX,
942  dThetaXMin,
943  dThetaXMax,
944  iNbBinThetaY,
945  dThetaYMin,
946  dThetaYMax);
947  fhPointSphAprZposErrMapSph =
948  new TProfile2D("TofTests_PointSphAprZposErrMapSph",
949  "Position of the Tof Points in spherical approx. (mean o/ "
950  "gaps); #theta[rad.]; #phi[rad.]; Zp - Zsph(X,Y) [cm]",
951  iNbBinTheta,
952  dThetaMin,
953  dThetaMax,
954  iNbBinPhi,
955  dPhiMin,
956  dPhiMax);
957  } // if( kTRUE == fbSphAppOn )
958 
959  // Physics coord mapping, 1 per particle type
960  // Phase space
961  Int_t iNbBinsY = 30;
962  Double_t dMinY = -1.;
963  Double_t dMaxY = 4.;
964  Int_t iNbBNinsPtm = 30;
965  Double_t dMinPtm = 0.0;
966  Double_t dMaxPtm = 2.5;
967  fvhPtmRapGenTrk.resize(kiNbPart);
968  fvhPtmRapStsPnt.resize(kiNbPart);
969  fvhPtmRapTofPnt.resize(kiNbPart);
970  fvhPtmRapSecGenTrk.resize(kiNbPart);
971  fvhPtmRapSecStsPnt.resize(kiNbPart);
972  fvhPtmRapSecTofPnt.resize(kiNbPart);
973  // PLab
974  Int_t iNbBinsPlab = 100;
975  Double_t dMinPlab = 0.0;
976  Double_t dMaxPlab = 10.0;
977  fvhPlabGenTrk.resize(kiNbPart);
978  fvhPlabStsPnt.resize(kiNbPart);
979  fvhPlabTofPnt.resize(kiNbPart);
980  fvhPlabSecGenTrk.resize(kiNbPart);
981  fvhPlabSecStsPnt.resize(kiNbPart);
982  fvhPlabSecTofPnt.resize(kiNbPart);
983  // MC Tracks losses
984  fvhPtmRapGenTrkTofPnt.resize(kiNbPart);
985  fvhPlabGenTrkTofPnt.resize(kiNbPart);
986  fvhPlabStsTrkTofPnt.resize(kiNbPart);
987  fvhPtmRapSecGenTrkTofPnt.resize(kiNbPart);
988  fvhPlabSecGenTrkTofPnt.resize(kiNbPart);
989  fvhPlabSecStsTrkTofPnt.resize(kiNbPart);
990  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
991  // Phase space
992  fvhPtmRapGenTrk[iPartIdx] =
993  new TH2D(Form("TofTests_PtmRapGenTrk_%s", ksPartTag[iPartIdx].Data()),
994  Form("P_{t}/M vs y distribution for MC tracks, %s, primary "
995  "tracks; y; P_{t}/M; # []",
996  ksPartName[iPartIdx].Data()),
997  iNbBinsY,
998  dMinY,
999  dMaxY,
1000  iNbBNinsPtm,
1001  dMinPtm,
1002  dMaxPtm);
1003  fvhPtmRapStsPnt[iPartIdx] =
1004  new TH2D(Form("TofTests_PtmRapStsPnt_%s", ksPartTag[iPartIdx].Data()),
1005  Form("P_{t}/M vs y distribution from MC Track with STS points, "
1006  "%s, primary tracks; y; P_{t}/M; # []",
1007  ksPartName[iPartIdx].Data()),
1008  iNbBinsY,
1009  dMinY,
1010  dMaxY,
1011  iNbBNinsPtm,
1012  dMinPtm,
1013  dMaxPtm);
1014  fvhPtmRapTofPnt[iPartIdx] =
1015  new TH2D(Form("TofTests_PtmRapTofPnt_%s", ksPartTag[iPartIdx].Data()),
1016  Form("P_{t}/M vs y distribution from MC Track for TOF points, "
1017  "%s, primary tracks; y; P_{t}/M; # []",
1018  ksPartName[iPartIdx].Data()),
1019  iNbBinsY,
1020  dMinY,
1021  dMaxY,
1022  iNbBNinsPtm,
1023  dMinPtm,
1024  dMaxPtm);
1025  // PLab
1026  fvhPlabGenTrk[iPartIdx] =
1027  new TH1D(Form("TofTests_PlabGenTrk_%s", ksPartTag[iPartIdx].Data()),
1028  Form("P_{lab} distribution for MC tracks, %s, primary tracks; "
1029  "P_{lab} [GeV/c]; # []",
1030  ksPartName[iPartIdx].Data()),
1031  iNbBinsPlab,
1032  dMinPlab,
1033  dMaxPlab);
1034  fvhPlabStsPnt[iPartIdx] =
1035  new TH1D(Form("TofTests_PlabStsPnt_%s", ksPartTag[iPartIdx].Data()),
1036  Form("P_{lab} distribution from MC Track with STS points, %s, "
1037  "primary tracks; P_{lab} [GeV/c]; # []",
1038  ksPartName[iPartIdx].Data()),
1039  iNbBinsPlab,
1040  dMinPlab,
1041  dMaxPlab);
1042  fvhPlabTofPnt[iPartIdx] =
1043  new TH1D(Form("TofTests_PlabTofPnt_%s", ksPartTag[iPartIdx].Data()),
1044  Form("P_{lab} distribution from MC Track for TOF points, %s, "
1045  "primary tracks; P_{lab} [GeV/c]; # []",
1046  ksPartName[iPartIdx].Data()),
1047  iNbBinsPlab,
1048  dMinPlab,
1049  dMaxPlab);
1050 
1051 
1052  // MC Tracks losses
1053  fvhPtmRapGenTrkTofPnt[iPartIdx] = new TH2D(
1054  Form("TofTests_PtmRapGenTrkTofPnt_%s", ksPartTag[iPartIdx].Data()),
1055  Form("P_{t}/M vs y distribution for MC tracks with TOF Point(s), %s, "
1056  "primary tracks; y; P_{t}/M; # []",
1057  ksPartName[iPartIdx].Data()),
1058  iNbBinsY,
1059  dMinY,
1060  dMaxY,
1061  iNbBNinsPtm,
1062  dMinPtm,
1063  dMaxPtm);
1064 
1065  fvhPlabGenTrkTofPnt[iPartIdx] =
1066  new TH1D(Form("TofTests_PlabGenTrkTofPnt_%s", ksPartTag[iPartIdx].Data()),
1067  Form("P_{lab} distribution for MC tracks with TOF Point(s), %s, "
1068  "primary tracks; P_{lab} [GeV/c]; # []",
1069  ksPartName[iPartIdx].Data()),
1070  iNbBinsPlab,
1071  dMinPlab,
1072  dMaxPlab);
1073  fvhPlabStsTrkTofPnt[iPartIdx] =
1074  new TH1D(Form("TofTests_PlabStsTrkTofPnt_%s", ksPartTag[iPartIdx].Data()),
1075  Form("P_{lab} distribution for MC tracks with STS and TOF "
1076  "Point(s), %s, primary tracks; P_{lab} [GeV/c]; # []",
1077  ksPartName[iPartIdx].Data()),
1078  iNbBinsPlab,
1079  dMinPlab,
1080  dMaxPlab);
1081 
1082  // Secondary tracks
1083  // Phase space
1084  fvhPtmRapSecGenTrk[iPartIdx] =
1085  new TH2D(Form("TofTests_PtmRapSecGenTrk_%s", ksPartTag[iPartIdx].Data()),
1086  Form("P_{t}/M vs y distribution for MC tracks, %s, secondary "
1087  "tracks; y; P_{t}/M; # []",
1088  ksPartName[iPartIdx].Data()),
1089  iNbBinsY,
1090  dMinY,
1091  dMaxY,
1092  iNbBNinsPtm,
1093  dMinPtm,
1094  dMaxPtm);
1095  fvhPtmRapSecStsPnt[iPartIdx] =
1096  new TH2D(Form("TofTests_PtmRapSecStsPnt_%s", ksPartTag[iPartIdx].Data()),
1097  Form("P_{t}/M vs y distribution from MC Track with STS points, "
1098  "%s, secondary tracks; y; P_{t}/M; # []",
1099  ksPartName[iPartIdx].Data()),
1100  iNbBinsY,
1101  dMinY,
1102  dMaxY,
1103  iNbBNinsPtm,
1104  dMinPtm,
1105  dMaxPtm);
1106  fvhPtmRapSecTofPnt[iPartIdx] =
1107  new TH2D(Form("TofTests_PtmRapSecTofPnt_%s", ksPartTag[iPartIdx].Data()),
1108  Form("P_{t}/M vs y distribution from MC Track for TOF points, "
1109  "%s, secondary tracks; y; P_{t}/M; # []",
1110  ksPartName[iPartIdx].Data()),
1111  iNbBinsY,
1112  dMinY,
1113  dMaxY,
1114  iNbBNinsPtm,
1115  dMinPtm,
1116  dMaxPtm);
1117  // PLab
1118  fvhPlabSecGenTrk[iPartIdx] =
1119  new TH1D(Form("TofTests_PlabSecGenTrk_%s", ksPartTag[iPartIdx].Data()),
1120  Form("P_{lab} distribution for MC tracks, %s, secondary tracks; "
1121  "P_{lab} [GeV/c]; # []",
1122  ksPartName[iPartIdx].Data()),
1123  iNbBinsPlab,
1124  dMinPlab,
1125  dMaxPlab);
1126  fvhPlabSecStsPnt[iPartIdx] =
1127  new TH1D(Form("TofTests_PlabSecStsPnt_%s", ksPartTag[iPartIdx].Data()),
1128  Form("P_{lab} distribution from MC Track with STS points, %s, "
1129  "secondary tracks; P_{lab} [GeV/c]; # []",
1130  ksPartName[iPartIdx].Data()),
1131  iNbBinsPlab,
1132  dMinPlab,
1133  dMaxPlab);
1134  fvhPlabSecTofPnt[iPartIdx] =
1135  new TH1D(Form("TofTests_PlabSecTofPnt_%s", ksPartTag[iPartIdx].Data()),
1136  Form("P_{lab} distribution from MC Track for TOF points, %s, "
1137  "secondary tracks; P_{lab} [GeV/c]; # []",
1138  ksPartName[iPartIdx].Data()),
1139  iNbBinsPlab,
1140  dMinPlab,
1141  dMaxPlab);
1142 
1143 
1144  // MC Tracks losses
1145  fvhPtmRapSecGenTrkTofPnt[iPartIdx] = new TH2D(
1146  Form("TofTests_PtmRapSecGenTrkTofPnt_%s", ksPartTag[iPartIdx].Data()),
1147  Form("P_{t}/M vs y distribution for MC tracks with TOF Point(s), %s, "
1148  "secondary tracks; y; P_{t}/M; # []",
1149  ksPartName[iPartIdx].Data()),
1150  iNbBinsY,
1151  dMinY,
1152  dMaxY,
1153  iNbBNinsPtm,
1154  dMinPtm,
1155  dMaxPtm);
1156 
1157  fvhPlabSecGenTrkTofPnt[iPartIdx] = new TH1D(
1158  Form("TofTests_PlabSecGenTrkTofPnt_%s", ksPartTag[iPartIdx].Data()),
1159  Form("P_{lab} distribution for MC tracks with TOF Point(s), %s, "
1160  "secondary tracks; P_{lab} [GeV/c]; # []",
1161  ksPartName[iPartIdx].Data()),
1162  iNbBinsPlab,
1163  dMinPlab,
1164  dMaxPlab);
1165 
1166  fvhPlabSecStsTrkTofPnt[iPartIdx] = new TH1D(
1167  Form("TofTests_PlabSecStsTrkTofPnt_%s", ksPartTag[iPartIdx].Data()),
1168  Form("P_{lab} distribution for MC tracks with STS and TOF Point(s), %s, "
1169  "secondary tracks; P_{lab} [GeV/c]; # []",
1170  ksPartName[iPartIdx].Data()),
1171  iNbBinsPlab,
1172  dMinPlab,
1173  dMaxPlab);
1174  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
1175 
1176  gDirectory->cd(
1177  oldir
1178  ->GetPath()); // <= To prevent histos from being sucked in by the param file of the TRootManager!
1179 
1180  return kTRUE;
1181 }
1182 
1183 // ------------------------------------------------------------------
1184 Bool_t CbmTofGeometryQa::FillHistos() {
1185  // Declare variables outside the loop
1186  CbmMCTrack* pMcTrk;
1187  CbmTofPoint* pTofPoint;
1188 
1189  Int_t iNbTracks, iNbTofPts, iNbTofRealPts;
1190 
1191  iNbTracks = fMcTracksColl->GetEntriesFast();
1192  iNbTofPts = fTofPointsColl->GetEntriesFast();
1193  if (kTRUE == fbRealPointAvail)
1194  iNbTofRealPts = fRealTofPointsColl->GetEntriesFast();
1195  else
1196  iNbTofRealPts = 0;
1197 
1198  // Tracks Info
1199  Int_t iNbTofTracks = 0;
1200  Int_t iNbTofTracksPrim = 0;
1201  std::vector<Bool_t> vbTrackHasHit(iNbTracks, kFALSE);
1202  // Are MC tracks reconstructable in STS?
1203  // std::vector< Bool_t > vbTrackStsRecOk( iNbTracks kFALSE);
1204  for (Int_t iTrkInd = 0; iTrkInd < iNbTracks; iTrkInd++) {
1205  pMcTrk = (CbmMCTrack*) fMcTracksColl->At(iTrkInd);
1206 
1207  // Is track reconstructable in STS
1208  /*
1209  UInt_t uNbStsPnts = pMcTrk->GetNPoints(ECbmModuleId::kSts);
1210 
1211  // True criterium is whether enough STS stations are crossed
1212  // but if already less STS points, can escape looping
1213  if( kiMinNbStsPntAcc <= uNbStsPnts )
1214  {
1215  std::vector< UInt_t > vStsStationsId();
1216  for( UInt_t uStsPntIdx = 0; uStsPntIdx < uNbStsPnts; uStsPntIdx++)
1217  {
1218  UInt_t uStation = CbmStsAddress::GetElementId(
1219  (dynamic_cast<CbmStsPoint*>fStsPointsColl->At( uStsPntIdx ))->GetDetectorID(), 1);
1220  if( kiMinNbStsPntAcc <= vStsStationsId.size() )
1221  {
1222  vbTrackStsRecOk[iTrkInd] = kTRUE;
1223  break;
1224  }
1225  } // for( UInt_t uStsPntIdx = 0; uStsPntIdx < uNbStsPnts; uStsPntIdx++)
1226  } // if( kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts) )
1227  */
1228 
1229  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTof)) {
1230  iNbTofTracks++;
1231  // Keep track of MC tracks with at least one TOF Point
1232 
1233  if (-1 == pMcTrk->GetMotherId()) {
1234  iNbTofTracksPrim++;
1235  } // if( -1 == pMcTrk->GetMotherId() )
1236  } // if( 0 < pMcTrk->GetNPoints(ECbmModuleId::kTof) )
1237 
1238  // tracks mapping: Only when creating normalization histos
1239  // Assume only TOF in setup, no field (only straight tracks)
1240  // and all tracks reach TOF (protons)
1241  // XYZ mapping: assume tracks along Z axis
1242  if (pMcTrk->GetPz() == pMcTrk->GetP()) {
1243  fhTrackMapXY->Fill(pMcTrk->GetStartX(), pMcTrk->GetStartY());
1244  // fhTrackMapXZ->Fill( pMcTrk->GetStartX(), fdWallPosZ ); // Not sure how to get Z here
1245  // fhTrackMapYZ->Fill( pMcTrk->GetStartY(), fdWallPosZ ); // Not sure how to get Z here
1246  } // if( pMcTrk->GetPz() == pMcTrk->GetP() )
1247 
1248  // Angular mapping: assume tracks all coming from origin and not necess. along Z axis
1249  // track with non zero Z momentum + non spectator (at least deflected in X or Y)
1250  if (0 != pMcTrk->GetPz()
1251  && ((0 != pMcTrk->GetPx()) || (0 != pMcTrk->GetPy()))) {
1252  Double_t dThetaX =
1253  TMath::ATan2(pMcTrk->GetPx(), pMcTrk->GetPz()) * 180.0 / TMath::Pi();
1254  Double_t dThetaY =
1255  TMath::ATan2(pMcTrk->GetPy(), pMcTrk->GetPz()) * 180.0 / TMath::Pi();
1256 
1257  fhTrackMapAng->Fill(dThetaX, dThetaY);
1258 
1259  // Primary tracks
1260  if (-1 == pMcTrk->GetMotherId()) {
1261  fhTrackMapAngPrimAll->Fill(dThetaX, dThetaY);
1262 
1263  if (kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts))
1264  fhTrackMapAngPrimSts->Fill(dThetaX, dThetaY);
1265 
1266  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kRich))
1267  fhTrackMapAngPrimRich->Fill(dThetaX, dThetaY);
1268 
1269  if (kiMinNbMuchPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kMuch))
1270  fhTrackMapAngPrimMuch->Fill(dThetaX, dThetaY);
1271 
1272  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTrd))
1273  fhTrackMapAngPrimTrd->Fill(dThetaX, dThetaY);
1274 
1275  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTof))
1276  fhTrackMapAngPrimTof->Fill(dThetaX, dThetaY);
1277  } // if( -1 == pMcTrk->GetMotherId() )
1278  } // if( 0 != pMcTrk->GetPz() && ( (0 != pMcTrk->GetPx() ) || (0 != pMcTrk->GetPy() ) ))
1279 
1280  // Spherical mapping: assume tracks all coming from origin and not necess. along Z axis
1281  if (0 != pMcTrk->GetPz() && 0 != pMcTrk->GetPx())
1282  fhTrackMapSph->Fill(TMath::ATan2(pMcTrk->GetPt(), pMcTrk->GetPz()),
1283  TMath::ATan2(pMcTrk->GetPy(), pMcTrk->GetPx()));
1284 
1285  // Physics coord mapping, 1 per particle type
1286  Int_t iPdgCode = pMcTrk->GetPdgCode();
1287  Int_t iPartIdx = -1;
1288  for (Int_t iPart = 0; iPart < kiNbPart; iPart++)
1289  if (kiPartPdgCode[iPart] == iPdgCode) {
1290  iPartIdx = iPart;
1291  break;
1292  } // if( kiPartPdgCode[iPart] == iPdgCode )
1293  if (-1 == iPartIdx) iPartIdx = 0;
1294 
1295  // Dependence of Track origin on centrality or position
1296  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTof)) {
1297  if (kTRUE == fbCentDepOn) {
1298  fvhTrackAllStartZCent[iPartIdx]->Fill(pMcTrk->GetStartZ(),
1299  fMCEventHeader->GetB());
1300  if (2 == iPartIdx) // 3D plot only for e-
1301  fvhTrackAllStartXZCent[iPartIdx]->Fill(
1302  pMcTrk->GetStartX(), pMcTrk->GetStartZ(), fMCEventHeader->GetB());
1303  } // if( kTRUE == fbCentDepOn )
1304  fvhTrackAllStartXZ[iPartIdx]->Fill(pMcTrk->GetStartZ(),
1305  pMcTrk->GetStartX());
1306  fvhTrackAllStartYZ[iPartIdx]->Fill(pMcTrk->GetStartZ(),
1307  pMcTrk->GetStartY());
1308  }
1309 
1310  if (-1 == pMcTrk->GetMotherId()) {
1311  // primary track
1312  // Phase space
1313  fvhPtmRapGenTrk[iPartIdx]->Fill(pMcTrk->GetRapidity(),
1314  pMcTrk->GetPt() / pMcTrk->GetMass());
1315  // PLab
1316  fvhPlabGenTrk[iPartIdx]->Fill(pMcTrk->GetP());
1317  // Do the same for tracks within STS acceptance
1318  if (kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts)) {
1319  fvhPtmRapStsPnt[iPartIdx]->Fill(pMcTrk->GetRapidity(),
1320  pMcTrk->GetPt() / pMcTrk->GetMass());
1321  fvhPlabStsPnt[iPartIdx]->Fill(pMcTrk->GetP());
1322  } // if( 0 < pMcTrk->GetNPoints(ECbmModuleId::kSts) )
1323  // Do the same for tracks within STS acceptance
1324  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTof)) {
1325  fvhPtmRapGenTrkTofPnt[iPartIdx]->Fill(
1326  pMcTrk->GetRapidity(), pMcTrk->GetPt() / pMcTrk->GetMass());
1327  fvhPlabGenTrkTofPnt[iPartIdx]->Fill(pMcTrk->GetP());
1328 
1329  if (kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts))
1330  fvhPlabStsTrkTofPnt[iPartIdx]->Fill(pMcTrk->GetP());
1331  } // if( 0 < pMcTrk->GetNPoints(ECbmModuleId::kTof) )
1332  } // if( -1 == pMcTrk->GetMotherId() )
1333  else {
1334  // secondary track
1335  // Dependence of Track origin on centrality
1336  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTof) && kTRUE == fbCentDepOn)
1337  fvhTrackSecStartZCent[iPartIdx]->Fill(pMcTrk->GetStartZ(),
1338  fMCEventHeader->GetB());
1339 
1340  // Phase space
1341  fvhPtmRapSecGenTrk[iPartIdx]->Fill(pMcTrk->GetRapidity(),
1342  pMcTrk->GetPt() / pMcTrk->GetMass());
1343  // PLab
1344  fvhPlabSecGenTrk[iPartIdx]->Fill(pMcTrk->GetP());
1345  // Do the same for tracks within STS acceptance
1346  if (kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts)) {
1347  fvhPtmRapSecStsPnt[iPartIdx]->Fill(pMcTrk->GetRapidity(),
1348  pMcTrk->GetPt() / pMcTrk->GetMass());
1349  fvhPlabSecStsPnt[iPartIdx]->Fill(pMcTrk->GetP());
1350  } // if( 0 < pMcTrk->GetNPoints(ECbmModuleId::kSts) )
1351  // Do the same for tracks within STS acceptance
1352  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTof)) {
1353  fvhPtmRapSecGenTrkTofPnt[iPartIdx]->Fill(
1354  pMcTrk->GetRapidity(), pMcTrk->GetPt() / pMcTrk->GetMass());
1355  fvhPlabSecGenTrkTofPnt[iPartIdx]->Fill(pMcTrk->GetP());
1356 
1357  if (kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts))
1358  fvhPlabSecStsTrkTofPnt[iPartIdx]->Fill(pMcTrk->GetP());
1359  } // if( 0 < pMcTrk->GetNPoints(ECbmModuleId::kTof) )
1360  } // else of if( -1 == pMcTrk->GetMotherId() )
1361  } // for(Int_t iTrkInd = 0; iTrkInd < nMcTracks; iTrkInd++)
1362 
1363  // Loop over Points and map them?
1364  for (Int_t iPntInd = 0; iPntInd < iNbTofPts; iPntInd++) {
1365  // Get a pointer to the TOF point
1366  pTofPoint = (CbmTofPoint*) fTofPointsColl->At(iPntInd);
1367  // Get a pointer to the corresponding MC Track
1368  pMcTrk = (CbmMCTrack*) fMcTracksColl->At(pTofPoint->GetTrackID());
1369 
1370  // Obtain position
1371  TVector3 vPntPos;
1372  pTofPoint->Position(vPntPos);
1373 
1374  Double_t dX = vPntPos.X();
1375  Double_t dY = vPntPos.Y();
1376  Double_t dZ = vPntPos.Z();
1377 
1378  // tracks mapping: Only when creating normalization histos
1379  // Assume only TOF in setup, no field (only straight tracks)
1380  // and all tracks reach TOF (protons)
1381  // XYZ mapping: assume tracks along Z axis
1382  if (pMcTrk->GetPz() == pMcTrk->GetP() && pMcTrk->GetStartX() == dX
1383  && pMcTrk->GetStartY() == dY) {
1384  fhTrackMapXZ->Fill(dX, dZ); // only way to get Z here?
1385  fhTrackMapYZ->Fill(dY, dZ); // only way to get Z here?
1386  } // if( pMcTrk->GetPz() == pMcTrk->GetP() )
1387 
1388  fhPointMapXY->Fill(dX, dY);
1389  fhPointMapXZ->Fill(dX, dZ);
1390  fhPointMapYZ->Fill(dY, dZ);
1391 
1392  Double_t dThetaX = TMath::ATan2(dX, dZ) * 180.0 / TMath::Pi();
1393  Double_t dThetaY = TMath::ATan2(dY, dZ) * 180.0 / TMath::Pi();
1394  fhPointMapAng->Fill(dThetaX, dThetaY);
1395 
1396  if (-1 == pMcTrk->GetMotherId()) {
1397  // primary track
1398  if (kiMinNbStsPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kSts))
1399  fhPointMapAngWithSts->Fill(dThetaX, dThetaY);
1400 
1401  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kRich))
1402  fhPointMapAngWithRich->Fill(dThetaX, dThetaY);
1403 
1404  if (kiMinNbMuchPntAcc <= pMcTrk->GetNPoints(ECbmModuleId::kMuch))
1405  fhPointMapAngWithMuch->Fill(dThetaX, dThetaY);
1406 
1407  if (0 < pMcTrk->GetNPoints(ECbmModuleId::kTrd))
1408  fhPointMapAngWithTrd->Fill(dThetaX, dThetaY);
1409  } // if( -1 == pMcTrk->GetMotherId() )
1410 
1411  Double_t dTheta =
1412  TMath::ATan2(TMath::Sqrt(dX * dX + dY * dY), dZ); // *180.0/TMath::Pi();
1413  Double_t dPhi = TMath::ATan2(dY, dX); // *180.0/TMath::Pi();
1414  fhPointMapSph->Fill(dTheta, dPhi);
1415 
1416  // Errors relative to spherical approx
1417  if (kTRUE == fbSphAppOn) {
1418  // Radius error (distance from target)
1419  Double_t dSphereRadius =
1420  fdWallPosZ + 115; // Make constant a user parameter!!!
1421  Double_t dRadiusError =
1422  TMath::Sqrt(dX * dX + dY * dY + dZ * dZ) - dSphereRadius;
1423  fhPointSphAprRadiusErrMapXY->Fill(dX, dY, dRadiusError);
1424  fhPointSphAprRadiusErrMapXZ->Fill(dX, dZ, dRadiusError);
1425  fhPointSphAprRadiusErrMapYZ->Fill(dY, dZ, dRadiusError);
1426  fhPointSphAprRadiusErrMapAng->Fill(dThetaX, dThetaY, dRadiusError);
1427  fhPointSphAprRadiusErrMapSph->Fill(dTheta, dPhi, dRadiusError);
1428  // Z position error
1429  Double_t dZposErr =
1430  dZ
1431  - TMath::Sqrt(dX * dX + dY * dY)
1432  / TMath::Tan(
1433  TMath::ASin(TMath::Sqrt(dX * dX + dY * dY) / dSphereRadius));
1434  fhPointSphAprZposErrMapXY->Fill(dX, dY, dZposErr);
1435  fhPointSphAprZposErrMapXZ->Fill(dX, dZ, dZposErr);
1436  fhPointSphAprZposErrMapYZ->Fill(dY, dZ, dZposErr);
1437  fhPointSphAprZposErrMapAng->Fill(dThetaX, dThetaY, dZposErr);
1438  fhPointSphAprZposErrMapSph->Fill(dTheta, dPhi, dZposErr);
1439  } // if( kTRUE == fbSphAppOn )
1440 
1441  // Physics coord mapping, 1 per particle type
1442  Int_t iPdgCode = pMcTrk->GetPdgCode();
1443  Int_t iPartIdx = -1;
1444  for (Int_t iPart = 0; iPart < kiNbPart; iPart++)
1445  if (kiPartPdgCode[iPart] == iPdgCode) {
1446  iPartIdx = iPart;
1447  break;
1448  } // if( kiPartPdgCode[iPart] == iPdgCode )
1449  if (-1 == iPartIdx) iPartIdx = 0;
1450 
1451  // Beam pipe check
1452  if (kTRUE == fbCentDepOn)
1453  fvhTofPntAllAngCent[iPartIdx]->Fill(
1454  dThetaX, dThetaY, fMCEventHeader->GetB());
1455 
1456  if (-1 == pMcTrk->GetMotherId()) {
1457  // primary track
1458  // Phase space
1459  fvhPtmRapTofPnt[iPartIdx]->Fill(pMcTrk->GetRapidity(),
1460  pMcTrk->GetPt() / pMcTrk->GetMass());
1461  // PLab
1462  fvhPlabTofPnt[iPartIdx]->Fill(pMcTrk->GetP());
1463  } // if( -1 == pMcTrk->GetMotherId() )
1464  else {
1465  // secondary track
1466  // Phase space
1467  fvhPtmRapSecTofPnt[iPartIdx]->Fill(pMcTrk->GetRapidity(),
1468  pMcTrk->GetPt() / pMcTrk->GetMass());
1469  // PLab
1470  fvhPlabSecTofPnt[iPartIdx]->Fill(pMcTrk->GetP());
1471  } // else of if( -1 == pMcTrk->GetMotherId() )
1472  } // for (Int_t iPntInd = 0; iPntInd < nTofPoint; iPntInd++ )
1473 
1474  // Loop over Real Points and map them, only in case of protons
1475  if (kTRUE == fbRealPointAvail)
1476  for (Int_t iPntInd = 0; iPntInd < iNbTofRealPts; iPntInd++) {
1477  // Get a pointer to the TOF point
1478  pTofPoint = (CbmTofPoint*) fRealTofPointsColl->At(iPntInd);
1479  // Get a pointer to the corresponding MC Track
1480  pMcTrk = (CbmMCTrack*) fMcTracksColl->At(pTofPoint->GetTrackID());
1481 
1482  // Physics coord mapping, 1 per particle type
1483  // Int_t iPdgCode = pMcTrk->GetPdgCode();
1484  // if( 2212 == iPdgCode ) // Protons cut, comment to get all
1485  {
1486  // Obtain position
1487  TVector3 vPntPos;
1488  pTofPoint->Position(vPntPos);
1489 
1490  Double_t dX = vPntPos.X();
1491  Double_t dY = vPntPos.Y();
1492  Double_t dZ = vPntPos.Z();
1493 
1494  fhRealPointMapXY->Fill(dX, dY);
1495  fhRealPointMapXZ->Fill(dX, dZ);
1496  fhRealPointMapYZ->Fill(dY, dZ);
1497 
1498  Double_t dThetaX = TMath::ATan2(dX, dZ) * 180.0 / TMath::Pi();
1499  Double_t dThetaY = TMath::ATan2(dY, dZ) * 180.0 / TMath::Pi();
1500  fhRealPointMapAng->Fill(dThetaX, dThetaY);
1501 
1502  Double_t dTheta = TMath::ATan2(TMath::Sqrt(dX * dX + dY * dY),
1503  dZ); // *180.0/TMath::Pi();
1504  Double_t dPhi = TMath::ATan2(dY, dX); // *180.0/TMath::Pi();
1505  fhRealPointMapSph->Fill(dTheta, dPhi);
1506  } // if( 2212 == iPdgCode )
1507  } // for (Int_t iPntInd = 0; iPntInd < iNbTofRealPts; iPntInd++ )
1508 
1509  return kTRUE;
1510 }
1511 // ------------------------------------------------------------------
1512 
1513 Bool_t CbmTofGeometryQa::SetHistoFileName(TString sFilenameIn) {
1514  fsHistoOutFilename = sFilenameIn;
1515  return kTRUE;
1516 }
1517 Bool_t CbmTofGeometryQa::WriteHistos() {
1518  // TODO: add sub-folders ?
1519 
1520  // Write histogramms to the file
1521  TDirectory* oldir = gDirectory;
1522  TFile* fHist = new TFile(fsHistoOutFilename, "RECREATE");
1523  fHist->cd();
1524 
1525  // Mapping
1526  TDirectory* cdGeomMap = fHist->mkdir("GeomMap");
1527  cdGeomMap->cd(); // make the "GeomMap" directory the current directory
1528  fhTrackMapXY->Write();
1529  fhTrackMapXZ->Write();
1530  fhTrackMapYZ->Write();
1531  fhTrackMapAng->Write();
1532  fhTrackMapSph->Write();
1533 
1534  fhTrackMapAngPrimAll->Write();
1535  fhTrackMapAngPrimSts->Write();
1536  fhTrackMapAngPrimRich->Write();
1537  fhTrackMapAngPrimMuch->Write();
1538  fhTrackMapAngPrimTrd->Write();
1539  fhTrackMapAngPrimTof->Write();
1540 
1541  fhPointMapXY->Write();
1542  fhPointMapXZ->Write();
1543  fhPointMapYZ->Write();
1544  fhPointMapAng->Write();
1545  fhPointMapSph->Write();
1546  fhRealPointMapXY->Write();
1547  fhRealPointMapXZ->Write();
1548  fhRealPointMapYZ->Write();
1549  fhRealPointMapAng->Write();
1550  fhRealPointMapSph->Write();
1551 
1552  fhPointMapAngWithSts->Write();
1553  fhPointMapAngWithRich->Write();
1554  fhPointMapAngWithMuch->Write();
1555  fhPointMapAngWithTrd->Write();
1556 
1557  // Errors relative to spherical approx
1558  if (kTRUE == fbSphAppOn) {
1559  TDirectory* cdSphApprox = fHist->mkdir("SphApprox");
1560  cdSphApprox->cd(); // make the "SphApprox" directory the current directory
1561  fhPointSphAprRadiusErrMapXY->Write();
1562  fhPointSphAprRadiusErrMapXZ->Write();
1563  fhPointSphAprRadiusErrMapYZ->Write();
1564  fhPointSphAprRadiusErrMapAng->Write();
1565  fhPointSphAprRadiusErrMapSph->Write();
1566  fhPointSphAprZposErrMapXY->Write();
1567  fhPointSphAprZposErrMapXZ->Write();
1568  fhPointSphAprZposErrMapYZ->Write();
1569  fhPointSphAprZposErrMapAng->Write();
1570  fhPointSphAprZposErrMapSph->Write();
1571 
1572  fHist->cd(); // make the file root the current directory
1573  } // if( kTRUE == fbSphAppOn )
1574 
1575  TDirectory* cdStartZ = fHist->mkdir("StartZ");
1576  cdStartZ->cd(); // make the "MixMap" directory the current directory
1577  // Dependence of Track origin on centrality
1578  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
1579  if (kTRUE == fbCentDepOn) {
1580  fvhTrackAllStartZCent[iPartIdx]->Write();
1581  fvhTrackSecStartZCent[iPartIdx]->Write();
1582  if (2 == iPartIdx) // 3D plot only for e-
1583  fvhTrackAllStartXZCent[iPartIdx]->Write();
1584  fvhTofPntAllAngCent[iPartIdx]->Write();
1585  } // if( kTRUE == fbCentDepOn )
1586  fvhTrackAllStartXZ[iPartIdx]->Write();
1587  fvhTrackAllStartYZ[iPartIdx]->Write();
1588  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
1589 
1590  TDirectory* cdPhysMap = fHist->mkdir("PhysMap");
1591  cdPhysMap->cd(); // make the "PhysMap" directory the current directory
1592  // Physics coord mapping, 1 per particle type
1593  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
1594  // Phase space
1595  fvhPtmRapGenTrk[iPartIdx]->Write();
1596  fvhPtmRapStsPnt[iPartIdx]->Write();
1597  fvhPtmRapTofPnt[iPartIdx]->Write();
1598  // PLab
1599  fvhPlabGenTrk[iPartIdx]->Write();
1600  fvhPlabStsPnt[iPartIdx]->Write();
1601  fvhPlabTofPnt[iPartIdx]->Write();
1602  // MC Tracks losses
1603  fvhPtmRapGenTrkTofPnt[iPartIdx]->Write();
1604  fvhPlabGenTrkTofPnt[iPartIdx]->Write();
1605  fvhPlabStsTrkTofPnt[iPartIdx]->Write();
1606  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
1607 
1608  TDirectory* cdPhysMapSec = fHist->mkdir("PhysMapSec");
1609  cdPhysMapSec->cd(); // make the "PhysMap" directory the current directory
1610  // Physics coord mapping, 1 per particle type
1611  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
1612  // Phase space
1613  fvhPtmRapSecGenTrk[iPartIdx]->Write();
1614  fvhPtmRapSecStsPnt[iPartIdx]->Write();
1615  fvhPtmRapSecTofPnt[iPartIdx]->Write();
1616  // PLab
1617  fvhPlabSecGenTrk[iPartIdx]->Write();
1618  fvhPlabSecStsPnt[iPartIdx]->Write();
1619  fvhPlabSecTofPnt[iPartIdx]->Write();
1620  // MC Tracks losses
1621  fvhPtmRapSecGenTrkTofPnt[iPartIdx]->Write();
1622  fvhPlabSecGenTrkTofPnt[iPartIdx]->Write();
1623  fvhPlabSecStsTrkTofPnt[iPartIdx]->Write();
1624  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
1625 
1626  fHist->cd(); // make the file root the current directory
1627 
1628  gDirectory->cd(oldir->GetPath());
1629 
1630  fHist->Close();
1631 
1632  return kTRUE;
1633 }
1634 Bool_t CbmTofGeometryQa::DeleteHistos() {
1635  // Mapping
1636  // Physics coord mapping, 1 per particle type
1637  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
1638  if (kTRUE == fbCentDepOn) {
1639  delete fvhTrackAllStartZCent[iPartIdx];
1640  delete fvhTrackSecStartZCent[iPartIdx];
1641  if (2 == iPartIdx) // 3D plot only for e-
1642  delete fvhTrackAllStartXZCent[iPartIdx];
1643  delete fvhTofPntAllAngCent[iPartIdx];
1644  } // if( kTRUE == fbCentDepOn )
1645  delete fvhTrackAllStartXZ[iPartIdx];
1646  delete fvhTrackAllStartYZ[iPartIdx];
1647  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
1648  if (kTRUE == fbCentDepOn) {
1649  fvhTrackAllStartZCent.clear();
1650  fvhTrackSecStartZCent.clear();
1651  fvhTrackAllStartXZCent.clear();
1652  fvhTofPntAllAngCent.clear();
1653  } // if( kTRUE == fbCentDepOn )
1654  fvhTrackAllStartXZ.clear();
1655  fvhTrackAllStartYZ.clear();
1656 
1657  delete fhTrackMapXY;
1658  delete fhTrackMapXZ;
1659  delete fhTrackMapYZ;
1660  delete fhTrackMapAng;
1661  delete fhTrackMapSph;
1662 
1663  delete fhTrackMapAngPrimAll;
1664  delete fhTrackMapAngPrimSts;
1665  delete fhTrackMapAngPrimRich;
1666  delete fhTrackMapAngPrimMuch;
1667  delete fhTrackMapAngPrimTrd;
1668  delete fhTrackMapAngPrimTof;
1669 
1670  delete fhPointMapXY;
1671  delete fhPointMapXZ;
1672  delete fhPointMapYZ;
1673  delete fhPointMapAng;
1674  delete fhPointMapSph;
1675  delete fhRealPointMapXY;
1676  delete fhRealPointMapXZ;
1677  delete fhRealPointMapYZ;
1678  delete fhRealPointMapAng;
1679  delete fhRealPointMapSph;
1680 
1681  delete fhPointMapAngWithSts;
1682  delete fhPointMapAngWithRich;
1683  delete fhPointMapAngWithMuch;
1684  delete fhPointMapAngWithTrd;
1685 
1686  if (kTRUE == fbSphAppOn) {
1687  delete fhPointSphAprRadiusErrMapXY;
1688  delete fhPointSphAprRadiusErrMapXZ;
1689  delete fhPointSphAprRadiusErrMapYZ;
1690  delete fhPointSphAprRadiusErrMapAng;
1691  delete fhPointSphAprRadiusErrMapSph;
1692  delete fhPointSphAprZposErrMapXY;
1693  delete fhPointSphAprZposErrMapXZ;
1694  delete fhPointSphAprZposErrMapYZ;
1695  delete fhPointSphAprZposErrMapAng;
1696  delete fhPointSphAprZposErrMapSph;
1697  } // if( kTRUE == fbSphAppOn )
1698 
1699  // Physics coord mapping, 1 per particle type
1700  for (Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++) {
1701  // Phase space
1702  delete fvhPtmRapGenTrk[iPartIdx];
1703  delete fvhPtmRapStsPnt[iPartIdx];
1704  delete fvhPtmRapTofPnt[iPartIdx];
1705  // PLab
1706  delete fvhPlabGenTrk[iPartIdx];
1707  delete fvhPlabStsPnt[iPartIdx];
1708  delete fvhPlabTofPnt[iPartIdx];
1709  // MC Tracks losses
1710  delete fvhPtmRapGenTrkTofPnt[iPartIdx];
1711  delete fvhPlabGenTrkTofPnt[iPartIdx];
1712 
1713  // Secondary tracks
1714  // Phase space
1715  delete fvhPtmRapSecGenTrk[iPartIdx];
1716  delete fvhPtmRapSecStsPnt[iPartIdx];
1717  delete fvhPtmRapSecTofPnt[iPartIdx];
1718  // PLab
1719  delete fvhPlabSecGenTrk[iPartIdx];
1720  delete fvhPlabSecStsPnt[iPartIdx];
1721  delete fvhPlabSecTofPnt[iPartIdx];
1722  // MC Tracks losses
1723  delete fvhPtmRapSecGenTrkTofPnt[iPartIdx];
1724  delete fvhPlabSecGenTrkTofPnt[iPartIdx];
1725  delete fvhPlabSecStsTrkTofPnt[iPartIdx];
1726  } // for( Int_t iPartIdx = 0; iPartIdx < kiNbPart; iPartIdx++)
1727  // Phase space
1728  fvhPtmRapGenTrk.clear();
1729  fvhPtmRapStsPnt.clear();
1730  fvhPtmRapTofPnt.clear();
1731  // PLab
1732  fvhPlabGenTrk.clear();
1733  fvhPlabStsPnt.clear();
1734  fvhPlabTofPnt.clear();
1735  // MC Tracks losses
1736  fvhPtmRapGenTrkTofPnt.clear();
1737  fvhPlabGenTrkTofPnt.clear();
1738  fvhPlabStsTrkTofPnt.clear();
1739 
1740  // Secondary tracks
1741  // Phase space
1742  fvhPtmRapSecGenTrk.clear();
1743  fvhPtmRapSecStsPnt.clear();
1744  fvhPtmRapSecTofPnt.clear();
1745  // PLab
1746  fvhPlabSecGenTrk.clear();
1747  fvhPlabSecStsPnt.clear();
1748  fvhPlabSecTofPnt.clear();
1749  // MC Tracks losses
1750  fvhPtmRapSecGenTrkTofPnt.clear();
1751  fvhPlabSecGenTrkTofPnt.clear();
1752  fvhPlabSecStsTrkTofPnt.clear();
1753 
1754  return kTRUE;
1755 }
1756 
1757 
1758 ClassImp(CbmTofGeometryQa);
CbmTofGeometryQa::fhPointSphAprZposErrMapSph
TProfile2D * fhPointSphAprZposErrMapSph
Definition: CbmTofGeometryQa.h:165
CbmTofGeometryQa::fTofId
CbmTofDetectorId * fTofId
Definition: CbmTofGeometryQa.h:79
CbmMCTrack::GetMotherId
Int_t GetMotherId() const
Definition: CbmMCTrack.h:71
CbmTofGeoHandler::GetGeoVersion
Int_t GetGeoVersion()
Definition: CbmTofGeoHandler.h:45
CbmMCTrack::GetMass
Double_t GetMass() const
Mass of the associated particle.
Definition: CbmMCTrack.cxx:114
CbmTofGeometryQa::RegisterInputs
Bool_t RegisterInputs()
Definition: CbmTofGeometryQa.cxx:380
CbmTofGeometryQa::fvhTrackAllStartZCent
std::vector< TH2 * > fvhTrackAllStartZCent
Definition: CbmTofGeometryQa.h:111
CbmMCTrack::GetStartX
Double_t GetStartX() const
Definition: CbmMCTrack.h:75
CbmTofGeometryQa::fvhTofPntAllAngCent
std::vector< TH3 * > fvhTofPntAllAngCent
Definition: CbmTofGeometryQa.h:117
CbmTofGeometryQa::fhPointSphAprZposErrMapXY
TProfile2D * fhPointSphAprZposErrMapXY
Definition: CbmTofGeometryQa.h:161
CbmTofGeometryQa::fhPointMapAngWithRich
TH2 * fhPointMapAngWithRich
Definition: CbmTofGeometryQa.h:150
CbmTofGeometryQa::fRealTofPointsColl
TClonesArray * fRealTofPointsColl
Definition: CbmTofGeometryQa.h:98
CbmTofGeometryQa::fhPointMapAngWithTrd
TH2 * fhPointMapAngWithTrd
Definition: CbmTofGeometryQa.h:152
CbmTofGeometryQa::fvhPtmRapTofPnt
std::vector< TH2 * > fvhPtmRapTofPnt
Definition: CbmTofGeometryQa.h:172
CbmTofGeometryQa::fhPointSphAprRadiusErrMapSph
TProfile2D * fhPointSphAprRadiusErrMapSph
Definition: CbmTofGeometryQa.h:160
CbmTofGeometryQa::fhTrackMapAngPrimSts
TH2 * fhTrackMapAngPrimSts
Definition: CbmTofGeometryQa.h:126
CbmTofGeometryQa::fhPointSphAprZposErrMapYZ
TProfile2D * fhPointSphAprZposErrMapYZ
Definition: CbmTofGeometryQa.h:163
CbmTofGeometryQa::DeleteHistos
Bool_t DeleteHistos()
Definition: CbmTofGeometryQa.cxx:1634
CbmTofGeometryQa::fvhPlabSecStsTrkTofPnt
std::vector< TH1 * > fvhPlabSecStsTrkTofPnt
Definition: CbmTofGeometryQa.h:196
CbmTofGeometryQa::fvhPlabGenTrkTofPnt
std::vector< TH1 * > fvhPlabGenTrkTofPnt
Definition: CbmTofGeometryQa.h:191
CbmTofGeometryQa::fvhPlabTofPnt
std::vector< TH1 * > fvhPlabTofPnt
Definition: CbmTofGeometryQa.h:182
CbmTofGeometryQa::LoadGeometry
Bool_t LoadGeometry()
Load the geometry: for now just resizing the Digis temporary vectors.
Definition: CbmTofGeometryQa.cxx:416
CbmMCTrack::GetPdgCode
Int_t GetPdgCode() const
Definition: CbmMCTrack.h:70
CbmTofGeometryQa::fvhPlabSecGenTrk
std::vector< TH1 * > fvhPlabSecGenTrk
Definition: CbmTofGeometryQa.h:184
CbmTofGeometryQa::fsHistoOutFilename
TString fsHistoOutFilename
Definition: CbmTofGeometryQa.h:105
CbmTofGeometryQa::fRealTofMatchColl
TClonesArray * fRealTofMatchColl
Definition: CbmTofGeometryQa.h:100
CbmTofGeometryQa::fhPointMapAng
TH2 * fhPointMapAng
Definition: CbmTofGeometryQa.h:142
CbmTofGeometryQa::fMCEventHeader
FairMCEventHeader * fMCEventHeader
Definition: CbmTofGeometryQa.h:94
CbmTofGeometryQa::SetParContainers
virtual void SetParContainers()
Inherited from FairTask.
Definition: CbmTofGeometryQa.cxx:344
CbmTofGeometryQa::SetHistoFileName
Bool_t SetHistoFileName(TString sFilenameIn)
Definition: CbmTofGeometryQa.cxx:1513
CbmTofGeometryQa::fbCentDepOn
Bool_t fbCentDepOn
Definition: CbmTofGeometryQa.h:109
CbmTofGeometryQa::fhTrackMapSph
TH2 * fhTrackMapSph
Definition: CbmTofGeometryQa.h:124
CbmTofGeometryQa::fhPointSphAprRadiusErrMapYZ
TProfile2D * fhPointSphAprRadiusErrMapYZ
Definition: CbmTofGeometryQa.h:158
CbmTofDetectorId_v12b
Definition: CbmTofDetectorId_v12b.h:33
CbmTofGeometryQa::fMcTracksColl
TClonesArray * fMcTracksColl
Definition: CbmTofGeometryQa.h:97
CbmTofGeometryQa::fhPointMapSph
TH2 * fhPointMapSph
Definition: CbmTofGeometryQa.h:143
CbmMCTrack::GetPx
Double_t GetPx() const
Definition: CbmMCTrack.h:72
CbmMCTrack::GetPy
Double_t GetPy() const
Definition: CbmMCTrack.h:73
ECbmModuleId::kTof
@ kTof
Time-of-flight Detector.
CbmTofGeometryQa::fvhPtmRapSecStsPnt
std::vector< TH2 * > fvhPtmRapSecStsPnt
Definition: CbmTofGeometryQa.h:175
CbmMatch.h
CbmTofGeometryQa::fhPointSphAprZposErrMapXZ
TProfile2D * fhPointSphAprZposErrMapXZ
Definition: CbmTofGeometryQa.h:162
CbmTofGeometryQa::fhRealPointMapXZ
TH2 * fhRealPointMapXZ
Definition: CbmTofGeometryQa.h:145
CbmTofGeometryQa::fTofPointsColl
TClonesArray * fTofPointsColl
Definition: CbmTofGeometryQa.h:96
CbmTofGeometryQa::fhTrackMapAngPrimRich
TH2 * fhTrackMapAngPrimRich
Definition: CbmTofGeometryQa.h:127
CbmTofGeometryQa::fEvents
Int_t fEvents
Definition: CbmTofGeometryQa.h:75
CbmTofGeometryQa::CreateHistos
Bool_t CreateHistos()
Definition: CbmTofGeometryQa.cxx:471
CbmTofGeoHandler.h
CbmTofGeometryQa::fvhTrackSecStartZCent
std::vector< TH2 * > fvhTrackSecStartZCent
Definition: CbmTofGeometryQa.h:113
CbmTofDetectorId_v14a.h
CbmMCTrack::GetStartZ
Double_t GetStartZ() const
Definition: CbmMCTrack.h:77
CbmTofGeometryQa::fhRealPointMapXY
TH2 * fhRealPointMapXY
Definition: CbmTofGeometryQa.h:144
CbmTofGeometryQa::fhRealPointMapSph
TH2 * fhRealPointMapSph
Definition: CbmTofGeometryQa.h:148
CbmTofGeometryQa::fvhPlabSecTofPnt
std::vector< TH1 * > fvhPlabSecTofPnt
Definition: CbmTofGeometryQa.h:186
CbmTofGeometryQa::fvhPtmRapSecGenTrkTofPnt
std::vector< TH2 * > fvhPtmRapSecGenTrkTofPnt
Definition: CbmTofGeometryQa.h:194
kiPartPdgCode
const Int_t kiPartPdgCode[kiNbPart]
Definition: CbmTofGeometryQa.cxx:59
CbmMCTrack::GetNPoints
Int_t GetNPoints(ECbmModuleId detId) const
Definition: CbmMCTrack.cxx:186
CbmTofGeometryQa::fhRealPointMapAng
TH2 * fhRealPointMapAng
Definition: CbmTofGeometryQa.h:147
CbmTofGeometryQa::fvhPlabSecStsPnt
std::vector< TH1 * > fvhPlabSecStsPnt
Definition: CbmTofGeometryQa.h:185
CbmTofGeoHandler
Definition: CbmTofGeoHandler.h:30
CbmTofGeometryQa::fvhPlabStsTrkTofPnt
std::vector< TH1 * > fvhPlabStsTrkTofPnt
Definition: CbmTofGeometryQa.h:192
k12b
@ k12b
Definition: CbmTofGeoHandler.h:17
CbmTofGeometryQa::Init
virtual InitStatus Init()
Definition: CbmTofGeometryQa.cxx:309
CbmTofDetectorId_v12b.h
CbmTofGeometryQa
QA class for the TOF event based Hit finder tasks (clusterizers, ...)
Definition: CbmTofGeometryQa.h:34
k14a
@ k14a
Definition: CbmTofGeoHandler.h:17
CbmTofGeometryQa::fvhPlabGenTrk
std::vector< TH1 * > fvhPlabGenTrk
Definition: CbmTofGeometryQa.h:180
CbmTofAddress.h
kiMinNbMuchPntAcc
const Int_t kiMinNbMuchPntAcc
Definition: CbmTofGeometryQa.cxx:87
CbmTofDetectorId_v14a
Definition: CbmTofDetectorId_v14a.h:36
ECbmModuleId::kRich
@ kRich
Ring-Imaging Cherenkov Detector.
CbmTofGeoHandler::Init
Int_t Init(Bool_t isSimulation=kFALSE)
Definition: CbmTofGeoHandler.cxx:39
CbmTofGeometryQa::fhPointMapXY
TH2 * fhPointMapXY
Definition: CbmTofGeometryQa.h:139
CbmTofGeometryQa::SetWallPosZ
Bool_t SetWallPosZ(Double_t dWallPosCm=1000)
Definition: CbmTofGeometryQa.cxx:464
CbmTofGeometryQa::fhTrackMapXZ
TH2 * fhTrackMapXZ
Definition: CbmTofGeometryQa.h:121
xMath::Pi
double Pi()
Definition: xMath.h:5
CbmTofCell.h
CbmTofGeometryQa::fhTrackMapXY
TH2 * fhTrackMapXY
Definition: CbmTofGeometryQa.h:120
CbmMCTrack::GetPt
Double_t GetPt() const
Definition: CbmMCTrack.h:99
CbmTofGeometryQa::fhTrackMapAngPrimTof
TH2 * fhTrackMapAngPrimTof
Definition: CbmTofGeometryQa.h:130
CbmTofGeometryQa::fGeoHandler
CbmTofGeoHandler * fGeoHandler
Definition: CbmTofGeometryQa.h:78
ECbmModuleId::kTrd
@ kTrd
Transition Radiation Detector.
CbmTofGeometryQa::fhPointSphAprRadiusErrMapXY
TProfile2D * fhPointSphAprRadiusErrMapXY
Definition: CbmTofGeometryQa.h:156
CbmTofGeometryQa::fvhPtmRapGenTrk
std::vector< TH2 * > fvhPtmRapGenTrk
Definition: CbmTofGeometryQa.h:170
CbmTofGeometryQa::fhTrackMapAngPrimAll
TH2 * fhTrackMapAngPrimAll
Definition: CbmTofGeometryQa.h:125
CbmMCTrack::GetRapidity
Double_t GetRapidity() const
Definition: CbmMCTrack.cxx:177
CbmTofGeometryQa::fvhTrackAllStartXZ
std::vector< TH2 * > fvhTrackAllStartXZ
Definition: CbmTofGeometryQa.h:118
CbmMCTrack::GetStartY
Double_t GetStartY() const
Definition: CbmMCTrack.h:76
CbmTofGeometryQa::Finish
virtual void Finish()
Definition: CbmTofGeometryQa.cxx:368
CbmMCTrack.h
CbmTofGeometryQa::fvhPtmRapGenTrkTofPnt
std::vector< TH2 * > fvhPtmRapGenTrkTofPnt
Definition: CbmTofGeometryQa.h:190
CbmTofGeometryQa::fvhTrackAllStartYZ
std::vector< TH2 * > fvhTrackAllStartYZ
Definition: CbmTofGeometryQa.h:119
CbmTofGeometryQa::fhTrackMapYZ
TH2 * fhTrackMapYZ
Definition: CbmTofGeometryQa.h:122
CbmTofGeometryQa::Exec
virtual void Exec(Option_t *option)
Definition: CbmTofGeometryQa.cxx:354
CbmTofGeometryQa::fhPointMapXZ
TH2 * fhPointMapXZ
Definition: CbmTofGeometryQa.h:140
CbmTofGeometryQa::fhPointSphAprZposErrMapAng
TProfile2D * fhPointSphAprZposErrMapAng
Definition: CbmTofGeometryQa.h:164
CbmMCTrack
Definition: CbmMCTrack.h:34
kiNbPart
const Int_t kiNbPart
Definition: CbmTofGeometryQa.cxx:45
CbmTofGeometryQa::fdWallPosZ
Double_t fdWallPosZ
Definition: CbmTofGeometryQa.h:107
CbmTofPoint.h
CbmTofGeometryQa::~CbmTofGeometryQa
virtual ~CbmTofGeometryQa()
Definition: CbmTofGeometryQa.cxx:303
CbmTofGeometryQa::fhPointMapAngWithSts
TH2 * fhPointMapAngWithSts
Definition: CbmTofGeometryQa.h:149
CbmTofGeometryQa::fhPointMapYZ
TH2 * fhPointMapYZ
Definition: CbmTofGeometryQa.h:141
CbmTofGeometryQa::fvhPlabStsPnt
std::vector< TH1 * > fvhPlabStsPnt
Definition: CbmTofGeometryQa.h:181
ClassImp
ClassImp(CbmTofGeometryQa)
CbmTofGeometryQa::fvhPtmRapStsPnt
std::vector< TH2 * > fvhPtmRapStsPnt
Definition: CbmTofGeometryQa.h:171
CbmTofGeometryQa::fvhPtmRapSecTofPnt
std::vector< TH2 * > fvhPtmRapSecTofPnt
Definition: CbmTofGeometryQa.h:176
CbmTofGeometryQa::fhTrackMapAng
TH2 * fhTrackMapAng
Definition: CbmTofGeometryQa.h:123
CbmTofGeometryQa::CbmTofGeometryQa
CbmTofGeometryQa()
Definition: CbmTofGeometryQa.cxx:99
ksPartTag
const TString ksPartTag[kiNbPart]
Definition: CbmTofGeometryQa.cxx:46
ECbmModuleId::kMuch
@ kMuch
Muon detection system.
CbmTofPoint
Geometric intersection of a MC track with a TOFb detector.
Definition: CbmTofPoint.h:40
CbmTofGeometryQa.h
CbmTofGeometryQa::fhPointSphAprRadiusErrMapAng
TProfile2D * fhPointSphAprRadiusErrMapAng
Definition: CbmTofGeometryQa.h:159
ksPartName
const TString ksPartName[kiNbPart]
Definition: CbmTofGeometryQa.cxx:72
CbmTofGeometryQa::fvhPlabSecGenTrkTofPnt
std::vector< TH1 * > fvhPlabSecGenTrkTofPnt
Definition: CbmTofGeometryQa.h:195
CbmTofGeometryQa::WriteHistos
Bool_t WriteHistos()
Definition: CbmTofGeometryQa.cxx:1517
CbmTofGeometryQa::fhPointMapAngWithMuch
TH2 * fhPointMapAngWithMuch
Definition: CbmTofGeometryQa.h:151
CbmTofGeometryQa::fbRealPointAvail
Bool_t fbRealPointAvail
Definition: CbmTofGeometryQa.h:101
CbmTofGeometryQa::fhRealPointMapYZ
TH2 * fhRealPointMapYZ
Definition: CbmTofGeometryQa.h:146
CbmTofGeometryQa::fhPointSphAprRadiusErrMapXZ
TProfile2D * fhPointSphAprRadiusErrMapXZ
Definition: CbmTofGeometryQa.h:157
CbmTofGeometryQa::fhTrackMapAngPrimMuch
TH2 * fhTrackMapAngPrimMuch
Definition: CbmTofGeometryQa.h:128
CbmTofGeometryQa::fvhPtmRapSecGenTrk
std::vector< TH2 * > fvhPtmRapSecGenTrk
Definition: CbmTofGeometryQa.h:174
ECbmModuleId::kSts
@ kSts
Silicon Tracking System.
CbmTofGeometryQa::fbSphAppOn
Bool_t fbSphAppOn
Definition: CbmTofGeometryQa.h:155
CbmTofGeometryQa::fvhTrackAllStartXZCent
std::vector< TH3 * > fvhTrackAllStartXZCent
Definition: CbmTofGeometryQa.h:115
CbmTofGeometryQa::FillHistos
Bool_t FillHistos()
Definition: CbmTofGeometryQa.cxx:1184
kiMinNbStsPntAcc
const Int_t kiMinNbStsPntAcc
Definition: CbmTofGeometryQa.cxx:85
CbmTofGeometryQa::fhTrackMapAngPrimTrd
TH2 * fhTrackMapAngPrimTrd
Definition: CbmTofGeometryQa.h:129
CbmMCTrack::GetP
Double_t GetP() const
Definition: CbmMCTrack.h:100
CbmMCTrack::GetPz
Double_t GetPz() const
Definition: CbmMCTrack.h:74