CbmRoot
CbmTofGeoHandler.cxx
Go to the documentation of this file.
1 // -------------------------------------------------------------------------
2 // ----- CbmTofGeoHandler source file -----
3 // ----- Created 13/08/10 by F. Uhlig -----
4 // -------------------------------------------------------------------------
5 #include "CbmTofGeoHandler.h"
6 
7 #include "CbmDefs.h" // for kTof
8 #include "CbmTofDetectorId_v07a.h" // for CbmTofDetectorId_v07a
9 #include "CbmTofDetectorId_v12b.h" // for CbmTofDetectorId_v12b
10 #include "CbmTofDetectorId_v14a.h" // for CbmTofDetectorId_v14a
11 
12 #include <FairLogger.h> // for Logger, LOG
13 
14 #include <TGeoBBox.h> // for TGeoBBox
15 #include <TGeoManager.h> // for gGeoManager, TGeoManager
16 #include <TGeoNode.h> // for TGeoNode
17 #include <TGeoVolume.h> // for TGeoVolume
18 #include <TObjArray.h> // for TObjArray
19 #include <TObject.h> // for TObject
20 #include <TVirtualMC.h> // for TVirtualMC, gMC
21 
22 #include <string.h> // for strlen, strncpy
23 
25  : TObject()
26  , fTofId(nullptr)
27  , fGeoVersion(-1)
28  , fIsSimulation(kFALSE)
29  , fMCVersion(-1)
30  , fUseNodeName(kFALSE)
31  , fLastUsedDetectorID(0)
32  , fDetectorInfoArray()
33  , fGeoPathHash(0)
34  , fCurrentVolume(nullptr)
35  , fVolumeShape(nullptr)
36  , fGlobal()
37  , fGlobalMatrix(nullptr) {}
38 
39 Int_t CbmTofGeoHandler::Init(Bool_t isSimulation) {
40  fIsSimulation = isSimulation;
41 
42  if (fIsSimulation) {
43  TString tVirtualMCName = gMC->GetName();
44 
45  if (tVirtualMCName == "TGeant3TGeo") {
46  fMCVersion = 0;
47  } else if (tVirtualMCName == "TGeant4") {
48  fMCVersion = 1;
49  } else if (tVirtualMCName == "TFluka") {
50  fMCVersion = 2;
51  } else {
52  fMCVersion = 3; // GEANE
53  }
54  }
55 
56  Int_t geoVersion = CheckGeometryVersion();
57 
58  return geoVersion;
59 }
60 
62  // Check which geometry version is used. In the moment there are 3
63  // possible geometry versions.
64  // v07a:
65  // Old TOF geometry at 10 m from target
66  // v12a:
67  // Old TOF geometry at 6 m from target. Beside the z position
68  // the geometry is the same as v07a, so it is handled in the same way
69  // v12b:
70  // New version of the tof geometrie developed by Norbert Herrmann
71  // including also a support structure
72  // v14a:
73  // test beam tof geometrie developed by Norbert Herrmann
74  if (nullptr == gGeoManager) LOG(fatal) << "No GeoManager";
75 
76  TObjArray* nodes = gGeoManager->GetTopNode()->GetNodes();
77  for (Int_t iNode = 0; iNode < nodes->GetEntriesFast(); iNode++) {
78  TGeoNode* node = (TGeoNode*) nodes->At(iNode);
79  LOG(info) << "Inspect node " << iNode << " " << node->GetName();
80  if (TString(node->GetName()).Contains("tof")) {
81  // Since there is only one tof top node we check for full node name
82  // In the old geometries v07a and v12a the name of this node is tof1_0
83  // In new geometries the node name is tof_v<year><version> eg. tof_v12b
84  // With this naming scheme the geometry version is completely qualified
85  LOG(info) << "Found TOF geometry " << TString(node->GetName());
86  if (TString(node->GetName()).EqualTo("tof1_0")) {
87  LOG(info) << "Found TOF geometry v07a";
89  fGeoVersion = k07a;
90  return fGeoVersion;
91  } else if (TString(node->GetName()).EqualTo("tof_v12b_0")) {
92  LOG(info) << "Found TOF geometry v12b.";
94  fGeoVersion = k12b;
95  return fGeoVersion;
96  } else if (TString(node->GetName()).Contains("v13")) {
97  //TString(node->GetName()).EqualTo("tof_v13-3a_0")) {
98  LOG(info) << "Found TOF geometry " << TString(node->GetName())
99  << ", treat as Id 12b ";
101  fGeoVersion = k12b;
102  return fGeoVersion;
103  } else if ((TString(node->GetName()).Contains("v14"))
104  || (TString(node->GetName()).Contains("v16a"))
105  || (TString(node->GetName()).Contains("v16c"))
106  || (TString(node->GetName()).Contains("v16d"))
107  || (TString(node->GetName()).Contains("v16e"))
108  || (TString(node->GetName()).Contains("v17a"))
109  || (TString(node->GetName()).Contains("v17c"))
110  || (TString(node->GetName()).Contains("v18"))
111  || (TString(node->GetName()).Contains("v19"))
112  || (TString(node->GetName()).Contains("v20"))) {
113  LOG(info)
114  << "CbmTofGeoHandler::CheckGeometryVersion: Found TOF geometry "
115  << TString(node->GetName()) << ", treat as Id 14a ";
116  // if(nullptr!=fTofId) fTofId->Delete();
118  fGeoVersion = k14a;
119 
120  if (TString(node->GetName()).Contains("v14a_n")) {
121  if (fIsSimulation && 0 != fMCVersion) {
122  LOG(fatal) << "Using node names instead of volume names to extract "
123  "the module type "
124  << "in a MC simulation only works with GEANT3 VMC!";
125  }
126 
127  fUseNodeName = kTRUE;
128  }
129 
130  return fGeoVersion;
131  } else {
132  LOG(fatal) << "Found an unknown TOF geometry.";
133  fGeoVersion = -1;
134  return fGeoVersion;
135  }
136  }
137  }
138  LOG(fatal) << "No TOF geometry found!";
139  fGeoVersion = -1;
140  return fGeoVersion;
141 }
142 
144  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
145  return GetUniqueDetectorId();
146 }
147 
148 
150 
151  Int_t smtype = 0;
152  Int_t smodule = 0;
153  Int_t counter = 0;
154  Int_t gap = 0;
155  Int_t cell = 0;
156  TString Volname;
157 
158 
159  if (fGeoVersion == k07a) {
160  Volname = CurrentVolName();
161  smtype = Volname[5] - '0';
163  CurrentVolOffID(1, cell);
164  CurrentVolID(gap);
165  } else if (fGeoVersion == k12b) {
166  Volname = CurrentVolOffName(4);
167  smtype = Volname[7] - '0';
168  CurrentVolOffID(4, smodule);
170  CurrentVolOffID(1, gap);
171  CurrentVolID(cell);
172  } else if (fGeoVersion == k14a) { // test beam
173  if (fUseNodeName) {
174  Volname = CurrentNodeOffName(4);
175  } else {
176  Volname = CurrentVolOffName(4);
177  }
178  smtype = Volname[7] - '0';
179  CurrentVolOffID(4, smodule);
181  CurrentVolOffID(1, gap);
182  CurrentVolID(cell);
183  // counter=smodule; // necessary for plastics
184  // smodule=smtype; // for test beam setup
185  gap = 0;
186  cell--;
187  }
188 
189  LOG(debug1) << "GeoHand: ";
190  LOG(debug1) << " Volname: " << Volname << ", " << CurrentVolOffName(3) << ", "
191  << CurrentVolOffName(2) << ", " << CurrentVolOffName(1) << ", "
192  << CurrentVolOffName(0);
193  LOG(debug1) << " SMtype: " << smtype;
194  LOG(debug1) << " SModule: " << smodule;
195  LOG(debug1) << " Counter: " << counter;
196  LOG(debug1) << " Gap: " << gap;
197  LOG(debug1) << " Cell: " << cell;
198 
199  CbmTofDetectorInfo detInfo(
200  ECbmModuleId::kTof, smtype, smodule, counter, gap, cell);
201 
202  Int_t result = fTofId->SetDetectorInfo(detInfo);
203  LOG(debug1) << " Unique ID: " << Form("0x%08x", result);
204  // return fTofId->SetDetectorInfo(detInfo);
205  return result;
206 }
207 
208 
210 
211  Int_t smtype = 0;
212  Int_t smodule = 0;
213  Int_t counter = 0;
214  Int_t gap = 0;
215  Int_t cell = 0;
216  TString Volname;
217 
218 
219  if (fGeoVersion == k07a) {
220  Volname = CurrentVolName();
221  smtype = Volname[5] - '0';
223  CurrentVolOffID(1, cell);
224  CurrentVolID(gap);
225  } else if (fGeoVersion == k12b) {
226  Volname = CurrentVolOffName(4);
227  smtype = Volname[7] - '0';
228  CurrentVolOffID(4, smodule);
230  CurrentVolOffID(1, gap);
231  CurrentVolID(cell);
232  } else if (fGeoVersion == k14a) { // test beam
233  if (fUseNodeName) {
234  Volname = CurrentNodeOffName(4);
235  } else {
236  Volname = CurrentVolOffName(4);
237  }
238  smtype = Volname[7] - '0';
239  CurrentVolOffID(4, smodule);
241  CurrentVolOffID(1, gap);
242  CurrentVolID(cell);
243  // counter=smodule; // necessary for plastics
244  // smodule=smtype; // for test beam setup
245  }
246 
247  cell = 0;
248 
250  CbmTofDetectorInfo(ECbmModuleId::kTof, smtype, smodule, counter, gap, cell);
251 
252  gap = 0;
253 
254  LOG(debug1) << "GeoHand: ";
255  LOG(debug1) << " Volname: " << Volname << ", " << CurrentVolOffName(3) << ", "
256  << CurrentVolOffName(2) << ", " << CurrentVolOffName(1) << ", "
257  << CurrentVolOffName(0);
258  LOG(debug1) << " SMtype: " << smtype;
259  LOG(debug1) << " SModule: " << smodule;
260  LOG(debug1) << " Counter: " << counter;
261  LOG(debug1) << " Gap: " << gap;
262  LOG(debug1) << " Cell: " << cell;
263 
264  CbmTofDetectorInfo detInfo(
265  ECbmModuleId::kTof, smtype, smodule, counter, gap, cell);
266 
267  Int_t result = fTofId->SetDetectorInfo(detInfo);
268  fLastUsedDetectorID = result;
269  LOG(debug1) << " Unique ID: " << Form("0x%08x", result);
270  // return fTofId->SetDetectorInfo(detInfo);
271  return result;
272 }
273 
274 /*
275 void CbmTofGeoHandler::FillInternalStructures()
276 {
277  // Extract geometry information from Virtual MC.
278  // All geometry handling should be done now in the
279  // separate utility class CbmTofGeoHandler
280 
281  Int_t stationNr = 1;
282  char volumeName[10];
283  Bool_t result;
284  Int_t MCid;
285 
286  fStationMap.clear();
287  fModuleTypeMap.clear();
288 
289  if (fGeoVersion == kNewMonolithic) {
290 
291  do {
292  sprintf(volumeName, "trd%dgas", stationNr);
293  MCid = VolId(volumeName);
294  if ( 0 != MCid) {
295  fStationMap.insert(pair<Int_t,Int_t>(MCid,stationNr));
296  }
297  stationNr++;
298  } while ( 0 != MCid);
299 
300  } else {
301 
302  do {
303  sprintf(volumeName, "trd%d", stationNr);
304  MCid = VolId(volumeName);
305  if ( 0 != MCid) {
306  fStationMap.insert(pair<Int_t,Int_t>(MCid,stationNr));
307  }
308  stationNr++;
309  }
310  while ( 0 != MCid);
311 
312  Int_t maxStationNr = --stationNr;
313 
314  Int_t maxModuleTypes;
315  if (fGeoVersion == kSegmentedSquaredOneKeepingVolume) {
316  maxModuleTypes = 8;
317  } else {
318  maxModuleTypes = 3;
319  }
320 
321  for (Int_t iStation = 1; iStation < maxStationNr; iStation++) {
322  for (Int_t iModule = 1; iModule <= maxModuleTypes; iModule++) {
323  sprintf(volumeName, "trd%dmod%d", iStation, iModule);
324  MCid = VolId(volumeName);
325  if ( 0 != MCid ) {
326  fModuleTypeMap.insert(pair<Int_t,Int_t>(MCid,iModule));
327  }
328  }
329  }
330  }
331 }
332 */
333 
334 Int_t CbmTofGeoHandler::VolIdGeo(const char* name) const {
335  //
336  // Return the unique numeric identifier for volume name
337  //
338 
339  Int_t uid = gGeoManager->GetUID(name);
340  if (uid < 0) {
341  LOG(info) << "VolId: Volume " << name << " not found";
342  return 0;
343  }
344  return uid;
345 }
346 
347 Int_t CbmTofGeoHandler::VolId(const Text_t* name) const {
348  if (fIsSimulation) {
349  return gMC->VolId(name);
350  } else {
351  //
352  // Return the unique numeric identifier for volume name
353  //
354  char sname[20];
355  Int_t len = strlen(name) - 1;
356  if (name[len] != ' ') { return VolIdGeo(name); }
357  strncpy(sname, name, len);
358  sname[len] = 0;
359  return VolIdGeo(sname);
360  }
361 }
362 
363 Int_t CbmTofGeoHandler::CurrentVolID(Int_t& copy) const {
364  if (fIsSimulation) {
365  return gMC->CurrentVolID(copy);
366  } else {
367  //
368  // Returns the current volume ID and copy number
369  //
370  if (gGeoManager->IsOutside()) { return 0; }
371  TGeoNode* node = gGeoManager->GetCurrentNode();
372  copy = node->GetNumber();
373  Int_t id = node->GetVolume()->GetNumber();
374  return id;
375  }
376 }
377 
378 //_____________________________________________________________________________
379 Int_t CbmTofGeoHandler::CurrentVolOffID(Int_t off, Int_t& copy) const {
380  if (fIsSimulation) {
381  return gMC->CurrentVolOffID(off, copy);
382  } else {
383  //
384  // Return the current volume "off" upward in the geometrical tree
385  // ID and copy number
386  //
387  if (off < 0 || off > gGeoManager->GetLevel()) { return 0; }
388  if (off == 0) { return CurrentVolID(copy); }
389  TGeoNode* node = gGeoManager->GetMother(off);
390  if (!node) { return 0; }
391  copy = node->GetNumber();
392  return node->GetVolume()->GetNumber();
393  }
394 }
395 
396 //_____________________________________________________________________________
397 const char* CbmTofGeoHandler::CurrentVolName() const {
398  if (fIsSimulation) {
399  return gMC->CurrentVolName();
400  } else {
401  //
402  // Returns the current volume name
403  //
404  if (gGeoManager->IsOutside()) return gGeoManager->GetTopVolume()->GetName();
405  return gGeoManager->GetCurrentVolume()->GetName();
406  }
407 }
408 
409 //_____________________________________________________________________________
410 const char* CbmTofGeoHandler::CurrentVolOffName(Int_t off) const {
411  if (fIsSimulation) {
412  return gMC->CurrentVolOffName(off);
413  } else {
414  //
415  // Return the current volume "off" upward in the geometrical tree
416  // ID, name and copy number
417  // if name=0 no name is returned
418  //
419  if (off < 0 || off > gGeoManager->GetLevel()) return 0;
420  if (off == 0) return CurrentVolName();
421  TGeoNode* node = gGeoManager->GetMother(off);
422  if (!node) return 0;
423  return node->GetVolume()->GetName();
424  }
425 }
426 
427 //_____________________________________________________________________________
429  //
430  // Returns the current node name
431  //
432  if (gGeoManager->IsOutside()) return gGeoManager->GetTopNode()->GetName();
433  return gGeoManager->GetCurrentNode()->GetName();
434 }
435 
436 //_____________________________________________________________________________
437 const char* CbmTofGeoHandler::CurrentNodeOffName(Int_t off) const {
438  //
439  // Return the current node "off" upward in the geometrical tree
440  // if name=0 no name is returned
441  //
442  if (off < 0 || off > gGeoManager->GetLevel()) return 0;
443  if (off == 0) return CurrentNodeName();
444  TGeoNode* node = gGeoManager->GetMother(off);
445  if (!node) return 0;
446  return node->GetName();
447 }
448 
451  fLastUsedDetectorID = uniqueId;
452 }
453 
454 Int_t CbmTofGeoHandler::GetDetSystemId(Int_t uniqueId) {
455  if (fLastUsedDetectorID != uniqueId) { FillDetectorInfoArray(uniqueId); }
457 }
458 
459 Int_t CbmTofGeoHandler::GetSMType(Int_t uniqueId) {
460  if (fLastUsedDetectorID != uniqueId) { FillDetectorInfoArray(uniqueId); }
462 }
463 
464 Int_t CbmTofGeoHandler::GetSModule(Int_t uniqueId) {
465  if (fLastUsedDetectorID != uniqueId) { FillDetectorInfoArray(uniqueId); }
467 }
468 
469 Int_t CbmTofGeoHandler::GetCounter(Int_t uniqueId) {
470  if (fLastUsedDetectorID != uniqueId) { FillDetectorInfoArray(uniqueId); }
472 }
473 
474 Int_t CbmTofGeoHandler::GetGap(Int_t uniqueId) {
475  if (fLastUsedDetectorID != uniqueId) { FillDetectorInfoArray(uniqueId); }
476  return fDetectorInfoArray.fGap;
477 }
478 
479 Int_t CbmTofGeoHandler::GetCell(Int_t uniqueId) {
480  if (fLastUsedDetectorID != uniqueId) { FillDetectorInfoArray(uniqueId); }
481  return fDetectorInfoArray.fCell;
482 }
483 
484 Int_t CbmTofGeoHandler::GetRegion(Int_t uniqueId) {
485  /*
486  if (fLastUsedDetectorID != uniqueId) {
487  FillDetectorInfoArray(uniqueId);
488  }
489 */
490  return GetSMType(uniqueId);
491 }
492 
493 Int_t CbmTofGeoHandler::GetCellId(Int_t uniqueId) {
494  return fTofId->GetCellId(uniqueId);
495 }
496 
497 Float_t CbmTofGeoHandler::GetSizeX(TString volName) {
498  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
499  Float_t sizex = fVolumeShape->GetDX();
500  return sizex;
501 }
502 
503 Float_t CbmTofGeoHandler::GetSizeY(TString volName) {
504  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
505  Float_t sizey = fVolumeShape->GetDY();
506  return sizey;
507 }
508 
509 Float_t CbmTofGeoHandler::GetSizeZ(TString volName) {
510  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
511  Float_t sizez = fVolumeShape->GetDZ();
512  return sizez;
513 }
514 
515 Float_t CbmTofGeoHandler::GetZ(TString volName) {
516  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
517  return fGlobal[2];
518 }
519 
520 Float_t CbmTofGeoHandler::GetY(TString volName) {
521  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
522  return fGlobal[1];
523 }
524 
525 Float_t CbmTofGeoHandler::GetX(TString volName) {
526  if (fGeoPathHash != volName.Hash()) { NavigateTo(volName); }
527  return fGlobal[0];
528 }
529 
530 void CbmTofGeoHandler::NavigateTo(TString volName) {
531  if (fIsSimulation) {
532  LOG(fatal) << "This methode is not supported in simulation mode";
533  } else {
534  gGeoManager->cd(volName.Data());
535  fGeoPathHash = volName.Hash();
536  fCurrentVolume = gGeoManager->GetCurrentVolume();
537  fVolumeShape = (TGeoBBox*) fCurrentVolume->GetShape();
538  Double_t local[3] = {0., 0., 0.}; // Local centre of volume
539  gGeoManager->LocalToMaster(local, fGlobal);
540  LOG(debug2) << "GeoNav: Pos: " << fGlobal[0] << " , " << fGlobal[1] << " , "
541  << fGlobal[2];
542  // fGlobalMatrix = gGeoManager->GetCurrentMatrix();
543  }
544 }
545 
546 
CbmTofDetectorInfo::fGap
Int_t fGap
Definition: CbmTofDetectorId.h:61
CbmTofGeoHandler::GetDetSystemId
Int_t GetDetSystemId(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:454
CbmTofGeoHandler::fGeoVersion
Int_t fGeoVersion
Definition: CbmTofGeoHandler.h:84
CbmTofGeoHandler::GetCounter
Int_t GetCounter(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:469
CbmTofGeoHandler::VolId
Int_t VolId(const Text_t *name) const
Definition: CbmTofGeoHandler.cxx:347
CbmTofDetectorInfo::fCell
Int_t fCell
Definition: CbmTofDetectorId.h:62
CbmTofGeoHandler::NavigateTo
void NavigateTo(TString volName)
Definition: CbmTofGeoHandler.cxx:530
CbmTofGeoHandler::GetRegion
Int_t GetRegion(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:484
CbmTofGeoHandler::fLastUsedDetectorID
Int_t fLastUsedDetectorID
Definition: CbmTofGeoHandler.h:90
CbmTofGeoHandler::CurrentVolID
Int_t CurrentVolID(Int_t &copy) const
Definition: CbmTofGeoHandler.cxx:363
CbmTofGeoHandler::GetGap
Int_t GetGap(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:474
CbmTofDetectorId_v12b
Definition: CbmTofDetectorId_v12b.h:33
CbmTofDetectorId_v07a.h
CbmTofDetectorInfo::fDetectorSystem
Int_t fDetectorSystem
Definition: CbmTofDetectorId.h:55
CbmTofGeoHandler::GetSizeY
Float_t GetSizeY(TString volName)
Definition: CbmTofGeoHandler.cxx:503
ECbmModuleId::kTof
@ kTof
Time-of-flight Detector.
CbmTofGeoHandler::CheckGeometryVersion
Int_t CheckGeometryVersion()
Definition: CbmTofGeoHandler.cxx:61
CbmTofGeoHandler::FillDetectorInfoArray
void FillDetectorInfoArray(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:449
CbmTofGeoHandler::GetZ
Float_t GetZ(TString volName)
Definition: CbmTofGeoHandler.cxx:515
CbmTofGeoHandler::GetSModule
Int_t GetSModule(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:464
CbmTofDetectorId::GetDetectorInfo
virtual CbmTofDetectorInfo GetDetectorInfo(const Int_t detectorId)=0
CbmTofDetectorId::GetCellId
virtual Int_t GetCellId(const Int_t detectorId)=0
CbmTofGeoHandler.h
CbmTofGeoHandler::fMCVersion
Int_t fMCVersion
Definition: CbmTofGeoHandler.h:87
CbmTofDetectorId_v14a.h
CbmTofGeoHandler::GetUniqueCounterId
Int_t GetUniqueCounterId()
Definition: CbmTofGeoHandler.cxx:209
CbmTofGeoHandler::VolIdGeo
Int_t VolIdGeo(const char *name) const
Definition: CbmTofGeoHandler.cxx:334
CbmTofGeoHandler::CurrentNodeName
const char * CurrentNodeName() const
Definition: CbmTofGeoHandler.cxx:428
CbmTofGeoHandler::GetCellId
Int_t GetCellId(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:493
CbmTofGeoHandler::CurrentVolOffName
const char * CurrentVolOffName(Int_t off) const
Definition: CbmTofGeoHandler.cxx:410
CbmTofGeoHandler
Definition: CbmTofGeoHandler.h:30
k12b
@ k12b
Definition: CbmTofGeoHandler.h:17
CbmTofDetectorId_v12b.h
CbmTofGeoHandler::fTofId
CbmTofDetectorId * fTofId
Definition: CbmTofGeoHandler.h:83
k14a
@ k14a
Definition: CbmTofGeoHandler.h:17
CbmTofGeoHandler::CurrentNodeOffName
const char * CurrentNodeOffName(Int_t off) const
Definition: CbmTofGeoHandler.cxx:437
CbmTofGeoHandler::CurrentVolName
const char * CurrentVolName() const
Definition: CbmTofGeoHandler.cxx:397
CbmTofGeoHandler::fCurrentVolume
TGeoVolume * fCurrentVolume
Definition: CbmTofGeoHandler.h:93
CbmTofDetectorId_v14a
Definition: CbmTofDetectorId_v14a.h:36
CbmTofGeoHandler::Init
Int_t Init(Bool_t isSimulation=kFALSE)
Definition: CbmTofGeoHandler.cxx:39
CbmTofGeoHandler::GetUniqueDetectorId
Int_t GetUniqueDetectorId()
Definition: CbmTofGeoHandler.cxx:149
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
k07a
@ k07a
Definition: CbmTofGeoHandler.h:17
CbmTofDetectorId::SetDetectorInfo
virtual Int_t SetDetectorInfo(const CbmTofDetectorInfo detectorInfo)=0
CbmTofDetectorInfo
Definition: CbmTofDetectorId.h:20
CbmTofGeoHandler::fVolumeShape
TGeoBBox * fVolumeShape
Definition: CbmTofGeoHandler.h:94
CbmTofGeoHandler::fGlobal
Double_t fGlobal[3]
Definition: CbmTofGeoHandler.h:95
CbmTofGeoHandler::fDetectorInfoArray
CbmTofDetectorInfo fDetectorInfoArray
Definition: CbmTofGeoHandler.h:91
CbmTofGeoHandler::GetCell
Int_t GetCell(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:479
CbmTofDetectorInfo::fSModule
Int_t fSModule
Definition: CbmTofDetectorId.h:59
counter
int counter
Definition: CbmMvdSensorDigiToHitTask.cxx:72
CbmTofDetectorId_v07a
Definition: CbmTofDetectorId_v07a.h:33
CbmTofGeoHandler::GetY
Float_t GetY(TString volName)
Definition: CbmTofGeoHandler.cxx:520
CbmTofGeoHandler::GetSizeX
Float_t GetSizeX(TString volName)
Definition: CbmTofGeoHandler.cxx:497
CbmTofGeoHandler::CurrentVolOffID
Int_t CurrentVolOffID(Int_t off, Int_t &copy) const
Definition: CbmTofGeoHandler.cxx:379
CbmTofGeoHandler::GetSizeZ
Float_t GetSizeZ(TString volName)
Definition: CbmTofGeoHandler.cxx:509
CbmTofAnaTestbeam::fTofId
CbmTofDetectorId * fTofId
Definition: CbmTofAnaTestbeam.h:309
CbmTofGeoHandler::GetSMType
Int_t GetSMType(Int_t uniqueId)
Definition: CbmTofGeoHandler.cxx:459
CbmTofDetectorInfo::fCounter
Int_t fCounter
Definition: CbmTofDetectorId.h:60
CbmTofGeoHandler::fIsSimulation
Bool_t fIsSimulation
Definition: CbmTofGeoHandler.h:86
CbmTofDetectorInfo::fSMtype
Int_t fSMtype
Definition: CbmTofDetectorId.h:58
CbmTofGeoHandler::fUseNodeName
Bool_t fUseNodeName
Definition: CbmTofGeoHandler.h:88
CbmTofGeoHandler::fGeoPathHash
UInt_t fGeoPathHash
Definition: CbmTofGeoHandler.h:92
CbmTofGeoHandler::CbmTofGeoHandler
CbmTofGeoHandler()
Definition: CbmTofGeoHandler.cxx:24
CbmTofGeoHandler::GetX
Float_t GetX(TString volName)
Definition: CbmTofGeoHandler.cxx:525
CbmDefs.h