CbmRoot
CbmMuchGeoScheme.cxx
Go to the documentation of this file.
1 // -------------------------------------------------------------------------
2 // ----- CbmMuchGeoScheme source file -----
3 //------ Modilfied 21/06/2019 by Ekata Nandy(Detector type for GEM & RPC included) -----
4 //------ Modilfied 18/10/2017 by Omveer Singh -----
5 // ----- Created 18/02/08 by E. Kryshen
6 // -------------------------------------------------------------------------
7 #include "CbmMuchGeoScheme.h"
8 
9 #include "CbmMuchAddress.h" // for CbmMuchAddress
10 #include "CbmMuchLayer.h" // for CbmMuchLayer
11 #include "CbmMuchLayerSide.h" // for CbmMuchLayerSide
12 #include "CbmMuchModule.h" // for CbmMuchModule
13 #include "CbmMuchModuleGem.h" // for CbmMuchModuleGem
14 #include "CbmMuchModuleGemRadial.h" // for CbmMuchModuleGemRadial
15 #include "CbmMuchStation.h" // for CbmMuchStation
16 
17 #include <FairLogger.h> // for LOG
18 
19 #include <TArrayD.h> // for TArrayD
20 #include <TArrayI.h> // for TArrayI
21 #include <TClonesArray.h> // for TClonesArray
22 #include <TFile.h> // for TFile, gFile
23 #include <TGeoArb8.h> // for TGeoTrap
24 #include <TGeoBBox.h> // for TGeoBBox
25 #include <TGeoManager.h> // for TGeoManager, gGeoManager
26 #include <TGeoNode.h> // for TGeoNode
27 #include <TGeoVolume.h> // for TGeoVolume
28 #include <TMath.h> // for Cos, Sqrt
29 #include <TObjArray.h> // for TObjArray
30 #include <TObject.h> // for TObject
31 #include <TVector3.h> // for TVector3
32 
33 
34 #include <cassert> // for assert
35 #include <math.h> // for sqrt
36 #include <stdexcept> // for out_of_range
37 #include <utility> // for pair
38 #include <vector>
39 
40 using std::vector;
41 
42 CbmMuchGeoScheme* CbmMuchGeoScheme::fInstance = nullptr;
43 Bool_t CbmMuchGeoScheme::fInitialized = kFALSE;
44 Bool_t CbmMuchGeoScheme::fModulesInitialized = kFALSE;
45 
46 // -------------------------------------------------------------------------
47 CbmMuchGeoScheme::CbmMuchGeoScheme()
48  : TObject()
49  , fGeoPathHash(0)
50  , fCurrentVolume(nullptr)
51  , fVolumeBoxShape(nullptr)
52  , fVolumeTrapShape(nullptr)
53  , fGlobal()
54  , fGlobalTrap()
55  , fGlobalMatrix(nullptr)
56  , fStation(0)
57  , fLayer(0)
58  , fActive(0)
59  , fGeoID(0)
60  ,
61  //fIsSimulation(kFALSE),
62  fModules()
63  , fSides()
64  , fMapSides()
65  , fStations(nullptr)
66  , fAbsorbers(new TObjArray())
67  , fMuchCave(nullptr)
68  , fMuchZ1(0.)
69  , fAcceptanceTanMin(0.)
70  , fAcceptanceTanMax(0.)
71  , fNabs(0)
72  , fNst(0)
73  , fActiveLx(0.)
74  , fActiveLy(0.)
75  , fActiveLz(0.)
76  , fSpacerLx(0.)
77  , fSpacerLy(0.)
78  , fOverlapY(0.)
79  , fStrawLz(0.)
80  , fNSectorsPerLayer(0)
81  , fActiveLzSector(0.)
82  , fSpacerR(0.)
83  , fSpacerPhi(0)
84  , fOverlapR(0.)
85  , fAbsorberZ1(0)
86  , fAbsorberLz(0)
87  , fAbsorberMat(0)
88  , fStationZ0(0)
89  , fNlayers(0)
90  , fDetType(0)
91  , fLayersDz(0)
92  , fSupportLz(0)
93  , fModuleDesign(0)
94  , muchSt(nullptr)
95  , muchLy(nullptr)
96  , muchLySd(nullptr)
97  , Rmin(-1.)
98  , Rmax(-1.)
99  , Dx2(-1.) {
100  LOG(debug) << "CbmMuchGeoScheme created";
101 }
102 // -------------------------------------------------------------------------
103 
104 // -------------------------------------------------------------------------
105 CbmMuchGeoScheme::~CbmMuchGeoScheme() {
106 
107  if (fInstance != nullptr) delete fInstance;
108 }
109 // -------------------------------------------------------------------------
110 
111 
112 // -------------------------------------------------------------------------
113 CbmMuchGeoScheme* CbmMuchGeoScheme::Instance() {
114 
115  if (!fInstance) fInstance = new CbmMuchGeoScheme();
116  return fInstance;
117 }
118 // -------------------------------------------------------------------------
119 
120 // -------------------------------------------------------------------------
121 void CbmMuchGeoScheme::Init(TObjArray* stations, Int_t flag) {
122 
123  if (!fInitialized) {
124  fStations = stations;
125  //LOG(info) <<" enter ini loop check"<<fStations->GetEntries()<<" "<<stations->GetEntries();
126  fGeoID = flag;
127  fInitialized = kTRUE;
128  }
129  LOG(debug) << "CbmMuchGeoScheme init successful";
130  InitModules();
131 }
132 // -------------------------------------------------------------------------
133 
134 
135 // -------------------------------------------------------------------------
136 void CbmMuchGeoScheme::Init(TString digiFileName, Int_t flag) {
137 
138  TFile* oldfile = gFile;
139  TFile* file = new TFile(digiFileName);
140  TObjArray* stations = (TObjArray*) file->Get("stations");
141  file->Close();
142  file->Delete();
143  gFile = oldfile;
144  Init(stations, flag);
145 }
146 // -------------------------------------------------------------------------
147 
148 
149 // -------------------------------------------------------------------------
150 void CbmMuchGeoScheme::InitModules() {
151 
152  if (!fModulesInitialized) {
153 
154 
155  if (!fStations) Fatal("InitModules", "No input array of stations.");
156  Int_t incSides = 0;
157  fMapSides.clear();
158  fSides.clear();
159  fModules.clear();
160 
161  //LOG(info) <<"Total No. of Stations "<<" "<<GetNStations()<<" absorbers "<<GetNAbsorbers();
162  for (Int_t iStation = 0; iStation < GetNStations(); iStation++) {
163 
164  const CbmMuchStation* station = GetStation(iStation);
165  if (!station) continue;
166 
167  assert(iStation
168  == CbmMuchAddress::GetStationIndex(station->GetDetectorId()));
169  vector<CbmMuchLayerSide*> sides;
170  vector<CbmMuchModule*> modules;
171 
172  for (Int_t iLayer = 0; iLayer < station->GetNLayers(); iLayer++) {
173  CbmMuchLayer* layer = station->GetLayer(iLayer);
174  if (!layer) continue;
175 
176  assert(iLayer == CbmMuchAddress::GetLayerIndex(layer->GetDetectorId()));
177  for (Int_t iSide = 0; iSide < 2; iSide++) {
178  CbmMuchLayerSide* side = (CbmMuchLayerSide*) layer->GetSide(iSide);
179  if (!side) continue;
180  assert(iSide
181  == CbmMuchAddress::GetLayerSideIndex(side->GetDetectorId()));
182  if (side->GetNModules() != 0)
183  fMapSides[side->GetDetectorId()] = incSides++;
184  sides.push_back(side);
185 
186  for (Int_t iModule = 0; iModule < side->GetNModules(); iModule++) {
187  CbmMuchModule* mod = side->GetModule(iModule);
188  if (!mod) continue;
189 
190  assert(iModule
191  == CbmMuchAddress::GetModuleIndex(mod->GetDetectorId()));
192  assert(iStation
193  == CbmMuchAddress::GetStationIndex(mod->GetDetectorId()));
194  if (!mod->InitModule()) continue;
195  modules.push_back(mod);
196  } // Modules
197  } // Sides
198  } // Layers
199  fSides.push_back(sides);
200  fModules.push_back(modules);
201  } // Stations
202 
203  fModulesInitialized = kTRUE;
204  }
205 }
206 // -------------------------------------------------------------------------
207 
208 // -------------------------------------------------------------------------
209 CbmMuchStation* CbmMuchGeoScheme::GetStation(Int_t iStation) const {
210 
211  if (!fStations) return nullptr;
212  Bool_t result = (iStation >= 0) || (iStation < fStations->GetEntries());
213 
214  return result ? (CbmMuchStation*) fStations->At(iStation) : nullptr;
215 }
216 // -------------------------------------------------------------------------
217 
218 
219 // -------------------------------------------------------------------------
220 CbmMuchLayer* CbmMuchGeoScheme::GetLayer(Int_t iStation, Int_t iLayer) const {
221 
222  CbmMuchStation* station = GetStation(iStation);
223  return station ? station->GetLayer(iLayer) : nullptr;
224 }
225 // -------------------------------------------------------------------------
226 
227 // -------------------------------------------------------------------------
228 CbmMuchLayerSide* CbmMuchGeoScheme::GetLayerSide(Int_t iStation,
229  Int_t iLayer,
230  Bool_t iSide) const {
231 
232  CbmMuchLayer* layer = GetLayer(iStation, iLayer);
233  return layer ? layer->GetSide(iSide) : nullptr;
234 }
235 // -------------------------------------------------------------------------
236 
237 // -------------------------------------------------------------------------
238 CbmMuchModule* CbmMuchGeoScheme::GetModule(Int_t iStation,
239  Int_t iLayer,
240  Bool_t iSide,
241  Int_t iModule) const {
242 
243  CbmMuchLayerSide* side = GetLayerSide(iStation, iLayer, iSide);
244  return side ? side->GetModule(iModule) : nullptr;
245 }
246 // -------------------------------------------------------------------------
247 
248 // -------------------------------------------------------------------------
249 CbmMuchStation* CbmMuchGeoScheme::GetStationByDetId(Int_t detId) const {
250 
251  Int_t iStation = CbmMuchAddress::GetStationIndex(detId);
252  assert(iStation < GetNStations());
253  return GetStation(iStation);
254 }
255 // -------------------------------------------------------------------------
256 
257 // -------------------------------------------------------------------------
258 CbmMuchLayer* CbmMuchGeoScheme::GetLayerByDetId(Int_t detId) const {
259 
260  CbmMuchStation* station = GetStationByDetId(detId);
261  Int_t iLayer = CbmMuchAddress::GetLayerIndex(detId);
262  assert(iLayer < station->GetNLayers());
263  return station ? station->GetLayer(iLayer) : nullptr;
264 }
265 // -------------------------------------------------------------------------
266 
267 // -------------------------------------------------------------------------
268 CbmMuchLayerSide* CbmMuchGeoScheme::GetLayerSideByDetId(Int_t detId) const {
269 
270  CbmMuchLayer* layer = GetLayerByDetId(detId);
271  Int_t iSide = CbmMuchAddress::GetLayerSideIndex(detId);
272  assert(iSide < 2);
273  return layer ? layer->GetSide(iSide) : nullptr;
274 }
275 // -------------------------------------------------------------------------
276 
277 // -------------------------------------------------------------------------
278 CbmMuchModule* CbmMuchGeoScheme::GetModuleByDetId(Int_t detId) const {
279 
280  CbmMuchLayerSide* side = GetLayerSideByDetId(detId);
281  Int_t iModule = CbmMuchAddress::GetModuleIndex(detId);
282  assert(iModule < side->GetNModules());
283  return side ? side->GetModule(iModule) : nullptr;
284 }
285 // -------------------------------------------------------------------------
286 
287 // -------------------------------------------------------------------------
288 void CbmMuchGeoScheme::CreatePointArrays() {
289 
290  vector<CbmMuchModule*> modules = GetModules();
291  for (vector<CbmMuchModule*>::iterator it = modules.begin();
292  it != modules.end();
293  it++) {
294  CbmMuchModule* module = (*it);
295  module->SetPoints(new TClonesArray("CbmVisPoint", 1));
296  }
297 }
298 // -------------------------------------------------------------------------
299 
300 // -------------------------------------------------------------------------
301 void CbmMuchGeoScheme::CreateHitArrays() {
302 
303  vector<CbmMuchModule*> modules = GetModules();
304  for (vector<CbmMuchModule*>::iterator it = modules.begin();
305  it != modules.end();
306  it++) {
307  CbmMuchModule* module = (*it);
308  if (module->GetDetectorType() == 1) {
309  CbmMuchModuleGem* mod = (CbmMuchModuleGem*) module;
310  mod->SetHits(new TClonesArray("CbmVisPixelHit", 1));
311  /*
312  } else if (module->GetDetectorType()==2) {
313  CbmMuchModuleStraws* mod = (CbmMuchModuleStraws*)module;
314  mod->SetHits(new TClonesArray("CbmVisStripHit",1));
315 */
316  }
317  }
318 }
319 // -------------------------------------------------------------------------
320 
321 // -------------------------------------------------------------------------
322 void CbmMuchGeoScheme::CreateClusterArrays() {
323 
324  vector<CbmMuchModule*> modules = GetModules();
325  for (vector<CbmMuchModule*>::iterator it = modules.begin();
326  it != modules.end();
327  it++) {
328  CbmMuchModule* module = (*it);
329  if (module->GetDetectorType() != 1) continue;
330  CbmMuchModuleGem* mod = (CbmMuchModuleGem*) module;
331  mod->SetClusters(new TClonesArray("CbmVisMuchCluster", 1));
332  }
333 }
334 // -------------------------------------------------------------------------
335 
336 // -------------------------------------------------------------------------
337 void CbmMuchGeoScheme::ClearPointArrays() {
338 
339  vector<CbmMuchModule*> modules = GetModules();
340  for (vector<CbmMuchModule*>::iterator it = modules.begin();
341  it != modules.end();
342  it++) {
343  (*it)->GetPoints()->Clear();
344  }
345 }
346 // -------------------------------------------------------------------------
347 
348 
349 // -------------------------------------------------------------------------
350 void CbmMuchGeoScheme::ClearHitArrays() {
351 
352  vector<CbmMuchModule*> modules = GetModules();
353  for (vector<CbmMuchModule*>::iterator it = modules.begin();
354  it != modules.end();
355  it++) {
356  (*it)->GetHits()->Clear();
357  }
358 }
359 // -------------------------------------------------------------------------
360 
361 // -------------------------------------------------------------------------
362 void CbmMuchGeoScheme::ClearClusterArrays() {
363 
364  vector<CbmMuchModule*> modules = GetModules();
365  for (vector<CbmMuchModule*>::iterator it = modules.begin();
366  it != modules.end();
367  it++) {
368  CbmMuchModule* module = (*it);
369  if (module->GetDetectorType() != 1) continue;
370  CbmMuchModuleGem* mod = (CbmMuchModuleGem*) module;
371  mod->GetClusters()->Clear();
372  }
373 }
374 // -------------------------------------------------------------------------
375 
376 // -------------------------------------------------------------------------
377 vector<CbmMuchLayerSide*>
378 CbmMuchGeoScheme::GetLayerSides(Int_t iStation) const {
379 
380  try {
381  return fSides.at(iStation);
382  } catch (std::out_of_range exc) {
383  Fatal("GetLayerSides", "No input array of stations.");
384  }
385  return vector<CbmMuchLayerSide*>();
386 }
387 
388 //Int_t CbmMuchGeoScheme::GetLayerSideNr(Int_t detId){
389 // int i = 0;
390 // Int_t sideId = GetLayerSideByDetId(detId)->GetDetectorId();
391 // Int_t iStation = GetStationIndex(detId);
392 // for(Int_t iSt=0; iSt<=iStation; iSt++){
393 // vector<CbmMuchLayerSide*> sides = GetLayerSides(iSt);
394 // for(Int_t iSide=0; iSide<sides.size(); iSide++){
395 // i++;
396 // }
397 // }
398 // printf("%i, %i\n",fMapSides[sideId] + 1, i);
399 // assert(fMapSides[sideId] + 1 == i);
400 // return i;
401 //}
402 
403 Int_t CbmMuchGeoScheme::GetLayerSideNr(Int_t detId) const {
404  Int_t sideId = GetLayerSideByDetId(detId)->GetDetectorId();
405  if (fMapSides.find(sideId) == fMapSides.end())
406  Fatal("GetLayerSideNr", "Wrong side id or no modules in the layer side");
407  return fMapSides.find(sideId)->second + 1;
408 }
409 
410 // -------------------------------------------------------------------------
411 void CbmMuchGeoScheme::NavigateTo(const TString& path) {
412 
413  gGeoManager->cd(path.Data());
414  // fGeoPathHash;
415  fGeoPathHash = path.Hash();
416  fCurrentVolume = gGeoManager->GetCurrentVolume();
417  fVolumeBoxShape = (TGeoBBox*) fCurrentVolume->GetShape();
418  Double_t local[3] = {0., 0., 0.};
419  gGeoManager->LocalToMaster(local, fGlobal);
420 }
421 
422 //------------------------------------------------------
423 Double_t CbmMuchGeoScheme::GetSizeX(const TString& path) {
424 
425  if (fGeoPathHash != path.Hash()) { NavigateTo(path); }
426  return fVolumeBoxShape->GetDX();
427 }
428 
429 
430 Double_t CbmMuchGeoScheme::GetSizeY(const TString& path) {
431 
432  if (fGeoPathHash != path.Hash()) { NavigateTo(path); }
433  return fVolumeBoxShape->GetDY();
434 }
435 
436 
437 Double_t CbmMuchGeoScheme::GetSizeZ(const TString& path) {
438  if (fGeoPathHash != path.Hash()) { NavigateTo(path); }
439  return fVolumeBoxShape->GetDZ();
440 }
441 
442 
443 Double_t CbmMuchGeoScheme::GetZ(const TString& path) {
444 
445  if (fGeoPathHash != path.Hash()) { NavigateTo(path); }
446  return fGlobal[2];
447 }
448 
449 
450 Double_t CbmMuchGeoScheme::GetY(const TString& path) {
451 
452  if (fGeoPathHash != path.Hash()) { NavigateTo(path); }
453  return fGlobal[1];
454 }
455 
456 
457 Double_t CbmMuchGeoScheme::GetX(const TString& path) {
458 
459  if (fGeoPathHash != path.Hash()) { NavigateTo(path); }
460  return fGlobal[0];
461 }
462 //-----------------------------------------------------------------------------------------------------
463 void CbmMuchGeoScheme::ExtractGeoParameter(TGeoNode* ncave,
464  const char* volumeName) {
465 
466  TObjArray* caveArr = ncave->GetNodes();
467 
468  for (int iSystem = 0; iSystem < caveArr->GetEntriesFast(); iSystem++) {
469  TGeoNode* SystemNode = static_cast<TGeoNode*>(caveArr->At(iSystem));
470 
471  if (!TString(SystemNode->GetName()).Contains(volumeName)) continue;
472  TObjArray* MuchObj = SystemNode->GetNodes();
473 
474  for (Int_t iMuchObj = 0; iMuchObj < MuchObj->GetEntriesFast(); iMuchObj++) {
475 
476  TGeoNode* MuchObjNode = static_cast<TGeoNode*>(MuchObj->At(iMuchObj));
477 
478  // if (!TString(MuchObjNode->GetName()).Contains("Station")) continue;
479  if (!TString(MuchObjNode->GetName()).Contains("station")) continue;
480  TString MuchObjPath = TString("/") + ncave->GetName() + "/"
481  + SystemNode->GetName() + "/"
482  + MuchObjNode->GetName();
483 
484  StationNode(MuchObjNode, MuchObjPath); //StationNode
485  } //iMuchObj
486 
487  } //iSystem
488 } //SetParameters
489 
490 //---------------------------------------------------------------------------------------------
491 void CbmMuchGeoScheme::StationNode(TGeoNode* fSNode, TString Path) {
492 
493  TObjArray* stations = fSNode->GetNodes();
494  //fStations=stations; // by PPB 1/11/2017
495  fNst = stations->GetEntriesFast();
496  // LOG(info) <<"check stations "<<fNst;
497  fStationZ0.Set(fNst); // Station Zceneter [cm]
498  fNlayers.Set(fNst); // Number of layers
499  fDetType.Set(fNst); // Detector type
500  fLayersDz.Set(fNst); // Distance between layers [cm]
501  fSupportLz.Set(fNst); // Support thickness [cm]
502  fLayersDz.Set(fNst); //
503  fModuleDesign.Set(fNst); // Module design (0/1)
504  fNSectorsPerLayer.Set(
505  fNst); // Number of sectors per layer in sector GEM geometry
506 
507 
508  for (Int_t iStation = 0; iStation < fNst; iStation++) {
509  TGeoNode* station = static_cast<TGeoNode*>(stations->At(iStation));
510  TString StationPath = Path + "/" + station->GetName();
511  TObjArray* layers = station->GetNodes();
512  fNlayers[iStation] = layers->GetEntriesFast();
513 
514 
515  // fDetType[iStation]=3;
516  // fLayersDz[iStation]=10.0;
517 
518  //-----------------------------Layer1-------------------------------------------------------
519  TGeoNode* layer1 =
520  static_cast<TGeoNode*>(layers->At(0)); //first layer position of station
521  TString Layer1Path = StationPath + "/" + layer1->GetName();
522  TObjArray* Supportlayer1 = layer1->GetNodes();
523  TGeoNode* Supportlayer1Node = static_cast<TGeoNode*>(Supportlayer1->At(0));
524 
525  TString Supportlayer1Path = Layer1Path + "/" + Supportlayer1Node->GetName();
526  Double_t fLayer1Z0;
527  //if(Supportlayer2Path.Contains("mcbm")) fLayer2Z0=GetModuleZ(Supportlayer2Path);
528  if (fGeoID == 1)
529  fLayer1Z0 = GetModuleZ(Supportlayer1Path);
530  else
531  fLayer1Z0 = GetZ(Supportlayer1Path);
532 
533 
534  //-----------------------------Layer2-------------------------------------------------------
535  TGeoNode* layer2 =
536  static_cast<TGeoNode*>(layers->At(1)); //second layer position of station
537  TString Layer2Path = StationPath + "/" + layer2->GetName();
538 
539  TObjArray* Supportlayer2 = layer2->GetNodes();
540  TGeoNode* Supportlayer2Node = static_cast<TGeoNode*>(Supportlayer2->At(0));
541 
542  TString Supportlayer2Path = Layer2Path + "/" + Supportlayer2Node->GetName();
543 
544  Double_t fLayer2Z0;
545  //if(Supportlayer2Path.Contains("mcbm")) fLayer2Z0=GetModuleZ(Supportlayer2Path);
546  if (fGeoID == 1)
547  fLayer2Z0 = GetModuleZ(Supportlayer2Path);
548  else
549  fLayer2Z0 = GetZ(Supportlayer2Path);
550  //
551 
552 
553  fLayersDz[iStation] = fLayer2Z0 - fLayer1Z0;
554 
555  //if(Supportlayer3Path.Contains("mcbm")) fSupportLz[iStation]=2.0*GetModuleDZ(Supportlayer3Path);
556  if (fGeoID == 1)
557  fSupportLz[iStation] = 2.0 * GetModuleDZ(Supportlayer1Path);
558  else
559  fSupportLz[iStation] = 2.0 * GetSizeZ(Supportlayer1Path);
560  //LOG(info) <<fSupportLz[iStation]<<" "<<fLayersDz[iStation];
561 
562 
563  Double_t PosY = 0., Phi = 0., Dy = 0.;
564 
565  if (fNlayers[iStation] == 3) {
566  //------------------------------Layer3-----------------------------------------------------------
567  TGeoNode* layer3 = static_cast<TGeoNode*>(layers->At(2));
568  TString Layer3Path = StationPath + "/" + layer3->GetName();
569 
570  TObjArray* Supportlayer3 = layer3->GetNodes();
571  TGeoNode* Supportlayer3Node =
572  static_cast<TGeoNode*>(Supportlayer3->At(0));
573  TString Supportlayer3Path =
574  Layer3Path + "/" + Supportlayer3Node->GetName();
575 
576  // Double_t fLayer3Z0;
577  //if(Supportlayer3Path.Contains("mcbm")) fLayer3Z0=GetModuleZ(Supportlayer3Path);
578  // if(fGeoID==1) fLayer3Z0=GetModuleZ(Supportlayer3Path);
579  // else fLayer3Z0 = GetZ(Supportlayer3Path);
580  TGeoNode* Activelayer3Node = static_cast<TGeoNode*>(Supportlayer3->At(1));
581  TString Activelayer3Path = Layer3Path + "/" + Activelayer3Node->GetName();
582 
583  PosY = GetModuleY(Activelayer3Path);
584  // Double_t PosX=GetModuleX(Activelayer3Path);
585  Phi = GetModulePhi(Activelayer3Path);
586  Dy = GetModuleH1(Activelayer3Path);
587  fActiveLzSector = 2.0 * GetModuleDZ(Activelayer3Path);
588  fStationZ0[iStation] = fLayer2Z0;
589  } else {
590  TGeoNode* Activelayer2Node = static_cast<TGeoNode*>(Supportlayer2->At(1));
591  TString Activelayer2Path = Layer2Path + "/" + Activelayer2Node->GetName();
592 
593  PosY = GetModuleY(Activelayer2Path);
594  // Double_t PosX=GetModuleX(Activelayer3Path);
595  Phi = GetModulePhi(Activelayer2Path);
596  Dy = GetModuleH1(Activelayer2Path);
597  fActiveLzSector = 2.0 * GetModuleDZ(Activelayer2Path);
598  fStationZ0[iStation] = (fLayer2Z0 - fLayer1Z0) / 2.;
599  }
600 
601 
602  //chaned by PPB on 16.11.2017
603  //Double_t yMin = -(PosX/TMath::Sin(Phi))-Dy;
604  Double_t yMin = (PosY / TMath::Cos(Phi)) - Dy;
605  Double_t yMax = 2 * Dy + yMin;
606  LOG(info) << " Geo Scheme "
607  << " posY " << PosY << " phi " << Phi << " Dy " << Dy;
608  Rmax = yMax;
609  Rmin = yMin; //-2.0; // Spacer width[cm] = 2.0
610 
611 
612  muchSt = new CbmMuchStation(iStation, fStationZ0[iStation]);
613  muchSt->SetRmin(Rmin);
614  muchSt->SetRmax(Rmax);
615 
616  if (Supportlayer1->GetEntriesFast() > 0) fModuleDesign[iStation] = 1;
617  muchSt->SetModuleDesign(fModuleDesign[iStation]);
618 
619 
620  LayerNode(station, iStation, StationPath);
621 
622 
623  muchLy = muchSt->GetLayer(0);
624  Double_t supDx = muchLy->GetSupportDx();
625  Double_t supDy = muchLy->GetSupportDy();
626  // Double_t supDz = muchLy->GetSupportDz();
627  muchSt->SetTubeRmin(muchSt->GetRmin());
628  muchSt->SetTubeRmax(TMath::Sqrt(supDx * supDx + supDy * supDy) + 10);
629  //LOG(info) <<" fill fStations array "<<iStation<<" z cent "<<fStationZ0[iStation];
630  fStations->Add(muchSt);
631 
632  } //Station
633 } //StationNode
634 //---------------------------------------------------------------------------------------------------------
635 
636 void CbmMuchGeoScheme::LayerNode(TGeoNode* StNode,
637  Int_t iStation,
638  TString StPath) {
639 
640  TObjArray* layerArray = StNode->GetNodes();
641  for (Int_t iLayer = 0; iLayer < layerArray->GetEntriesFast(); iLayer++) {
642  TGeoNode* layerNode = static_cast<TGeoNode*>(layerArray->At(iLayer));
643  TString layerPath = StPath + "/" + layerNode->GetName();
644 
645  ModuleNode(layerNode, iStation, iLayer, layerPath);
646 
647  //Set support shape
648  muchLy->SetSupportDx(sqrt(Rmax * Rmax + Dx2 * Dx2));
649  muchLy->SetSupportDy(sqrt(Rmax * Rmax + Dx2 * Dx2));
650  muchLy->SetSupportDz(fSupportLz[iStation] / 2.);
651 
652  muchSt->AddLayer(muchLy);
653 
654  } //iLayer
655 }
656 //---------------------------------------------------------------------------------------------------------------------------------
657 
658 void CbmMuchGeoScheme::ModuleNode(TGeoNode* layerNode,
659  Int_t iStation,
660  Int_t iLayer,
661  TString layerPath) {
662 
663 
664  TObjArray* moduleArray = layerNode->GetNodes();
665  for (Int_t iModule = 0; iModule < moduleArray->GetEntriesFast(); iModule++) {
666  TGeoNode* moduleNode = static_cast<TGeoNode*>(moduleArray->At(iModule));
667 
668  TString modulePath = layerPath + "/" + moduleNode->GetName();
669 
670  ActiveModuleNode(moduleNode, iStation, iLayer, iModule, modulePath);
671 
672 
673  } //iModule
674 }
675 
676 //----------------------------------------------------------------------------------------------------------------------------------------------------------------
677 
678 void CbmMuchGeoScheme::ActiveModuleNode(TGeoNode* moduleNode,
679  Int_t iStation,
680  Int_t iLayer,
681  Int_t /*iModule*/,
682  TString modulePath) {
683 
684  TString modName = moduleNode->GetName();
685 
686 
687  if (modName.Contains("support")) {
688 
689 
690  Double_t layerGlobalZ0;
691  // if(modulePath.Contains("mcbm")) layerGlobalZ0=GetModuleZ(modulePath);
692  if (fGeoID == 1)
693  layerGlobalZ0 = GetModuleZ(modulePath);
694  else
695  layerGlobalZ0 = GetZ(modulePath);
696 
697  Double_t layerZ0 =
698  (iLayer - (fNlayers[iStation] - 1) / 2.) * fLayersDz[iStation];
699  Double_t sideDz = fSupportLz[iStation] / 2. + fActiveLzSector / 2.;
700 
701  muchLy = new CbmMuchLayer(
702  iStation, iLayer, layerGlobalZ0, layerZ0); //CbmMuchLayer Class
703  muchLy->GetSideB()->SetZ(layerGlobalZ0 + sideDz);
704  muchLy->GetSideF()->SetZ(layerGlobalZ0 - sideDz);
705  }
706 
707 
708  if (modName.Contains("active")) {
709 
710  gGeoManager->cd(modulePath.Data());
711  // TGeoNode* moduleNode = gGeoManager->GetMother(0);
712  moduleNode = gGeoManager->GetMother(0);
713  // Int_t nModule=moduleNode->GetNumber();
714 
715  Bool_t iSide;
716  if (modName.Contains("factive")) iSide = 0;
717  if (modName.Contains("bactive")) iSide = 1;
718  TVector3 pos;
719  pos[0] = GetModuleX(modulePath);
720  pos[1] = GetModuleY(modulePath);
721  pos[2] = GetModuleZ(modulePath);
722  // LOG(info) <<" positions "<<pos[0]<<" "<<pos[1]<<" "<<pos[2];
723  Double_t Dz = GetModuleDZ(modulePath);
724  // Double_t Phi = GetModulePhi(modulePath);
725  Double_t Dy = GetModuleH1(modulePath);
726  Double_t Dx1 = GetModuleBl1(modulePath);
727  Dx2 = GetModuleTl1(modulePath);
728  //LOG(info) <<" positions "<<pos[0]<<" "<<pos[1]<<" "<<pos[2]<<" phi "<<Phi;
729 
730  // Is this formula correct? Check Omveer (PPB 16.11.2017)
731  // Double_t yMin = (pos[1]/TMath::Cos(Phi))-Dy;
732  // Double_t yMax = 2*Dy + yMin;
733  // Double_t Rmin = yMin-2.0; // Spacer width[cm] = 2.0
734  // Why is R0 required?
735  // Double_t R0 = yMax-Dy;
736  // Double_t Rmax = yMax;
737 
738 
739  Int_t DetType = -1;
740  if (modName.Contains("gasArgon")) DetType = 3; // Detector type 3 for GEM
741  if (modName.Contains("rpcgas")) DetType = 4; // Detector type 4 for RPC
742  // LOG(info) <<" detector type "<<DetType;
743 
744  muchLySd = muchLy->GetSide(iSide);
745  muchLySd->AddModule(new CbmMuchModuleGemRadial(
746  DetType,
747  iStation,
748  iLayer,
749  iSide,
750  muchLySd->GetNModules(),
751  pos,
752  Dx1,
753  Dx2,
754  Dy,
755  Dz,
756  Rmin)); // Detector type variable added in the class constructor on 03-07-2019
757 
758 
759  } //activeLayer
760 
761 
762 } //ActiveModuleNode
763 //----------------------------------------------------------------------------------------------------------
764 void CbmMuchGeoScheme::NavigateModule(const TString& path) {
765  gGeoManager->cd(path.Data());
766  // fGeoPathHash;
767  fGeoPathHash = path.Hash();
768  fCurrentVolume = gGeoManager->GetCurrentVolume();
769  fVolumeTrapShape = (TGeoTrap*) fCurrentVolume->GetShape();
770  Double_t local[3] = {0., 0., 0.};
771  gGeoManager->LocalToMaster(local, fGlobalTrap);
772 
773 } //NavigateModule
774 
775 //----------------------------------------------------------------------------------------------------------
776 
777 Double_t CbmMuchGeoScheme::GetModuleDZ(const TString& path) {
778 
779  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
780  return fVolumeTrapShape->GetDZ();
781 }
782 
783 
784 Double_t CbmMuchGeoScheme::GetModuleZ(const TString& path) {
785 
786  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
787  return fGlobalTrap[2];
788 }
789 
790 
791 Double_t CbmMuchGeoScheme::GetModuleY(const TString& path) {
792 
793  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
794  return fGlobalTrap[1];
795 }
796 
797 
798 Double_t CbmMuchGeoScheme::GetModuleX(const TString& path) {
799 
800  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
801  return fGlobalTrap[0];
802 }
803 
804 Double_t CbmMuchGeoScheme::GetModulePhi(const TString& path) {
805 
806  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
807  return fVolumeTrapShape->GetPhi();
808 }
809 
810 Double_t CbmMuchGeoScheme::GetModuleH1(const TString& path) {
811 
812  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
813  return fVolumeTrapShape->GetH1();
814 }
815 
816 Double_t CbmMuchGeoScheme::GetModuleBl1(const TString& path) {
817 
818  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
819  return fVolumeTrapShape->GetBl1();
820 }
821 
822 Double_t CbmMuchGeoScheme::GetModuleTl1(const TString& path) {
823 
824  if (fGeoPathHash != path.Hash()) { NavigateModule(path); }
825  return fVolumeTrapShape->GetTl1();
826 }
827 
828 // -------------------------------------------------------------------------
829 Int_t CbmMuchGeoScheme::Intersect(Float_t x,
830  Float_t y,
831  Float_t dx,
832  Float_t dy,
833  Float_t r) {
834 
835  Float_t x1 = x - dx;
836  Float_t x2 = x + dx;
837  Float_t y1 = y - dy;
838  Float_t y2 = y + dy;
839  Int_t nCornersInside = 0;
840  if (x1 * x1 + y1 * y1 < r * r) nCornersInside++;
841  if (x2 * x2 + y1 * y1 < r * r) nCornersInside++;
842  if (x1 * x1 + y2 * y2 < r * r) nCornersInside++;
843  if (x2 * x2 + y2 * y2 < r * r) nCornersInside++;
844  if (nCornersInside == 4) return 2;
845  if (nCornersInside) return 1;
846  if (!nCornersInside && x1 < r && y1 < 0 && y2 > 0) return 1;
847  return 0;
848 }
849 // -------------------------------------------------------------------------
850 
851 // -------------------------------------------------------------------------
852 vector<CbmMuchModule*> CbmMuchGeoScheme::GetModules() const {
853 
854  vector<CbmMuchModule*> modules;
855  for (Int_t iStation = 0; iStation < GetNStations(); ++iStation) {
856  vector<CbmMuchModule*> stationModules = GetModules(iStation);
857  for (vector<CbmMuchModule*>::iterator it = stationModules.begin();
858  it != stationModules.end();
859  it++) {
860  CbmMuchModule* module = (*it);
861  modules.push_back(module);
862  assert(CbmMuchAddress::GetStationIndex(module->GetDetectorId())
863  == iStation);
864  }
865  }
866  return modules;
867 }
868 // -------------------------------------------------------------------------
869 
870 
871 // -------------------------------------------------------------------------
872 vector<CbmMuchModuleGem*> CbmMuchGeoScheme::GetGemModules() const {
873 
874  vector<CbmMuchModuleGem*> modules;
875  for (Int_t iStation = 0; iStation < GetNStations(); ++iStation) {
876  vector<CbmMuchModule*> stationModules = GetModules(iStation);
877  for (vector<CbmMuchModule*>::iterator it = stationModules.begin();
878  it != stationModules.end();
879  it++) {
880  CbmMuchModule* module = (*it);
881  if (module->GetDetectorType() != 3 && module->GetDetectorType() != 4)
882  continue; //Detector type 3:GEM, 4:RPC
883  modules.push_back((CbmMuchModuleGem*) module);
884  assert(CbmMuchAddress::GetStationIndex(module->GetDetectorId())
885  == iStation);
886  }
887  }
888  return modules;
889 }
890 // -------------------------------------------------------------------------
891 
892 
893 // -------------------------------------------------------------------------
894 vector<CbmMuchModule*> CbmMuchGeoScheme::GetModules(Int_t iStation) const {
895 
896  try {
897  return fModules.at(iStation);
898  } catch (std::out_of_range exc) {
899  Fatal("GetModules", "No input array of stations.");
900  }
901  return vector<CbmMuchModule*>();
902 }
903 // -------------------------------------------------------------------------
904 
905 ClassImp(CbmMuchGeoScheme)
CbmMuchLayerSide::AddModule
void AddModule(CbmMuchModule *module)
Definition: CbmMuchLayerSide.cxx:42
CbmMuchLayerSide.h
CbmMuchModule.h
CbmMuchGeoScheme::GetZ
Double_t GetZ(const TString &path)
Definition: CbmMuchGeoScheme.cxx:443
CbmMuchStation::SetModuleDesign
void SetModuleDesign(Bool_t on)
Definition: CbmMuchStation.h:41
CbmMuchGeoScheme::fGeoID
Int_t fGeoID
ModuleCopyID with module type.
Definition: CbmMuchGeoScheme.h:173
CbmMuchGeoScheme
Definition: CbmMuchGeoScheme.h:43
CbmMuchGeoScheme::GetModule
CbmMuchModule * GetModule(Int_t iStation, Int_t iLayer, Bool_t iSide, Int_t iModule) const
Definition: CbmMuchGeoScheme.cxx:238
CbmMuchGeoScheme::Rmin
Double_t Rmin
Definition: CbmMuchGeoScheme.h:228
CbmMuchGeoScheme::StationNode
void StationNode(TGeoNode *MuchObjNode, TString MuchObjPath)
Definition: CbmMuchGeoScheme.cxx:491
CbmMuchStation::GetLayer
CbmMuchLayer * GetLayer(Int_t iLayer) const
Definition: CbmMuchStation.h:58
CbmMuchGeoScheme::muchLy
CbmMuchLayer * muchLy
Definition: CbmMuchGeoScheme.h:226
CbmMuchStation
Definition: CbmMuchStation.h:22
CbmMuchGeoScheme::GetLayerSides
std::vector< CbmMuchLayerSide * > GetLayerSides(Int_t iStation) const
Definition: CbmMuchGeoScheme.cxx:378
CbmMuchLayer::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchLayer.h:46
CbmMuchGeoScheme::fStations
TObjArray * fStations
Definition: CbmMuchGeoScheme.h:184
CbmMuchGeoScheme::GetLayerSideByDetId
CbmMuchLayerSide * GetLayerSideByDetId(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:268
CbmMuchGeoScheme::fInitialized
static Bool_t fInitialized
Definition: CbmMuchGeoScheme.h:176
CbmMuchStation::SetTubeRmax
void SetTubeRmax(Double_t rMax)
Definition: CbmMuchStation.h:43
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:41
CbmMuchModule::SetPoints
void SetPoints(TClonesArray *points)
Definition: CbmMuchModule.h:60
CbmMuchGeoScheme::fDetType
TArrayI fDetType
Definition: CbmMuchGeoScheme.h:219
CbmMuchStation::SetRmin
void SetRmin(Double_t rMin)
Definition: CbmMuchStation.h:39
CbmMuchGeoScheme::GetSizeY
Double_t GetSizeY(const TString &path)
Definition: CbmMuchGeoScheme.cxx:430
CbmMuchGeoScheme::~CbmMuchGeoScheme
~CbmMuchGeoScheme()
Definition: CbmMuchGeoScheme.cxx:105
CbmMuchGeoScheme::fNlayers
TArrayI fNlayers
Definition: CbmMuchGeoScheme.h:218
CbmMuchGeoScheme::GetModulePhi
Double_t GetModulePhi(const TString &path)
Definition: CbmMuchGeoScheme.cxx:804
CbmMuchGeoScheme::fVolumeBoxShape
TGeoBBox * fVolumeBoxShape
Definition: CbmMuchGeoScheme.h:163
CbmMuchGeoScheme::GetSizeX
Double_t GetSizeX(const TString &path)
Definition: CbmMuchGeoScheme.cxx:423
CbmMuchGeoScheme::GetSizeZ
Double_t GetSizeZ(const TString &path)
Definition: CbmMuchGeoScheme.cxx:437
CbmMuchGeoScheme::fGlobal
Double_t fGlobal[3]
Definition: CbmMuchGeoScheme.h:165
CbmMuchGeoScheme::Init
void Init(TObjArray *stations, Int_t flag)
Definition: CbmMuchGeoScheme.cxx:121
CbmMuchGeoScheme::fLayersDz
TArrayD fLayersDz
Definition: CbmMuchGeoScheme.h:220
CbmMuchModule::SetClusters
void SetClusters(TClonesArray *clusters)
Definition: CbmMuchModule.h:62
CbmMuchGeoScheme::GetGemModules
std::vector< CbmMuchModuleGem * > GetGemModules() const
Definition: CbmMuchGeoScheme.cxx:872
CbmMuchGeoScheme::ExtractGeoParameter
void ExtractGeoParameter(TGeoNode *muchNode, const char *volumeName)
Definition: CbmMuchGeoScheme.cxx:463
CbmMuchLayer::GetSide
CbmMuchLayerSide * GetSide(Bool_t side)
Definition: CbmMuchLayer.h:49
CbmMuchGeoScheme::GetModuleH1
Double_t GetModuleH1(const TString &path)
Definition: CbmMuchGeoScheme.cxx:810
CbmMuchGeoScheme::fActiveLzSector
Double_t fActiveLzSector
Definition: CbmMuchGeoScheme.h:208
CbmMuchLayer::GetSupportDy
Double_t GetSupportDy() const
Definition: CbmMuchLayer.h:51
CbmMuchGeoScheme::Dx2
Double_t Dx2
Definition: CbmMuchGeoScheme.h:230
CbmMuchModuleGemRadial.h
CbmMuchGeoScheme::fGlobalTrap
Double_t fGlobalTrap[3]
Definition: CbmMuchGeoScheme.h:166
CbmMuchGeoScheme::GetModuleY
Double_t GetModuleY(const TString &path)
Definition: CbmMuchGeoScheme.cxx:791
CbmMuchGeoScheme::GetStationByDetId
CbmMuchStation * GetStationByDetId(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:249
CbmMuchGeoScheme::GetY
Double_t GetY(const TString &path)
Definition: CbmMuchGeoScheme.cxx:450
CbmMuchLayer::SetSupportDx
void SetSupportDx(Double_t supDx)
Definition: CbmMuchLayer.h:53
CbmMuchGeoScheme::GetModuleX
Double_t GetModuleX(const TString &path)
Definition: CbmMuchGeoScheme.cxx:798
CbmMuchAddress::GetModuleIndex
static Int_t GetModuleIndex(Int_t address)
Definition: CbmMuchAddress.h:112
CbmMuchGeoScheme::ClearPointArrays
void ClearPointArrays()
Definition: CbmMuchGeoScheme.cxx:337
CbmMuchGeoScheme::GetNStations
Int_t GetNStations() const
Definition: CbmMuchGeoScheme.h:79
CbmMuchGeoScheme::fNSectorsPerLayer
TArrayI fNSectorsPerLayer
Definition: CbmMuchGeoScheme.h:207
CbmMuchModule::InitModule
virtual Bool_t InitModule()
Definition: CbmMuchModule.h:57
CbmMuchGeoScheme::fVolumeTrapShape
TGeoTrap * fVolumeTrapShape
Definition: CbmMuchGeoScheme.h:164
CbmMuchLayer::SetSupportDz
void SetSupportDz(Double_t supDz)
Definition: CbmMuchLayer.h:55
CbmMuchModuleGemRadial
Definition: CbmMuchModuleGemRadial.h:21
CbmMuchStation::SetTubeRmin
void SetTubeRmin(Double_t rMin)
Definition: CbmMuchStation.h:42
CbmMuchLayerSide::GetModule
CbmMuchModule * GetModule(Int_t iModule) const
Definition: CbmMuchLayerSide.h:52
CbmMuchGeoScheme::CreateHitArrays
void CreateHitArrays()
Definition: CbmMuchGeoScheme.cxx:301
CbmMuchGeoScheme::muchLySd
CbmMuchLayerSide * muchLySd
Definition: CbmMuchGeoScheme.h:227
CbmMuchGeoScheme::Instance
static CbmMuchGeoScheme * Instance()
Definition: CbmMuchGeoScheme.cxx:113
CbmMuchModuleGem
Definition: CbmMuchModuleGem.h:24
CbmMuchGeoScheme::LayerNode
void LayerNode(TGeoNode *StNode, Int_t iStation, TString StPath)
Definition: CbmMuchGeoScheme.cxx:636
CbmMuchGeoScheme::fSides
std::vector< std::vector< CbmMuchLayerSide * > > fSides
Definition: CbmMuchGeoScheme.h:181
CbmMuchLayer::SetSupportDy
void SetSupportDy(Double_t supDy)
Definition: CbmMuchLayer.h:54
CbmMuchStation::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchStation.h:48
CbmMuchLayerSide
Definition: CbmMuchLayerSide.h:22
CbmMuchGeoScheme::Intersect
Int_t Intersect(Float_t x, Float_t y, Float_t dx, Float_t dy, Float_t r)
Definition: CbmMuchGeoScheme.cxx:829
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
CbmMuchModule::SetHits
void SetHits(TClonesArray *hits)
Definition: CbmMuchModule.h:61
CbmMuchGeoScheme::muchSt
CbmMuchStation * muchSt
Definition: CbmMuchGeoScheme.h:225
CbmMuchLayer::GetSupportDx
Double_t GetSupportDx() const
Definition: CbmMuchLayer.h:50
CbmMuchGeoScheme::fInstance
static CbmMuchGeoScheme * fInstance
Definition: CbmMuchGeoScheme.h:175
CbmMuchModule
Definition: CbmMuchModule.h:24
CbmMuchLayer.h
CbmMuchAddress::GetLayerIndex
static Int_t GetLayerIndex(Int_t address)
Definition: CbmMuchAddress.h:106
CbmMuchGeoScheme::ActiveModuleNode
void ActiveModuleNode(TGeoNode *moduleNode, Int_t iStation, Int_t iLayer, Int_t iModule, TString modulePath)
Definition: CbmMuchGeoScheme.cxx:678
CbmMuchAddress::GetStationIndex
static Int_t GetStationIndex(Int_t address)
Definition: CbmMuchAddress.h:103
CbmMuchModule::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchModule.h:48
CbmMuchGeoScheme::fMapSides
std::map< Int_t, Int_t > fMapSides
Definition: CbmMuchGeoScheme.h:182
CbmMuchGeoScheme::GetLayerSide
CbmMuchLayerSide * GetLayerSide(Int_t iStation, Int_t iLayer, Bool_t iSide) const
Definition: CbmMuchGeoScheme.cxx:228
CbmMuchGeoScheme::GetLayer
CbmMuchLayer * GetLayer(Int_t iStation, Int_t iLayer) const
Definition: CbmMuchGeoScheme.cxx:220
CbmMuchGeoScheme::fSupportLz
TArrayD fSupportLz
Definition: CbmMuchGeoScheme.h:221
CbmMuchModule::GetClusters
TClonesArray * GetClusters() const
Definition: CbmMuchModule.h:55
CbmMuchModule::GetDetectorType
Int_t GetDetectorType() const
Definition: CbmMuchModule.h:52
CbmMuchGeoScheme::InitModules
void InitModules()
Definition: CbmMuchGeoScheme.cxx:150
CbmMuchGeoScheme::NavigateTo
void NavigateTo(const TString &path)
Definition: CbmMuchGeoScheme.cxx:411
CbmMuchGeoScheme::fModulesInitialized
static Bool_t fModulesInitialized
Definition: CbmMuchGeoScheme.h:178
CbmMuchGeoScheme::fModuleDesign
TArrayI fModuleDesign
Definition: CbmMuchGeoScheme.h:222
CbmMuchGeoScheme::GetModuleDZ
Double_t GetModuleDZ(const TString &path)
Definition: CbmMuchGeoScheme.cxx:777
CbmMuchGeoScheme::fModules
std::vector< std::vector< CbmMuchModule * > > fModules
Definition: CbmMuchGeoScheme.h:180
CbmMuchAddress.h
CbmMuchGeoScheme::fCurrentVolume
TGeoVolume * fCurrentVolume
Definition: CbmMuchGeoScheme.h:162
CbmMuchGeoScheme::ClearClusterArrays
void ClearClusterArrays()
Definition: CbmMuchGeoScheme.cxx:362
CbmMuchGeoScheme::fStationZ0
TArrayD fStationZ0
Definition: CbmMuchGeoScheme.h:217
CbmMuchGeoScheme::fGeoPathHash
UInt_t fGeoPathHash
Definition: CbmMuchGeoScheme.h:161
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMuchStation::SetRmax
void SetRmax(Double_t rMax)
Definition: CbmMuchStation.h:40
CbmMuchGeoScheme::GetX
Double_t GetX(const TString &path)
Definition: CbmMuchGeoScheme.cxx:457
CbmMuchGeoScheme::CbmMuchGeoScheme
CbmMuchGeoScheme()
Definition: CbmMuchGeoScheme.cxx:47
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
CbmMuchGeoScheme::GetStation
CbmMuchStation * GetStation(Int_t iStation) const
Definition: CbmMuchGeoScheme.cxx:209
CbmMuchStation::GetNLayers
Int_t GetNLayers() const
Definition: CbmMuchStation.h:50
CbmMuchGeoScheme::Rmax
Double_t Rmax
Definition: CbmMuchGeoScheme.h:229
CbmMuchGeoScheme::GetModules
std::vector< CbmMuchModule * > GetModules() const
Definition: CbmMuchGeoScheme.cxx:852
CbmMuchGeoScheme::ClearHitArrays
void ClearHitArrays()
Definition: CbmMuchGeoScheme.cxx:350
CbmMuchGeoScheme.h
CbmMuchLayer::GetSideF
CbmMuchLayerSide * GetSideF()
Definition: CbmMuchLayer.h:47
CbmMuchGeoScheme::GetModuleBl1
Double_t GetModuleBl1(const TString &path)
Definition: CbmMuchGeoScheme.cxx:816
CbmMuchLayer
Definition: CbmMuchLayer.h:21
CbmMuchGeoScheme::fNst
Int_t fNst
Definition: CbmMuchGeoScheme.h:193
CbmMuchGeoScheme::GetModuleZ
Double_t GetModuleZ(const TString &path)
Definition: CbmMuchGeoScheme.cxx:784
CbmMuchLayer::GetSideB
CbmMuchLayerSide * GetSideB()
Definition: CbmMuchLayer.h:48
CbmMuchStation::AddLayer
void AddLayer(CbmMuchLayer *layer)
Definition: CbmMuchStation.cxx:50
CbmMuchGeoScheme::GetLayerByDetId
CbmMuchLayer * GetLayerByDetId(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:258
CbmMuchStation::GetRmin
Double_t GetRmin() const
Definition: CbmMuchStation.h:51
CbmMuchGeoScheme::GetModuleByDetId
CbmMuchModule * GetModuleByDetId(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:278
CbmMuchStation.h
CbmMuchLayerSide::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchLayerSide.h:46
CbmMuchGeoScheme::CreatePointArrays
void CreatePointArrays()
Definition: CbmMuchGeoScheme.cxx:288
CbmMuchGeoScheme::NavigateModule
void NavigateModule(const TString &path)
Definition: CbmMuchGeoScheme.cxx:764
CbmMuchModuleGem.h
CbmMuchAddress::GetLayerSideIndex
static Int_t GetLayerSideIndex(Int_t address)
Definition: CbmMuchAddress.h:109
CbmMuchGeoScheme::GetModuleTl1
Double_t GetModuleTl1(const TString &path)
Definition: CbmMuchGeoScheme.cxx:822
CbmMuchLayerSide::SetZ
void SetZ(Double_t z)
Definition: CbmMuchLayerSide.h:50
CbmMuchGeoScheme::CreateClusterArrays
void CreateClusterArrays()
Definition: CbmMuchGeoScheme.cxx:322
CbmMuchGeoScheme::GetLayerSideNr
Int_t GetLayerSideNr(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:403
CbmMuchGeoScheme::ModuleNode
void ModuleNode(TGeoNode *layerNode, Int_t iStation, Int_t iLayer, TString layerPath)
Definition: CbmMuchGeoScheme.cxx:658
CbmMuchLayerSide::GetNModules
Int_t GetNModules() const
Definition: CbmMuchLayerSide.h:47