BmnRoot
Loading...
Searching...
No Matches
CbmStsDigiScheme.cxx
Go to the documentation of this file.
1//* $Id: */
2
3// -------------------------------------------------------------------------
4// ----- CbmStsDigiScheme source file -----
5// ----- Created 31/08/06 by V. Friese -----
6// -------------------------------------------------------------------------
7#include "CbmStsDigiScheme.h"
8
9#include "BmnVSPStationSet.h"
10#include "CbmGeoStsPar.h"
11#include "CbmStsDetectorId.h"
12#include "CbmStsDigiPar.h"
13#include "CbmStsSector.h"
14#include "CbmStsSectorDigiPar.h"
15#include "CbmStsSensor.h"
16#include "CbmStsSensorDigiPar.h"
17#include "CbmStsStation.h"
18#include "CbmStsStationDigiPar.h"
19#include "FairGeoMedium.h"
20#include "FairGeoNode.h"
21#include "FairGeoTransform.h"
22#include "FairGeoVector.h"
23#include "FairLogger.h"
24#include "FairRunAna.h"
25#include "FairRuntimeDb.h"
26#include "TArrayD.h"
27#include "TGeoBBox.h"
28#include "TGeoManager.h"
29#include "TGeoMatrix.h"
30
31#include <iostream>
32#include <map>
33
34using std::cout;
35using std::endl;
36using std::flush;
37using std::map;
38using std::pair;
39
40// ----- Initialisation of static singleton pointer --------------------
41CbmStsDigiScheme* CbmStsDigiScheme::fgInstance = NULL;
42int CbmStsDigiScheme::fVersion = -1; // AZ-290322
43// -------------------------------------------------------------------------
44
45// ----- Constructor ---------------------------------------------------
46CbmStsDigiScheme::CbmStsDigiScheme()
47 : fStations(new TObjArray(10))
48 , fNSectors(0)
49 , fNSensors(0)
50 , fNChannels(0)
51 , fIsNewGeometry(kFALSE)
52 , fStationMap()
53 , fDetIdByName()
54 , fSensorByName()
55{
56 // AZ fStations = new TObjArray(10);
57 // AZ fNSectors = fNSensors = fNChannels = 0;
58 if (fgInstance == NULL)
59 fgInstance = this;
60 if (gGeoManager)
61 Init();
62}
63// -------------------------------------------------------------------------
64
65CbmStsDigiScheme* CbmStsDigiScheme::Instance(int version)
66{
67 // Singleton instance
68
69 if (fVersion < 0)
70 fVersion = version; // AZ-030922
71 if (fgInstance == NULL)
72 new CbmStsDigiScheme();
73 // AZ-030922 if (fVersion < 0) fVersion = version; //AZ-290322
74 return fgInstance;
75}
76
77// ----- Destructor ----------------------------------------------------
78CbmStsDigiScheme::~CbmStsDigiScheme()
79{
80 if (fStations) {
81 fStations->Delete();
82 delete fStations;
83 }
84}
85// -------------------------------------------------------------------------
86
87// ----- Public method Init --------------------------------------------
88Bool_t CbmStsDigiScheme::Init()
89{
91 // FairRunAna *run = FairRunAna::Instance();
92 // FairRuntimeDb *rtdb = run->GetRuntimeDb();;
93 FairRuntimeDb* rtdb = FairRuntimeDb::instance();
95
96 // Get STS geometry parameter container
97 CbmGeoStsPar* geoPar = (CbmGeoStsPar*)rtdb->getContainer("CbmGeoStsPar");
98
99 // Get STS digitisation parameter container
100 CbmStsDigiPar* digiPar = (CbmStsDigiPar*)rtdb->getContainer("CbmStsDigiPar");
101
102 Init(geoPar, digiPar);
103
104 return kTRUE;
105}
106// -------------------------------------------------------------------------
107
108// ----- Public method Init --------------------------------------------
109Bool_t CbmStsDigiScheme::Init(CbmGeoStsPar* geoPar, CbmStsDigiPar* digiPar)
110{
111
112 // if (fNChannels) return kTRUE; //AZ - for singleton
113 if (fStations->GetEntries())
114 return kTRUE; // SM - for singleton
115
116 // Check availability of parameters
117 /* if ( ! geoPar ) {
118 cout << "-W- CbmStsDigiScheme::Init: "
119 << "No geometry parameters available!" << endl;
120 return kFALSE;
121 } */
122 if (!digiPar) {
123 cout << "-W- CbmStsDigiScheme::Init: "
124 << "No digitisation parameters available!" << endl;
125 return kFALSE;
126 }
127
128 TGeoVolume* test = NULL;
129
130 // Check for new geometry version. Should contain STS volume on level 2.
131 if (gGeoManager == nullptr) {
132 LOG(error) << "gGeoManager has null pointer";
133 return kFALSE;
134 }
135 TGeoNode* top = gGeoManager->GetTopNode();
136 for (Int_t iNode = 0; iNode < top->GetNdaughters(); iNode++) {
137 TString nodeName = top->GetDaughter(iNode)->GetName();
138 if (nodeName.Contains("GEMS")) {
139 test = top->GetDaughter(iNode)->GetVolume();
140 break;
141 }
142 }
143 if (test) {
144 // cout << "CbmStsDigiScheme:: Init for new geometry "
145 // << test->GetName() << endl;
146 fIsNewGeometry = kTRUE;
147 // AZ-290322 return InitNew(NULL, digiPar);
148 if (fVersion)
149 return InitNewNew(NULL, digiPar); // AZ-290322
150 else {
151 AddHotZones(); // AZ-290322 - add GEM hot zones as separate volumes to BM@N
152 return InitNew(NULL, digiPar); // AZ-290322
153 }
154 }
155
156 // If none found, bail out
157 cout << "-E- CbmStsDigiScheme::Init: unknown geometry version" << endl;
158 return kFALSE;
159}
160// -------------------------------------------------------------------------
161
162// -------------------------------------------------------------------------
163
164// ----- Public method Clear -------------------------------------------
165void CbmStsDigiScheme::Clear()
166{
167 fStations->Delete();
168 fStationMap.clear();
169 fDetIdByName.clear();
170 fSensorByName.clear();
171 fNSectors = fNSensors = fNChannels = 0;
172}
173// -------------------------------------------------------------------------
174
175// ----- Public method Reset -------------------------------------------
176void CbmStsDigiScheme::Reset()
177{
178 for (Int_t iStation = 0; iStation < fStations->GetEntries(); iStation++)
179 GetStation(iStation)->Reset();
180}
181// -------------------------------------------------------------------------
182
183// ----- Public method GetStation --------------------------------------
184CbmStsStation* CbmStsDigiScheme::GetStation(Int_t iStation)
185{
186 if (!fStations)
187 return NULL;
188 return dynamic_cast<CbmStsStation*>(fStations->At(iStation));
189}
190// -------------------------------------------------------------------------
191
192// ----- Public method GetStationByNr ----------------------------------
193CbmStsStation* CbmStsDigiScheme::GetStationByNr(Int_t stationNr)
194{
195 if (!fStations)
196 return NULL;
197 if (fStationMap.find(stationNr) == fStationMap.end())
198 return NULL;
199 return fStationMap[stationNr];
200}
201// -------------------------------------------------------------------------
202
203// ----- Public method GetSector ---------------------------------------
204CbmStsSector* CbmStsDigiScheme::GetSector(Int_t stationNr, Int_t sectorNr)
205{
206 return (GetStationByNr(stationNr)->GetSectorByNr(sectorNr));
207}
208// -------------------------------------------------------------------------
209
210// ----- Public method GetSensor ---------------------------------------
211CbmStsSensor* CbmStsDigiScheme::GetSensor(Int_t stationNr, Int_t sectorNr, Int_t sensorNr)
212{
213 return (GetStationByNr(stationNr)->GetSectorByNr(sectorNr)->GetSensorByNr(sensorNr));
214}
215// -------------------------------------------------------------------------
216
217// ----- Public method GetDetectorIdByName ------------------------------
218Int_t CbmStsDigiScheme::GetDetectorIdByName(TString sensorName)
219{
220 map<TString, Int_t>::iterator p;
221 p = fDetIdByName.find(sensorName);
222
223 if (p != fDetIdByName.end()) {
224 return p->second;
225 } else {
226 cout << " -E- StsDigiScheme::GetDetectorIdByName \"" << sensorName.Data() << "\" not found " << endl;
227 return -1;
228 }
229}
230// -------------------------------------------------------------------------
231
232// ----- Public method GetSensorIdByName --------------------------------
233CbmStsSensor* CbmStsDigiScheme::GetSensorByName(TString sensorName)
234{
235 map<TString, CbmStsSensor*>::iterator p;
236 p = fSensorByName.find(sensorName);
237
238 if (p != fSensorByName.end()) {
239 return p->second;
240 } else {
241 LOG(debug) << "StsDigiScheme: sensor " << sensorName.Data() << " not found ";
242 return NULL;
243 }
244}
245// -------------------------------------------------------------------------
246
247// ----- Public method Print -------------------------------------------
248void CbmStsDigiScheme::Print(Bool_t kLong)
249{
250 cout << endl;
251 cout << "=================== STS digitisation scheme =================" << endl;
252 for (Int_t iStat = 0; iStat < GetNStations(); iStat++) {
253 CbmStsStation* station = GetStation(iStat);
254 station->Print(kLong);
255 }
256 cout << "================================================================" << endl << endl;
257}
258// -------------------------------------------------------------------------
259
260// ---- Init new ----------------------------------------------------------
261Bool_t CbmStsDigiScheme::InitNewNew(CbmGeoStsPar* geoPar, CbmStsDigiPar* digiPar)
262{
263 // Digi scheme for BM@N configuration
264
265 Double_t statD = 0.03; // A dirty fix. TODO
266 Double_t statRadLength = 9.34953; // TODO
267 // AZ
268 // if ( TString(shape->ClassName()).Contains("Composite") ) {
269 // statD = 0.02;
270 // statRadLength = 3.56; // Titanium
271 // }
272 // AZ
273 Double_t statRmin = 0.;
274 Double_t statRmax = 6; // 2. * TMath::Max(shape->GetDX(), shape->GetDY());
275 // Double_t statRot = stationPar->GetRotation();
276
277 TString gPathConfig = gSystem->Getenv("VMCWORKDIR");
278
279 TString gemSet = "GemRun8.xml";
280 TString silSet = "SiliconRun8.xml";
281 TString vspSet = "";
282 if (fVersion == 9) {
283 silSet = "SiliconRun9.xml";
284 gemSet = "GemRun9.xml";
285 vspSet = "VSP_Run9.xml";
286 }
287
288 // Create GEM detector ------------------------------------------------------
289 GemStationSet = new BmnGemStripStationSet(gPathConfig + "/parameters/gem/XMLConfigs/" + gemSet);
290 // if (fVersion == 4) SilStationSet =
291 // new BmnSiliconStationSet(gPathConfig + "/parameters/silicon/XMLConfigs/SiliconRun8_mods_6_10_14_18.xml");
292 // //AZ-041022
293 // else
294
295 SilStationSet = new BmnSiliconStationSet(gPathConfig + "/parameters/silicon/XMLConfigs/" + silSet);
296 fVspStationSet = nullptr;
297 if (vspSet != "")
298 fVspStationSet = new BmnVSPStationSet(gPathConfig + "/parameters/vsp/XMLConfigs/" + vspSet);
299
300 //---> AZ-040625 - Run 9
301 int nVspStat = (fVspStationSet) ? fVspStationSet->GetNStations() : 0;
302
303 for (Int_t iSt = 0; iSt < nVspStat; ++iSt) {
304 BmnVSPStation* siStation = fVspStationSet->GetStation(iSt);
305 statRmax = TMath::Max(siStation->GetXSize(), siStation->GetYSize());
306 // AZ CbmStsStation* station = new CbmStsStation(Form("stat%02d", iSt + 1), iSt + 1, siStation->GetZPosition(),
307 // statD, statRadLength, 0, 0, 0);
308 CbmStsStation* station = new CbmStsStation(Form("stat%02d", iSt + 1), iSt + 1, siStation->GetZPosition(), statD,
309 statRadLength, 0, statRmax, 0);
310 Double_t zmean = 0.0; // AZ-210625
311
312 for (Int_t iMod = 0; iMod < siStation->GetNModules(); ++iMod) {
313 BmnVSPModule* siModule = siStation->GetModule(iMod);
314 Int_t detId = kVSP << 24 | (iSt + 1) << 16 | (iMod + 1) << 4 | 1 << 1;
315 CbmStsSector* sector = new CbmStsSector(Form("sect%02d", iMod + 1), detId); // ???????
316 Float_t x0 = 0.5 * (siModule->GetXMinModule() + siModule->GetXMaxModule());
317 Float_t y0 = 0.5 * (siModule->GetYMinModule() + siModule->GetYMaxModule());
318 Float_t z0 = siModule->GetZPositionRegistered();
319 Float_t d0 = siModule->GetModuleThickness();
320 BmnVSPLayer lay = siModule->GetStripLayer(siModule->GetNStripLayers() - 1);
321 // CbmStsSensor* sensor = new CbmStsSensor(detId, 2, x0, y0, 0, siModule->GetXSize(), siModule->GetYSize(),
322 // 0.01, 0.0, 0.0, lay.GetAngleRad());
323 CbmStsSensor* sensor =
324 new CbmStsSensor("", detId, 2, x0, y0, z0, 0, siModule->GetXSize(), siModule->GetYSize(), d0, 0.01, 0.0,
325 0.0, lay.GetAngleRad()); // ???????
326 sector->AddSensor(sensor);
327 station->AddSector(sector);
328 zmean += z0; // AZ-210625
329 }
330 station->SetZ(zmean / siStation->GetNModules()); // AZ-210625
331 fStations->Add(station);
332 // AZ fStationMap[iSt] = station;
333 fStationMap[iSt + 1] = station; // AZ
334 }
335 //<---
336
337 // printf("SilStationSet->GetNStations() = %d\n", SilStationSet->GetNStations());
338 int nSiStat = SilStationSet->GetNStations(); // AZ-190322
339 // nSiStat = 0; //AZ-190322 - w/out Si
340
341 for (Int_t iSt = 0; iSt < nSiStat; ++iSt) { // AZ-190322
342 BmnSiliconStation* siStation = SilStationSet->GetStation(iSt);
343 statRmax = TMath::Max(siStation->GetXSize(), siStation->GetYSize()); // AZ
344 // AZ CbmStsStation* station = new CbmStsStation(Form("stat%02d", iSt + 1), iSt + 1, siStation->GetZPosition(),
345 // statD, statRadLength, 0, 0, 0);
346 // AZ-060625 CbmStsStation* station = new CbmStsStation(Form("stat%02d", iSt + 1), iSt + 1,
347 // siStation->GetZPosition(), statD, statRadLength, 0, statRmax, 0);
348 CbmStsStation* station =
349 new CbmStsStation(Form("stat%02d", iSt + 1 + nVspStat), iSt + 1 + nVspStat, siStation->GetZPosition(),
350 statD, statRadLength, 0, statRmax, 0); // AZ-060625
351
352 for (Int_t iMod = 0; iMod < siStation->GetNModules(); ++iMod) {
353 BmnSiliconModule* siModule = siStation->GetModule(iMod);
354 Int_t detId = kSILICON << 24 | (iSt + 1) << 16 | (iMod + 1) << 4 | 1 << 1;
355 CbmStsSector* sector = new CbmStsSector(Form("sect%02d", iMod + 1), detId);
356 Float_t x0 = 0.5 * (siModule->GetXMinModule() + siModule->GetXMaxModule());
357 Float_t y0 = 0.5 * (siModule->GetYMinModule() + siModule->GetYMaxModule());
358 Float_t z0 = siModule->GetZPositionRegistered();
359 Float_t d0 = siModule->GetModuleThickness();
360 BmnSiliconLayer lay = siModule->GetStripLayer(siModule->GetNStripLayers() - 1);
361 // CbmStsSensor* sensor = new CbmStsSensor(detId, 2, x0, y0, 0, siModule->GetXSize(), siModule->GetYSize(),
362 // 0.01, 0.0, 0.0, lay.GetAngleRad());
363 CbmStsSensor* sensor = new CbmStsSensor("", detId, 2, x0, y0, z0, 0, siModule->GetXSize(),
364 siModule->GetYSize(), d0, 0.01, 0.0, 0.0, lay.GetAngleRad());
365 sector->AddSensor(sensor);
366 station->AddSector(sector);
367 }
368 fStations->Add(station);
369 // AZ fStationMap[iSt] = station;
370 fStationMap[iSt + nVspStat + 1] = station; // AZ
371 }
372
373 // printf("GemStationSet->GetNStations() = %d\n", GemStationSet->GetNStations());
374 for (Int_t iSt = 0; iSt < GemStationSet->GetNStations(); ++iSt) {
375 BmnGemStripStation* gemStation = GemStationSet->GetStation(iSt);
376 statRmax = TMath::Max(gemStation->GetXSize(), gemStation->GetYSize()); // AZ
377 // Double_t statRot = (gemStation->GetModule(0)->GetElectronDriftDirection() == 1) ? 0 : Pi();
378
379 // AZ CbmStsStation* station = new CbmStsStation(Form("stat%02d", iSt + 1 + SilStationSet->GetNStations()), iSt
380 // + 1 + SilStationSet->GetNStations(), gemStation->GetZPosition(), statD, statRadLength, statRmin, statRmax,
381 // statRot);
382 // AZ-060625 CbmStsStation* station = new CbmStsStation(Form("stat%02d", iSt + 1 + nSiStat), iSt + 1 + nSiStat,
383 CbmStsStation* station = new CbmStsStation(
384 Form("stat%02d", iSt + 1 + nSiStat + nVspStat), iSt + 1 + nSiStat + nVspStat, // AZ-060625
385 gemStation->GetZPosition(), statD, statRadLength, statRmin, statRmax, 0);
386
387 for (Int_t iMod = 0; iMod < gemStation->GetNModules(); ++iMod) {
388 BmnGemStripModule* gemModule = gemStation->GetModule(iMod);
389
390 /*AZ-230322
391 Int_t detId = 2 << 24 | (iSt + 1 + nSiStat) << 16 | (iMod + 1) << 4 | 1 << 1;
392 CbmStsSector* sector = new CbmStsSector(Form("sect%02d", iMod + 1), detId);
393 Float_t x0 = 0.5 * (gemModule->GetXMinModule() + gemModule->GetXMaxModule());
394 Float_t y0 = 0.5 * (gemModule->GetYMinModule() + gemModule->GetYMaxModule());
395 CbmStsSensor* sensor = new CbmStsSensor(detId, 2, x0, y0, 0, gemModule->GetXSize(), gemModule->GetYSize(),
396 0.08, 0.0, 0.0, gemModule->GetStripLayer(1).GetAngleRad());
397 */
398 Double_t z0 = gemModule->GetZPositionRegistered();
399 Double_t d0 = gemModule->GetModuleThickness();
400 // AZ-230322
401 Int_t sens = 1;
402 for (Int_t iL = 0; iL < gemModule->GetNStripLayers(); iL += 2) {
403 BmnGemStripLayer gemLay = gemModule->GetStripLayer(iL);
404 // cout << gemLay.GetAngleDeg() << endl;
405 int sect = (iMod % 2) * 2 + (iMod / 2 * 4) + 1 + iL / 2;
406 Int_t detId = kGEM << 24 | (iSt + 1 + nSiStat) << 16 | sect << 4 | sens << 1;
407 CbmStsSector* sector = new CbmStsSector(Form("sect%02d", sect), detId);
408 Double_t x0 = 0.5 * (gemLay.GetXMinLayer() + gemLay.GetXMaxLayer());
409 Double_t y0 = 0.5 * (gemLay.GetYMinLayer() + gemLay.GetYMaxLayer());
410 Double_t xSize = gemLay.GetXSize();
411 Double_t ySize = gemLay.GetYSize();
412 // cout << " AAAAAA " << iMod << " " << iL << " " << sect << " " << x0 << " " << y0 << " " << xSize << "
413 // " << ySize << endl; AZ-230322 CbmStsSensor* sensor = new CbmStsSensor(detId, 2, x0, y0, 0, xSize,
414 // ySize, 0.08, 0.0, 0.0, gemModule->GetStripLayer(1).GetAngleRad()); //TODO
415 CbmStsSensor* sensor = new CbmStsSensor("", detId, 2, x0, y0, z0, 0, xSize, ySize, d0, 0.08, 0.0, 0.0,
416 gemModule->GetStripLayer(1).GetAngleRad());
417 sector->AddSensor(sensor);
418 station->AddSector(sector);
419 }
420 }
421 fStations->Add(station);
422 // AZ fStationMap[iSt + SilStationSet->GetNStations()] = station;
423 fStationMap[iSt + nSiStat + nVspStat + 1] = station; // AZ
424 }
425 // printf("fStations->GetEntries() = %d\n", fStations->GetEntries());
426
427 // return kTRUE;
428
429 // //cout<<digiPar->GetNStations()<<endl;
430
431 // // Get STS node
432 // TGeoNode* sts = NULL;
433 // gGeoManager->CdTop();
434 // TGeoNode* cave = gGeoManager->GetCurrentNode();
435 // for (Int_t iNode = 0; iNode < cave->GetNdaughters(); iNode++) {
436 // TGeoNode* node = cave->GetDaughter(iNode);
437 // TString name = node->GetName();
438 // cout<<"NODE: "<<name<<endl;
439 // if ( name.Contains("GEMS_0") ) {
440 // sts = node;
441 // gGeoManager->CdDown(iNode);
442 // break;
443 // }
444 // }
445 // if ( ! sts ) {
446 // cout << "-E- CbmStsDigiScheme::InitNew: Cannot find top GEM node"
447 // << endl;
448 // return kFALSE;
449 // }
450
451 // cout << "stations: " << sts->GetNdaughters() << endl;
452
453 // // Loop over stations in STS
454
455 // Int_t statNr = 0, stNr = 0; //AZ
456
457 // for (Int_t iNode = 0; iNode < sts->GetNdaughters(); iNode++) {
458 // // Go to station node
459 // //if(iNode==0) continue;
460 // gGeoManager->CdDown(iNode);
461 // TGeoNode* stationNode = gGeoManager->GetCurrentNode();
462 // TString statName = stationNode->GetName();
463 // if ( ! statName.Contains("station") ) { //GP Station -> station
464 // gGeoManager->CdUp();
465 // continue;
466 // }
467 // cout<<"station: "<< iNode << " " << sts->GetNdaughters()<< " " << statName << endl;
468 // //AZ Int_t statNr = stationNode->GetNumber();
469
470 // ++stNr;
471 // /*
472 // if(stNr<4){
473 // gGeoManager->CdUp();
474 // cout<<" Station skipped !!!"<<endl;
475 // continue;} */
476
477 // ++statNr; //AZ
478 // //skip Si tracker
479
480 // // Get station parameters
481 // CbmStsStationDigiPar* stationPar = NULL;
482 // for (Int_t iStation = 0; iStation < digiPar->GetNStations(); iStation++) {
483 // CbmStsStationDigiPar* partest1 = digiPar->GetStation(iStation);
484 // if ( partest1->GetStationNr() == statNr ) {
485 // stationPar = partest1;
486 // break;
487 // }
488 // }
489 // if ( ! stationPar ) {
490 // cout << "-E- CbmStsDigiScheme::InitNew: No parameters for station "
491 // << statNr << endl;
492 // //AZ return kFALSE;
493 // return kTRUE; //AZ - reduced geometry
494 // }
495
496 // // Create CbmStsStation
497 // TGeoBBox* shape = (TGeoBBox*) (stationNode->GetVolume()->GetShape());
498 // statName = Form("stat%02d", statNr);
499 // Double_t* statTrans = gGeoManager->GetCurrentMatrix()->GetTranslation();
500 // Double_t statZ = statTrans[2];
501 // //Double_t statD = 2. * shape->GetDZ();
502 // Double_t statD = 0.03; // A dirty fix. TODO
503 // Double_t statRadLength = 9.34953; // TODO
504 // //AZ
505 // /*
506 // if ( TString(shape->ClassName()).Contains("Composite") ) {
507 // statD = 0.02;
508 // statRadLength = 3.56; // Titanium
509 // }
510 // if (stationNode->GetNdaughters() % 2 > 0) {
511 // // GEMs - 3 daughters
512 // statRadLength = 0.9 / 0.02 * 3.56; // effective rad. length
513 // }
514 // */
515 // //AZ
516 // Double_t statRmin = 0.;
517 // Double_t statRmax = 2. * TMath::Max(shape->GetDX(), shape->GetDY());
518 // Double_t statRot = stationPar->GetRotation();
519 // CbmStsStation* station = new CbmStsStation(statName, statNr, statZ, statD,
520 // statRadLength, statRmin,
521 // statRmax, statRot);
522 // //AZ station->SetXYminmax(-2*shape->GetDX(),-2*shape->GetDY(),2*shape->GetDX(),2*shape->GetDY()); //AZ
523 // //station->SetXYminmax(-1*shape->GetDX(),-1*shape->GetDY(),1*shape->GetDX(),1*shape->GetDY()); //AZ
524 // //station->SetXYminmax(-shape->GetDX()+statTrans[0], -shape->GetDY()+statTrans[1],
525 // // shape->GetDX()+statTrans[0], shape->GetDY()+statTrans[1]); //AZ
526 // fStations->Add(station);
527 // fStationMap[statNr] = station;
528
529 // // Loop over modules in the station
530 // Int_t moduleNr = 0; // moduleNr ---> sector number in current station !!
531 // Int_t sensNr = 0;
532 // Int_t nModules = stationNode->GetNdaughters();
533
534 // for (Int_t iModule = 0; iModule < nModules; iModule++) {
535 // if (statNr > -1) gGeoManager->CdDown(iModule); ///FIX AZ
536
537 // TGeoNode* moduleNode = gGeoManager->GetCurrentNode();
538 // TString moduleName = moduleNode->GetName();
539 // cout << "moduleName: " << moduleName << endl;
540 // if ( ! (moduleName.Contains("module") || moduleName.Contains("adder") ||
541 // moduleName.Contains("ensor")) ) {
542 // gGeoManager->CdUp();
543 // continue;
544 // }
545
546 // if (moduleName.Contains("adder")) {
547 // // CBM Si stations
548 // Int_t nsens = SetSensorsCbm(moduleNr, statNr, station, stationPar);
549 // fNSensors += nsens;
550 // moduleNr += nsens;
551 // gGeoManager->CdUp(); // to station
552
553 // } else if (statNr <= 3) {
554 // // Silicon in run 7
555 // moduleNr++;
556 // fNSensors += SetSensor(moduleNr,statNr,station,stationPar)->GetNSensors();
557 // gGeoManager->CdUp(); // to station
558
559 // } else {
560 // // GEMs
561 // moduleNr++;
562 // cout << gGeoManager->GetCurrentNode()->GetName() << " " << gGeoManager->GetCurrentMatrix()->GetTranslation()[2]
563 // << endl;
564
565 // fNSensors += SetSensor(moduleNr,statNr, station, stationPar)->GetNSensors();
566
567 // // Loop over sensors in the sector
568
569 // Int_t nSensors = moduleNode->GetNdaughters();
570
571 // for (Int_t iSensor = 0; iSensor < nSensors; iSensor++) {
572
573 // //cout<<"iSensor: "<<iSensor<<endl;
574 // gGeoManager->CdDown(iSensor);
575 // //cout<<"dbg: 1"<<endl;
576 // TGeoNode* sensorNode = gGeoManager->GetCurrentNode();
577 // //cout<<"Ses name: "<<sensorNode->GetName()<<endl;
578 // if ( ! TString(sensorNode->GetName()).Contains("Sensor") ) {
579 // gGeoManager->CdUp();
580 // continue;
581 // }
582
583 // moduleNr++;
584 // fNSensors += SetSensor(moduleNr,statNr,station,stationPar)->GetNSensors();
585
586 // gGeoManager->CdUp(); // to module
587 // }
588 // // sensor loop
589 // gGeoManager->CdUp(); // to station
590 // } // ladder loop
591 // }
592 // fNSectors += station->GetNSectors();
593 // fNChannels += station->GetNChannels();
594 // gGeoManager->CdUp(); // to sts
595 // } // station loop
596
597 // cout << "-I- CbmStsDigiScheme::InitNew: Intialisation successful" << endl;
598 // Print();
599 return kTRUE;
600}
601// -------------------------------------------------------------------------
602
603Bool_t CbmStsDigiScheme::InitNew(CbmGeoStsPar* geoPar, CbmStsDigiPar* digiPar)
604{
605 // CBM (old) configuration
606
607 // cout<<digiPar->GetNStations()<<endl;
608
609 // Get STS node
610 TGeoNode* sts = NULL;
611 gGeoManager->CdTop();
612 TGeoNode* cave = gGeoManager->GetCurrentNode();
613 Int_t statNr = 0, stNr = 0; // AZ-280322
614
615 for (Int_t iNode0 = 0; iNode0 < cave->GetNdaughters(); iNode0++) {
616 gGeoManager->CdTop(); // AZ-280322
617 TGeoNode* node = cave->GetDaughter(iNode0);
618 TString name = node->GetName();
619 cout << "NODE: " << name << endl;
620 /*AZ-270322
621 if ( name.Contains("GEMS_0") ) {
622 sts = node;
623 gGeoManager->CdDown(iNode);
624 break;
625 }
626 }
627 */
628 if (!(name.Contains("GEMS_0") || name.Contains("Silicon_0")))
629 continue;
630 // if ( !(name.Contains("Silicon_0")) ) continue;
631 cout << " xxxxxxxxx " << name << endl;
632 sts = node;
633 gGeoManager->CdDown(iNode0);
634
635 if (!sts) {
636 cout << "-E- CbmStsDigiScheme::InitNew: Cannot find top GEM node" << endl;
637 return kFALSE;
638 }
639
640 cout << "stations: " << sts->GetNdaughters() << endl;
641
642 // Loop over stations in STS
643
644 // AZ-280322 Int_t statNr = 0, stNr = 0; //AZ
645
646 for (Int_t iNode = 0; iNode < sts->GetNdaughters(); iNode++) {
647 // Go to station node
648 // if(iNode==0) continue;
649 gGeoManager->CdDown(iNode);
650 TGeoNode* stationNode = gGeoManager->GetCurrentNode();
651 TString statName = stationNode->GetName();
652 if (!statName.Contains("station")) { // GP Station -> station
653 gGeoManager->CdUp();
654 continue;
655 }
656 cout << "station: " << iNode << " " << sts->GetNdaughters() << " " << statName << endl;
657 // AZ Int_t statNr = stationNode->GetNumber();
658
659 ++stNr;
660 /*
661 if(stNr<4){
662 gGeoManager->CdUp();
663 cout<<" Station skipped !!!"<<endl;
664 continue;} */
665
666 ++statNr; // AZ
667 // skip Si tracker
668
669 // Get station parameters
670 CbmStsStationDigiPar* stationPar = NULL;
671 for (Int_t iStation = 0; iStation < digiPar->GetNStations(); iStation++) {
672 CbmStsStationDigiPar* partest1 = digiPar->GetStation(iStation);
673 if (partest1->GetStationNr() == statNr) {
674 stationPar = partest1;
675 break;
676 }
677 }
678 if (!stationPar) {
679 cout << "-E- CbmStsDigiScheme::InitNew: No parameters for station " << statNr << endl;
680 // AZ return kFALSE;
681 return kTRUE; // AZ - reduced geometry
682 }
683
684 // Create CbmStsStation
685 TGeoBBox* shape = (TGeoBBox*)(stationNode->GetVolume()->GetShape());
686 statName = Form("stat%02d", statNr);
687 Double_t* statTrans = gGeoManager->GetCurrentMatrix()->GetTranslation();
688 Double_t statZ = statTrans[2];
689 // Double_t statD = 2. * shape->GetDZ();
690 Double_t statD = 0.03; // A dirty fix. TODO
691 Double_t statRadLength = 9.34953; // TODO
692 // AZ
693 /*
694 if ( TString(shape->ClassName()).Contains("Composite") ) {
695 statD = 0.02;
696 statRadLength = 3.56; // Titanium
697 }
698 if (stationNode->GetNdaughters() % 2 > 0) {
699 // GEMs - 3 daughters
700 statRadLength = 0.9 / 0.02 * 3.56; // effective rad. length
701 }
702 */
703 // AZ
704 Double_t statRmin = 0.;
705 Double_t statRmax = 2. * TMath::Max(shape->GetDX(), shape->GetDY());
706 Double_t statRot = stationPar->GetRotation();
707 CbmStsStation* station =
708 new CbmStsStation(statName, statNr, statZ, statD, statRadLength, statRmin, statRmax, statRot);
709 // AZ station->SetXYminmax(-2*shape->GetDX(),-2*shape->GetDY(),2*shape->GetDX(),2*shape->GetDY()); //AZ
710 // station->SetXYminmax(-1*shape->GetDX(),-1*shape->GetDY(),1*shape->GetDX(),1*shape->GetDY()); //AZ
711 // station->SetXYminmax(-shape->GetDX()+statTrans[0], -shape->GetDY()+statTrans[1],
712 // shape->GetDX()+statTrans[0], shape->GetDY()+statTrans[1]); //AZ
713 fStations->Add(station);
714 fStationMap[statNr] = station;
715
716 // Loop over modules in the station
717 Int_t moduleNr = 0; // moduleNr ---> sector number in current station !!
718 // Int_t sensNr = 0;
719 Int_t nModules = stationNode->GetNdaughters();
720
721 for (Int_t iModule = 0; iModule < nModules; iModule++) {
722 if (statNr > -1)
723 gGeoManager->CdDown(iModule);
724
725 TGeoNode* moduleNode = gGeoManager->GetCurrentNode();
726 TString moduleName = moduleNode->GetName();
727 cout << "moduleName: " << moduleName << endl;
728 if (!(moduleName.Contains("module") || moduleName.Contains("adder") || moduleName.Contains("ensor"))) {
729 gGeoManager->CdUp();
730 continue;
731 }
732
733 if (moduleName.Contains("adder")) {
734 // CBM Si stations
735 Int_t nsens = SetSensorsCbm(moduleNr, statNr, station, stationPar);
736 fNSensors += nsens;
737 moduleNr += nsens;
738 gGeoManager->CdUp(); // to station
739
740 // AZ-170322 } else if (statNr <= 3) {
741 } else if (sts->GetNdaughters() > 7 && statNr <= 3) { // AZ-170322
742 // Silicon in run 7
743 moduleNr++;
744 fNSensors += SetSensor(moduleNr, statNr, station, stationPar)->GetNSensors();
745 gGeoManager->CdUp(); // to station
746
747 } else if (sts->GetNdaughters() < 5) { // AZ-280322
748 // Silicon in run 8
749 moduleNr++;
750 fNSensors += SetSensor(moduleNr, statNr, station, stationPar)->GetNSensors();
751 gGeoManager->CdUp(); // to station
752
753 } else {
754 // GEMs
755 moduleNr++;
756 cout << nModules << " " << gGeoManager->GetCurrentNode()->GetName() << " "
757 << gGeoManager->GetCurrentMatrix()->GetTranslation()[2] << endl;
758
759 fNSensors += SetSensor(moduleNr, statNr, station, stationPar)->GetNSensors();
760
761 // AZ-170322 - BM@N geometry
762 if (0) {
763 // if (TString(gGeoManager->GetCurrentNode()->GetName()).Contains("Sensor_module")) {
764 // BM@N geometry - hot zone is not a separate volume
765 AddHotZone(++moduleNr, statNr, station, stationPar);
766 } else {
767 // Loop over sensors in the sector
768
769 Int_t nSensors = moduleNode->GetNdaughters();
770
771 for (Int_t iSensor = 0; iSensor < nSensors; iSensor++) {
772
773 // cout<<"iSensor: "<<iSensor<<endl;
774 gGeoManager->CdDown(iSensor);
775 // cout<<"dbg: 1"<<endl;
776 TGeoNode* sensorNode = gGeoManager->GetCurrentNode();
777 // cout<<"Ses name: "<<sensorNode->GetName()<<endl;
778 if (!TString(sensorNode->GetName()).Contains("Sensor")) {
779 gGeoManager->CdUp();
780 continue;
781 }
782
783 moduleNr++;
784 fNSensors += SetSensor(moduleNr, statNr, station, stationPar)->GetNSensors();
785
786 gGeoManager->CdUp(); // to module
787 } // sensor loop
788 } // else
789 gGeoManager->CdUp(); // to station
790 } // ladder loop
791 }
792 fNSectors += station->GetNSectors();
793 fNChannels += station->GetNChannels();
794 gGeoManager->CdUp(); // to sts
795 } // station loop
796 } // AZ-270322
797 // cout << "-I- CbmStsDigiScheme::InitNew: Intialisation successful" << endl;
798 Print();
799 return kTRUE;
800}
801// -------------------------------------------------------------------------
802
803// ----- GetPath -------------------------------------------------------
804TString CbmStsDigiScheme::GetCurrentPath()
805{
806
807 TString path;
808
809 if (!gGeoManager) {
810 cout << "-E- CbmStsDigiScheme::GetCurrentPath:: No TGeoManager" << endl;
811 return path;
812 }
813
814 TGeoNode* cNode = gGeoManager->GetCurrentNode();
815 while (cNode) {
816 TString nodeName = cNode->GetName();
817 path = "/" + nodeName + path;
818 if (cNode == gGeoManager->GetTopNode())
819 break;
820 gGeoManager->CdUp();
821 cNode = gGeoManager->GetCurrentNode();
822 }
823
824 gGeoManager->cd(path.Data());
825
826 return path;
827}
828// -------------------------------------------------------------------------
829
830CbmStsSector* CbmStsDigiScheme::SetSensor(Int_t moduleNr,
831 Int_t statNr,
832 CbmStsStation* station,
833 CbmStsStationDigiPar* stationPar)
834{
835
836 CbmStsSector* sector = NULL;
837 CbmStsSensorDigiPar* sensorPar = NULL;
838 CbmStsSectorDigiPar* sectorPar = NULL;
839
840 for (Int_t iSector = 0; iSector < stationPar->GetNSectors(); iSector++) {
841 CbmStsSectorDigiPar* partest2 = stationPar->GetSector(iSector);
842 if (partest2->GetSectorNr() == moduleNr) {
843 sectorPar = partest2;
844 break;
845 }
846 }
847 if (!sectorPar) {
848 cout << "-E- CbmStsDigiScheme::SetSensor: No parameters for module " << moduleNr << ", station " << statNr
849 << endl;
850 // return kFALSE;
851 }
852
853 // Create CbmStsSector
854 TString sectName = Form("stat%02dsect%d", statNr, moduleNr);
855 Int_t sectId = 2 << 24 | statNr << 16 | moduleNr << 4;
856 sector = new CbmStsSector(sectName.Data(), sectId);
857 station->AddSector(sector);
858 // cout<<"DIGI SHEME: SEN N: "<<sector->GetSectorNr()<<endl;
859 // Int_t sensNr = sensorNode->GetNumber();
860 Int_t sensNr = 1;
861
862 // Get sensor parameters
863
864 for (Int_t iPar = 0; iPar < sectorPar->GetNSensors(); iPar++) {
865 CbmStsSensorDigiPar* partest3 = sectorPar->GetSensor(iPar);
866 if (partest3->GetSensorNr() == sensNr) {
867 sensorPar = partest3;
868 break;
869 }
870 }
871 if (!sensorPar) {
872 cout << "-E- CbmStsDigiScheme::SetSensor: No parameters for sensor " << sensNr << ", module " << moduleNr
873 << ", station " << statNr << endl;
874 // return kFALSE;
875 }
876 // Create CbmStsSensor
877 Double_t* sensTrans = gGeoManager->GetCurrentMatrix()->GetTranslation();
878 TString sensName = gGeoManager->GetPath();
879 Int_t sensId = 2 << 24 | statNr << 16 | moduleNr << 4 | sensNr << 1;
880 Int_t sensType = sensorPar->GetType();
881 Double_t sensX = sensTrans[0];
882 Double_t sensY = sensTrans[1];
883 // Double_t sensZ =sensorPar->GetZ0();// sensTrans[2]; GP
884 Double_t sensZ = sensTrans[2];
885 Double_t sensRot = sensorPar->GetRotation();
886 Double_t sensLx = sensorPar->GetLx();
887 Double_t sensLy = sensorPar->GetLy();
888 Double_t sensD = sensorPar->GetD();
889 // AZ - does not work Double_t sensD = station->GetD();
890 Double_t sensDx = sensorPar->GetDx();
891 Double_t sensDy = sensorPar->GetDy();
892 // AZ - 9feb2019
893 if (sensDx > 0.02) { // using strip pitch
894 Double_t zShift = 0.3;
895 if (statNr % 2 == 1)
896 zShift *= -1;
897 // AZ sensZ += zShift;
898 }
899 Double_t sensStereoF = sensorPar->GetStereoF();
900 Double_t sensStereoB = sensorPar->GetStereoB();
901 CbmStsSensor* sensor = new CbmStsSensor(sensName, sensId, sensType, sensX, sensY, sensZ, sensRot, sensLx, sensLy,
902 sensD, sensDx, sensDy, sensStereoF, sensStereoB);
903 sector->AddSensor(sensor);
904 if (fDetIdByName.find(sensName) != fDetIdByName.end()) {
905 cout << "-E- CbmStsDigiScheme: Duplicate sensor name " << sensName << endl;
906 // return kFALSE;
907 }
908
909 fDetIdByName[sensName] = sensId;
910 if (fSensorByName.find(sensName) != fSensorByName.end()) {
911 cout << "-E- CbmStsDigiScheme: Duplicate sensor name " << sensName << endl;
912 // return kFALSE;
913 }
914 fSensorByName[sensName] = sensor;
915 // if (sensX > 0) station->SetZ(sensZ); //AZ
916 // station->SetZ(sensZ); //AZ
917
918 return sector;
919}
920
921// -------------------------------------------------------------------------
922
923Int_t CbmStsDigiScheme::SetSensorsCbm(Int_t moduleNr,
924 Int_t statNr,
925 CbmStsStation* statCBM,
926 CbmStsStationDigiPar* stationPar)
927{
928 // Process CBM Si station
929
930 TGeoManager* geoMan = gGeoManager;
931 TGeoNode* ladder = geoMan->GetCurrentNode();
932 Int_t nD = ladder->GetNdaughters();
933 Int_t modNr0 = moduleNr;
934
935 // Loop over ladder daughters (half-ladders)
936 for (Int_t i2 = 0; i2 < nD; i2++) {
937 if (!TString(ladder->GetDaughter(i2)->GetName()).Contains("HalfLadder"))
938 continue;
939
940 // Down to half-ladder
941 geoMan->CdDown(i2);
942 TGeoNode* halflad = geoMan->GetCurrentNode();
943 Int_t nHalfLadD = halflad->GetNdaughters();
944
945 // Loop over half-ladder daughters (modules)
946 for (Int_t imod = 0; imod < nHalfLadD; imod++) {
947 // TGeoNode *sens = halflad->GetDaughter(imod)->GetDaughter(0);
948 // cout << sens->GetName() << endl;
949 geoMan->CdDown(imod);
950 geoMan->CdDown(0);
951 ++moduleNr;
952 SetSensor(moduleNr, statNr, statCBM, stationPar);
953 // cout << moduleNr << " " << geoMan->GetPath() << endl;
954 geoMan->CdUp();
955 geoMan->CdUp();
956 }
957
958 geoMan->CdUp();
959 } // loop over half-ladders
960
961 return moduleNr - modNr0;
962}
963
964// -------------------------------------------------------------------------
965
966Int_t CbmStsDigiScheme::AddHotZone(Int_t moduleNr,
967 Int_t statNr,
968 CbmStsStation* station,
969 CbmStsStationDigiPar* stationPar)
970{
971 // AZ - add GEM hot zone if it is not described as a separate volume
972
973 CbmStsSector* sector = NULL;
974 CbmStsSensorDigiPar* sensorPar = NULL;
975 CbmStsSectorDigiPar* sectorPar = NULL;
976
977 for (Int_t iSector = 0; iSector < stationPar->GetNSectors(); iSector++) {
978 CbmStsSectorDigiPar* partest2 = stationPar->GetSector(iSector);
979 if (partest2->GetSectorNr() == moduleNr) {
980 sectorPar = partest2;
981 break;
982 }
983 }
984 if (!sectorPar) {
985 cout << "-E- CbmStsDigiScheme::SetSensor: No parameters for module " << moduleNr << ", station " << statNr
986 << endl;
987 // return kFALSE;
988 }
989 cout << " mod, sectors: " << moduleNr << " " << stationPar->GetNSectors() << " " << sectorPar->GetNSensors()
990 << "\n"; // AZ-170322
991
992 // Create CbmStsSector
993 TString sectName = Form("stat%02dsect%d", statNr, moduleNr);
994 Int_t sectId = 2 << 24 | statNr << 16 | moduleNr << 4;
995 sector = new CbmStsSector(sectName.Data(), sectId);
996 station->AddSector(sector);
997 // cout<<"DIGI SHEME: SEN N: "<<sector->GetSectorNr()<<endl;
998 // Int_t sensNr = sensorNode->GetNumber();
999 Int_t sensNr = 1;
1000
1001 // Get sensor parameters
1002
1003 for (Int_t iPar = 0; iPar < sectorPar->GetNSensors(); iPar++) {
1004 CbmStsSensorDigiPar* partest3 = sectorPar->GetSensor(iPar);
1005 if (partest3->GetSensorNr() == sensNr) {
1006 sensorPar = partest3;
1007 break;
1008 }
1009 }
1010 if (!sensorPar) {
1011 cout << "-E- CbmStsDigiScheme::SetSensor: No parameters for sensor " << sensNr << ", module " << moduleNr
1012 << ", station " << statNr << endl;
1013 // return kFALSE;
1014 }
1015 // Create CbmStsSensor
1016 // AZ-180322 Double_t* sensTrans = gGeoManager->GetCurrentMatrix()->GetTranslation();
1017 Double_t sensTrans[3] = {sensorPar->GetX0(), sensorPar->GetY0(), sensorPar->GetZ0()}; // AZ-180322
1018 TString sensName = gGeoManager->GetPath();
1019 sensName += "/hotZone";
1020 Int_t sensId = 2 << 24 | statNr << 16 | moduleNr << 4 | sensNr << 1;
1021 Int_t sensType = sensorPar->GetType();
1022 Double_t sensX = sensTrans[0];
1023 Double_t sensY = sensTrans[1];
1024 // Double_t sensZ =sensorPar->GetZ0();// sensTrans[2]; GP
1025 Double_t sensZ = sensTrans[2];
1026 Double_t sensRot = sensorPar->GetRotation();
1027 Double_t sensLx = sensorPar->GetLx();
1028 Double_t sensLy = sensorPar->GetLy();
1029 Double_t sensD = sensorPar->GetD();
1030 // AZ - does not work Double_t sensD = station->GetD();
1031 Double_t sensDx = sensorPar->GetDx();
1032 Double_t sensDy = sensorPar->GetDy();
1033 // AZ - 9feb2019
1034 if (sensDx > 0.02) { // using strip pitch
1035 Double_t zShift = 0.3;
1036 if (statNr % 2 == 1)
1037 zShift *= -1;
1038 // AZ sensZ += zShift;
1039 }
1040 Double_t sensStereoF = sensorPar->GetStereoF();
1041 Double_t sensStereoB = sensorPar->GetStereoB();
1042 CbmStsSensor* sensor = new CbmStsSensor(sensName, sensId, sensType, sensX, sensY, sensZ, sensRot, sensLx, sensLy,
1043 sensD, sensDx, sensDy, sensStereoF, sensStereoB);
1044 sector->AddSensor(sensor);
1045 if (fDetIdByName.find(sensName) != fDetIdByName.end()) {
1046 cout << "-E- CbmStsDigiScheme: Duplicate sensor name " << sensName << endl;
1047 // return kFALSE;
1048 }
1049
1050 fDetIdByName[sensName] = sensId;
1051 if (fSensorByName.find(sensName) != fSensorByName.end()) {
1052 cout << "-E- CbmStsDigiScheme: Duplicate sensor name " << sensName << endl;
1053 // return kFALSE;
1054 }
1055 fSensorByName[sensName] = sensor;
1056 // if (sensX > 0) station->SetZ(sensZ); //AZ
1057 // station->SetZ(sensZ); //AZ
1058
1059 return 1;
1060}
1061
1062// -------------------------------------------------------------------------
1063
1064void CbmStsDigiScheme::AddHotZones()
1065{
1066 // AZ - add GEM hot zones as separate volumes to BM@N geometry
1067
1068 cout << " AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA " << endl;
1069 // Get STS node
1070 TGeoNode* sts = NULL;
1071 gGeoManager->CdTop();
1072 TGeoNode* cave = gGeoManager->GetCurrentNode();
1073 for (Int_t iNode = 0; iNode < cave->GetNdaughters(); iNode++) {
1074 TGeoNode* node = cave->GetDaughter(iNode);
1075 TString name = node->GetName();
1076 cout << "NODE: " << name << endl;
1077 if (name.Contains("GEMS_0")) {
1078 sts = node;
1079 gGeoManager->CdDown(iNode);
1080 break;
1081 }
1082 }
1083 if (!sts) {
1084 cout << "-E- CbmStsDigiScheme::AddHotZones: Cannot find top GEM node" << endl;
1085 return;
1086 }
1087
1088 cout << "stations: " << sts->GetNdaughters() << endl;
1089
1090 // Loop over stations in STS
1091
1092 // Int_t statNr = 0, stNr = 0;
1093
1094 for (Int_t iNode = 0; iNode < sts->GetNdaughters(); iNode++) {
1095 // Go to station node
1096 gGeoManager->CdDown(iNode);
1097 TGeoNode* stationNode = gGeoManager->GetCurrentNode();
1098 TString statName = stationNode->GetName();
1099 if (!statName.Contains("station")) {
1100 gGeoManager->CdUp();
1101 continue;
1102 }
1103 cout << " Station: " << iNode << " " << sts->GetNdaughters() << " " << statName << endl;
1104
1105 // Loop over modules in the station
1106 // Int_t moduleNr = 0; // moduleNr ---> sector number in current station !!
1107 // Int_t sensNr = 0;
1108 Int_t nModules = stationNode->GetNdaughters();
1109
1110 for (Int_t iModule = 0; iModule < nModules; iModule++) {
1111 gGeoManager->CdDown(iModule);
1112 TGeoNode* moduleNode = gGeoManager->GetCurrentNode();
1113 TString moduleName = moduleNode->GetName();
1114 cout << " ModuleName: " << moduleName << endl;
1115 if (!(moduleName.Contains("Sensor_module"))) {
1116 gGeoManager->CdUp();
1117 continue;
1118 }
1119 // Add hot zone
1120 Double_t hzone[3] = {20, 15.0 / 2, 0}; // hot zone half-dimensions
1121 TGeoVolume* hotVol = nullptr /*, *coldVol = nullptr*/;
1122 const Double_t* tr = moduleNode->GetMatrix()->GetTranslation(); // cold zone position
1123 TGeoVolume* mod = moduleNode->GetVolume();
1124 TGeoCompositeShape* shape = (TGeoCompositeShape*)mod->GetShape();
1125 Double_t wxyzMain[3] = {shape->GetDX(), shape->GetDY(), shape->GetDZ()};
1126 cout << wxyzMain[0] << " " << wxyzMain[1] << " " << wxyzMain[2] << endl;
1127 cout << tr[0] << " " << tr[1] << " " << tr[2] << endl;
1128 Double_t dxyzHot[3] = {0};
1129 TGeoBBox* hZone = new TGeoBBox("hotZone", hzone[0], hzone[1], wxyzMain[2]);
1130 hotVol = new TGeoVolume("Sensor_hot", hZone);
1131 hotVol->SetMedium(mod->GetMedium());
1132 if (tr[0] > 0 && tr[1] > 0) {
1133 dxyzHot[0] = -wxyzMain[0] + hzone[0];
1134 dxyzHot[1] = -wxyzMain[1] + hzone[1];
1135 } else if (tr[0] > 0 && tr[1] < 0) {
1136 dxyzHot[0] = -wxyzMain[0] + hzone[0];
1137 dxyzHot[1] = -wxyzMain[1] + hzone[1];
1138 } else if (tr[0] < 0 && tr[1] < 0) {
1139 dxyzHot[0] = -wxyzMain[0] + hzone[0];
1140 dxyzHot[1] = -wxyzMain[1] + hzone[1];
1141 } else if (tr[0] < 0 && tr[1] > 0) {
1142 dxyzHot[0] = -wxyzMain[0] + hzone[0];
1143 dxyzHot[1] = -wxyzMain[1] + hzone[1];
1144 }
1145 TString transName = "stat";
1146 transName += iNode;
1147 transName += "mod";
1148 transName += iModule;
1149 TGeoTranslation* hot = new TGeoTranslation(transName, dxyzHot[0], dxyzHot[1], 0.0);
1150 hot->RegisterYourself();
1151 mod->AddNode(hotVol, 0, hot);
1152 gGeoManager->CdUp();
1153 }
1154
1155 gGeoManager->CdUp();
1156 }
1157}
z0
const Float_t z0
Definition BmnMwpcHit.cxx:6
kSILICON
@ kSILICON
Definition BmnDetectorList.h:25
kGEM
@ kGEM
Definition BmnDetectorList.h:15
kVSP
@ kVSP
Definition BmnDetectorList.h:21
BmnGemStripLayer::GetYMinLayer
Double_t GetYMinLayer()
Definition BmnGemStripLayer.h:54
BmnGemStripLayer::GetYMaxLayer
Double_t GetYMaxLayer()
Definition BmnGemStripLayer.h:55
BmnGemStripLayer::GetXMinLayer
Double_t GetXMinLayer()
Definition BmnGemStripLayer.h:52
BmnGemStripLayer::GetXMaxLayer
Double_t GetXMaxLayer()
Definition BmnGemStripLayer.h:53
BmnGemStripModule::GetModuleThickness
Double_t GetModuleThickness()
Definition BmnGemStripModule.h:54
BmnGemStripModule::GetStripLayer
BmnGemStripLayer & GetStripLayer(Int_t num)
Definition BmnGemStripModule.h:71
BmnGemStripModule::GetZPositionRegistered
Double_t GetZPositionRegistered()
Definition BmnGemStripModule.cxx:73
BmnGemStripStationSet::GetStation
BmnGemStripStation * GetStation(Int_t station_num)
Definition BmnGemStripStationSet.h:45
BmnGemStripStation::GetModule
BmnGemStripModule * GetModule(Int_t module_num)
Definition BmnGemStripStation.cxx:183
BmnSiliconLayer::GetAngleRad
Double_t GetAngleRad()
Definition BmnSiliconLayer.h:49
BmnSiliconModule::GetYMinModule
Double_t GetYMinModule()
Definition BmnSiliconModule.h:26
BmnSiliconModule::GetXMinModule
Double_t GetXMinModule()
Definition BmnSiliconModule.h:24
BmnSiliconModule::GetXMaxModule
Double_t GetXMaxModule()
Definition BmnSiliconModule.h:25
BmnSiliconModule::GetZPositionRegistered
Double_t GetZPositionRegistered()
Definition BmnSiliconModule.cxx:53
BmnSiliconModule::GetModuleThickness
Double_t GetModuleThickness()
Definition BmnSiliconModule.h:35
BmnSiliconModule::GetStripLayer
BmnSiliconLayer & GetStripLayer(Int_t num)
Definition BmnSiliconModule.h:76
BmnSiliconModule::GetYMaxModule
Double_t GetYMaxModule()
Definition BmnSiliconModule.h:27
BmnSiliconStationSet::GetStation
BmnSiliconStation * GetStation(Int_t station_num)
Definition BmnSiliconStationSet.h:41
BmnSiliconStation::GetModule
BmnSiliconModule * GetModule(Int_t module_num)
Definition BmnSiliconStation.cxx:95
BmnVSPLayer::GetAngleRad
Double_t GetAngleRad()
Definition BmnVSPLayer.h:49
BmnVSPModule::GetYMinModule
Double_t GetYMinModule()
Definition BmnVSPModule.h:26
BmnVSPModule::GetYSize
Double_t GetYSize()
Definition BmnVSPModule.h:30
BmnVSPModule::GetXSize
Double_t GetXSize()
Definition BmnVSPModule.h:29
BmnVSPModule::GetZPositionRegistered
Double_t GetZPositionRegistered()
Definition BmnVSPModule.cxx:53
BmnVSPModule::GetXMinModule
Double_t GetXMinModule()
Definition BmnVSPModule.h:24
BmnVSPModule::GetYMaxModule
Double_t GetYMaxModule()
Definition BmnVSPModule.h:27
BmnVSPModule::GetNStripLayers
Int_t GetNStripLayers()
Definition BmnVSPModule.h:75
BmnVSPModule::GetStripLayer
BmnVSPLayer & GetStripLayer(Int_t num)
Definition BmnVSPModule.h:76
BmnVSPModule::GetModuleThickness
Double_t GetModuleThickness()
Definition BmnVSPModule.h:35
BmnVSPModule::GetXMaxModule
Double_t GetXMaxModule()
Definition BmnVSPModule.h:25
BmnVSPStationSet::GetStation
BmnVSPStation * GetStation(Int_t station_num)
Definition BmnVSPStationSet.h:41
BmnVSPStation::GetNModules
Int_t GetNModules()
Definition BmnVSPStation.h:57
BmnVSPStation::GetModule
BmnVSPModule * GetModule(Int_t module_num)
Definition BmnVSPStation.cxx:95
BmnVSPStation::GetZPosition
Double_t GetZPosition()
Definition BmnVSPStation.h:69
BmnVSPStation::GetYSize
Double_t GetYSize()
Definition BmnVSPStation.h:65
BmnVSPStation::GetXSize
Double_t GetXSize()
Definition BmnVSPStation.h:64
CbmStsDigiPar::GetStation
CbmStsStationDigiPar * GetStation(Int_t iStation)
Definition CbmStsDigiPar.cxx:187
CbmStsDigiPar::GetNStations
Int_t GetNStations()
Definition CbmStsDigiPar.h:71
CbmStsDigiScheme::Print
void Print(Bool_t kLong=kFALSE)
Definition CbmStsDigiScheme.cxx:248
CbmStsDigiScheme::Instance
static CbmStsDigiScheme * Instance(int version=1)
Definition CbmStsDigiScheme.cxx:65
CbmStsDigiScheme::GetSensor
CbmStsSensor * GetSensor(Int_t stationNr, Int_t sectorNr, Int_t sensorNr)
Definition CbmStsDigiScheme.cxx:211
CbmStsDigiScheme::GetSensorByName
CbmStsSensor * GetSensorByName(TString sensorName)
Definition CbmStsDigiScheme.cxx:233
CbmStsDigiScheme::GetStationByNr
CbmStsStation * GetStationByNr(Int_t stationNr)
Definition CbmStsDigiScheme.cxx:193
CbmStsDigiScheme::GetSector
CbmStsSector * GetSector(Int_t stationNr, Int_t sectorNr)
Definition CbmStsDigiScheme.cxx:204
CbmStsDigiScheme::GetStation
CbmStsStation * GetStation(Int_t iStation)
Definition CbmStsDigiScheme.cxx:184
CbmStsDigiScheme::GetDetectorIdByName
Int_t GetDetectorIdByName(TString sensorName)
Definition CbmStsDigiScheme.cxx:218
CbmStsSectorDigiPar::GetSensor
CbmStsSensorDigiPar * GetSensor(Int_t iSensor)
Definition CbmStsSectorDigiPar.h:60
CbmStsSector::AddSensor
void AddSensor(CbmStsSensorDigiPar *sensorPar)
Definition CbmStsSector.cxx:125
CbmStsSector::GetNSensors
Int_t GetNSensors() const
Definition CbmStsSector.h:82
CbmStsSensorDigiPar::GetRotation
Double_t GetRotation() const
Definition CbmStsSensorDigiPar.h:62
CbmStsSensorDigiPar::GetStereoB
Double_t GetStereoB() const
Definition CbmStsSensorDigiPar.h:69
CbmStsSensorDigiPar::GetStereoF
Double_t GetStereoF() const
Definition CbmStsSensorDigiPar.h:68
CbmStsStationDigiPar::GetSector
CbmStsSectorDigiPar * GetSector(Int_t iSector)
Definition CbmStsStationDigiPar.h:49
CbmStsStation::Print
virtual void Print(Bool_t kLong)
Definition CbmStsStation.cxx:222
CbmStsStation::GetNSectors
Int_t GetNSectors() const
Definition CbmStsStation.h:62
CbmStsStation::AddSector
void AddSector(CbmStsSectorDigiPar *sectorPar)
Definition CbmStsStation.cxx:113
CbmStsStation::SetZ
void SetZ(Double_t z)
Definition CbmStsStation.h:73
setup.name
name
Definition setup.py:7