Cleanup of monitor package
[u/mrichter/AliRoot.git] / STEER / AliGeomManager.cxx
CommitLineData
67dd5535 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15//-------------------------------------------------------------------------
16// Implementation of AliGeomManager, the geometry manager class
17// which interfaces to TGeo and the look-up table mapping unique
18// volume indices to symbolic volume names. For that it collects
19// several static methods.
20//-------------------------------------------------------------------------
21
22#include <TClass.h>
23#include <TFile.h>
24#include <TGeoManager.h>
25#include <TObjString.h>
26#include <TGeoPhysicalNode.h>
27#include <TClonesArray.h>
28#include <TGeoMatrix.h>
29#include <TGeoPhysicalNode.h>
99de26a3 30#include <TSystem.h>
5590c6c3 31#include <TStopwatch.h>
32#include <TGeoOverlap.h>
33#include <TPluginManager.h>
34#include <TROOT.h>
67dd5535 35
36#include "AliGeomManager.h"
37#include "AliLog.h"
38#include "AliAlignObj.h"
90dbf5fb 39#include "AliAlignObjParams.h"
67dd5535 40#include "AliCDBManager.h"
41#include "AliCDBStorage.h"
42#include "AliCDBEntry.h"
43
44ClassImp(AliGeomManager)
45
46Int_t AliGeomManager::fgLayerSize[kLastLayer - kFirstLayer] = {
47 80, 160, // ITS SPD first and second layer
48 84, 176, // ITS SDD first and second layer
49 748, 950, // ITS SSD first and second layer
50 36, 36, // TPC inner and outer chambers
51 90, 90, 90, 90, 90, 90, // 6 TRD chambers' layers
52 1638, // TOF
df117114 53 5, 5, // PHOS,CPV
67dd5535 54 7, // HMPID ??
3dfc15c0 55 1, // MUON ??
56 12 // EMCAL
67dd5535 57};
58
59const char* AliGeomManager::fgLayerName[kLastLayer - kFirstLayer] = {
60 "ITS inner pixels layer", "ITS outer pixels layer",
61 "ITS inner drifts layer", "ITS outer drifts layer",
62 "ITS inner strips layer", "ITS outer strips layer",
63 "TPC inner chambers layer", "TPC outer chambers layer",
64 "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
65 "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
66 "TOF layer",
df117114 67 "PHOS EMC layer","PHOS CPV layer",
3dfc15c0 68 "HMPID layer",
69 "MUON ?",
70 "EMCAL layer"
67dd5535 71};
72
67dd5535 73TGeoPNEntry** AliGeomManager::fgPNEntry[kLastLayer - kFirstLayer] = {
74 0x0,0x0,
75 0x0,0x0,
76 0x0,0x0,
77 0x0,0x0,
78 0x0,0x0,0x0,
79 0x0,0x0,0x0,
80 0x0,
81 0x0,0x0,
82 0x0,
3dfc15c0 83 0x0,
67dd5535 84 0x0
85};
86
36b010bf 87AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
88 0x0,0x0,
89 0x0,0x0,
90 0x0,0x0,
91 0x0,0x0,
92 0x0,0x0,0x0,
93 0x0,0x0,0x0,
94 0x0,
95 0x0,0x0,
96 0x0,
3dfc15c0 97 0x0,
36b010bf 98 0x0
99};
67dd5535 100
4fbb8e9d 101const char* AliGeomManager::fgkDetectorName[AliGeomManager::fgkNDetectors] = {"GRP","ITS","TPC","TRD","TOF","PHOS","HMPID","EMCAL","MUON","FMD","ZDC","PMD","T0","VZERO","ACORDE"};
102Int_t AliGeomManager::fgNalignable[fgkNDetectors] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
103
104
67dd5535 105TGeoManager* AliGeomManager::fgGeometry = 0x0;
106
107//_____________________________________________________________________________
36b010bf 108void AliGeomManager::LoadGeometry(const char *geomFileName)
67dd5535 109{
9d47e237 110 // initialization
111 // Load geometry either from a file
112 // or from the corresponding CDB entry
67dd5535 113
a9870fe8 114 if(fgGeometry->IsLocked()){
115 AliErrorClass("Cannot load a new geometry, the current one being locked. Setting internal geometry to null!!");
116 fgGeometry = NULL;
117 return;
118 }
119
36b010bf 120 fgGeometry = NULL;
b8cf7791 121 if (geomFileName && (!gSystem->AccessPathName(geomFileName))) {
36b010bf 122 fgGeometry = TGeoManager::Import(geomFileName);
4fbb8e9d 123 AliInfoClass(Form("From now on using geometry from custom geometry file \"%s\"",geomFileName));
36b010bf 124 }
125
126 if (!fgGeometry) {
36b010bf 127 AliCDBPath path("GRP","Geometry","Data");
128
129 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
130 if(!entry) AliFatalClass("Couldn't load geometry data from CDB!");
131
132 entry->SetOwner(0);
133 fgGeometry = (TGeoManager*) entry->GetObject();
134 if (!fgGeometry) AliFatalClass("Couldn't find TGeoManager in the specified CDB entry!");
b8cf7791 135
4fbb8e9d 136 AliInfoClass(Form("From now on using geometry from CDB base folder \"%s\"",
b8cf7791 137 AliCDBManager::Instance()->GetURI("Geometry/Align/Data")));
36b010bf 138 }
3564f2da 139 ResetPNEntriesLUT();
67dd5535 140 InitPNEntriesLUT();
4fbb8e9d 141 InitNalignable();
67dd5535 142}
143
144//_____________________________________________________________________________
53dd673d 145void AliGeomManager::SetGeometry(TGeoManager * const geom)
9d47e237 146{
147 // Load already active geometry
148 if (!geom) AliFatalClass("Pointer to the active geometry is 0x0!");
3564f2da 149 ResetPNEntriesLUT();
9d47e237 150 fgGeometry = geom;
9d47e237 151 InitPNEntriesLUT();
4fbb8e9d 152 InitNalignable();
9d47e237 153}
154
155//_____________________________________________________________________________
67dd5535 156AliGeomManager::AliGeomManager():
36b010bf 157 TObject()
67dd5535 158{
159 // default constructor
160}
161
162//_____________________________________________________________________________
163AliGeomManager::~AliGeomManager()
164{
165 // dummy destructor
67dd5535 166}
167
168//_____________________________________________________________________________
169Int_t AliGeomManager::LayerSize(Int_t layerId)
170{
171 // Get the layer size for layer corresponding to layerId.
172 // Implemented only for ITS,TPC,TRD,TOF and HMPID
173 //
174 if (layerId < kFirstLayer || layerId >= kLastLayer) {
175 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
176 return 0;
177 }
178 else {
179 return fgLayerSize[layerId - kFirstLayer];
5aedd709 180 }
67dd5535 181}
182
183//_____________________________________________________________________________
184const char* AliGeomManager::LayerName(Int_t layerId)
185{
186 // Get the layer name corresponding to layerId.
187 // Implemented only for ITS,TPC,TRD,TOF and HMPID
188 //
189 if (layerId < kFirstLayer || layerId >= kLastLayer) {
190 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
191 return "Invalid Layer!";
192 }
193 else {
194 return fgLayerName[layerId - kFirstLayer];
5aedd709 195 }
67dd5535 196}
197
198//_____________________________________________________________________________
199UShort_t AliGeomManager::LayerToVolUID(ELayerID layerId, Int_t modId)
200{
201 // From detector (layer) name and module number (according to detector
202 // internal numbering) build the unique numerical identity of that volume
203 // inside ALICE
204 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
205 // remaining 11 for module ID inside det (2048 possible values).
206 // NO check for validity of given modId inside the layer for speed's sake.
207 //
208 return ((UShort_t(layerId) << 11) | UShort_t(modId));
209}
210
211//_____________________________________________________________________________
212UShort_t AliGeomManager::LayerToVolUID(Int_t layerId, Int_t modId)
213{
214 // From detector (layer) name and module number (according to detector
215 // internal numbering) build the unique numerical identity of that volume
216 // inside ALICE
217 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
218 // remaining 11 for module ID inside det (2048 possible values).
219 // NO check for validity of given modId inside the layer for speed's sake.
220 //
221 return ((UShort_t(layerId) << 11) | UShort_t(modId));
222}
223
224//_____________________________________________________________________________
225UShort_t AliGeomManager::LayerToVolUIDSafe(ELayerID layerId, Int_t modId)
226{
227 // From detector (layer) name and module number (according to detector
228 // internal numbering) build the unique numerical identity of that volume
229 // inside ALICE
230 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
231 // remaining 11 for module ID inside det (2048 possible values).
232 // Check validity of given modId inside the layer.
233 //
234 if(modId < 0 || modId >= LayerSize(layerId)){
235 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
236 return 0;
237 }
238 return ((UShort_t(layerId) << 11) | UShort_t(modId));
239}
240
241//_____________________________________________________________________________
242UShort_t AliGeomManager::LayerToVolUIDSafe(Int_t layerId, Int_t modId)
243{
244 // From detector (layer) name and module number (according to detector
245 // internal numbering) build the unique numerical identity of that volume
246 // inside ALICE
247 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
248 // remaining 11 for module ID inside det (2048 possible values).
249 // Check validity of given modId inside the layer.
250 //
251 if(modId < 0 || modId >= LayerSize(layerId)){
252 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
253 return 0;
254 }
255 return ((UShort_t(layerId) << 11) | UShort_t(modId));
256}
257
258//_____________________________________________________________________________
259AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid, Int_t &modId)
260{
261 // From voluid, unique numerical identity of that volume inside ALICE,
262 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
263 // remaining 11 for module ID inside det (2048 possible values)), return
264 // the identity of the layer to which that volume belongs and sets the
265 // argument modId to the identity of that volume internally to the layer.
266 // NO check for validity of given voluid for speed's sake.
267 //
268 modId = voluid & 0x7ff;
269
270 return VolUIDToLayer(voluid);
271}
272
273//_____________________________________________________________________________
274AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid)
275{
276 // From voluid, unique numerical identity of that volume inside ALICE,
277 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
278 // remaining 11 for module ID inside det (2048 possible values)), return
279 // the identity of the layer to which that volume belongs
280 // NO check for validity of given voluid for speed's sake.
281 //
282 return ELayerID(voluid >> 11);
283}
284
285//_____________________________________________________________________________
286AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid, Int_t &modId)
287{
288 // From voluid, unique numerical identity of that volume inside ALICE,
289 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
290 // remaining 11 for module ID inside det (2048 possible values)), returns
291 // the identity of the layer to which that volume belongs and sets the
292 // argument modId to the identity of that volume internally to the layer.
293 // Checks the validity of the given voluid
294 //
295 ELayerID layId = VolUIDToLayerSafe(voluid);
296 if(layId){
297 Int_t mId = Int_t(voluid & 0x7ff);
298 if( mId>=0 && mId<LayerSize(layId)){
299 modId = mId;
300 return layId;
301 }
302 }
303
304 AliErrorClass(Form("Invalid unique volume id: %d !",voluid));
305 modId = -1;
306 return kInvalidLayer;
307
308}
309
310//_____________________________________________________________________________
311AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid)
312{
313 // From voluid, unique numerical identity of that volume inside ALICE,
314 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
315 // remaining 11 for module ID inside det (2048 possible values)), returns
316 // the identity of the layer to which that volume belongs
317 // Checks the validity of the given voluid
318 //
319 if( (voluid >> 11) < kLastLayer) return ELayerID(voluid >> 11);
320
321 AliErrorClass(Form("Invalid layer id: %d !",(voluid >> 11)));
322 return kInvalidLayer;
323
324}
325
326//_____________________________________________________________________________
327Bool_t AliGeomManager::GetFromGeometry(const char *symname, AliAlignObj &alobj)
328{
329 // Get the alignment object which corresponds to the symbolic volume name
330 // symname (in case equal to the TGeo volume path)
331 // The method is extremely slow due to the searching by string,
332 // therefore it should be used with great care!!
333 // This method returns FALSE if the symname of the object was not
334 // valid neither to get a TGeoPEntry nor as a volume path, or if the path
335 // associated to the TGeoPNEntry was not valid.
336 //
337
338 // Reset the alignment object
339 alobj.SetPars(0,0,0,0,0,0);
340 alobj.SetSymName(symname);
341
36b010bf 342 if (!fgGeometry || !fgGeometry->IsClosed()) {
67dd5535 343 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
344 return kFALSE;
345 }
346
36b010bf 347 if (!fgGeometry->GetListOfPhysicalNodes()) {
67dd5535 348 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
349 return kFALSE;
350 }
351
67dd5535 352 const char *path;
36b010bf 353 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 354 if(pne){
355 path = pne->GetTitle();
356 }else{
357 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
358 path = symname;
359 }
36b010bf 360 TObjArray* nodesArr = fgGeometry->GetListOfPhysicalNodes();
67dd5535 361 TGeoPhysicalNode* node = NULL;
362 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
363 TGeoPhysicalNode* tempNode = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
364 const char *nodePath = tempNode->GetName();
365 if (strcmp(path,nodePath) == 0) {
366 node = tempNode;
367 break;
368 }
369 }
370
371 if (!node) {
36b010bf 372 if (!fgGeometry->cd(path)) {
67dd5535 373 AliErrorClass(Form("%s not valid neither as symbolic volume name nor as volume path!",path));
374 return kFALSE;
375 }
376 else {
377 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
378 return kTRUE;
379 }
380 }
381
382 TGeoHMatrix align,gprime,g,ginv,l;
383 gprime = *node->GetMatrix();
384 l = *node->GetOriginalMatrix();
385 g = *node->GetMatrix(node->GetLevel()-1);
386 g *= l;
387 ginv = g.Inverse();
388 align = gprime * ginv;
389
390 return alobj.SetMatrix(align);
391}
392
393
394//_____________________________________________________________________________
395void AliGeomManager::InitAlignObjFromGeometry()
396{
5aedd709 397 // Loop over all alignable volumes and extract
398 // the corresponding alignment objects from
399 // the TGeo geometry
3564f2da 400 //
67dd5535 401 for (Int_t iLayer = kFirstLayer; iLayer < AliGeomManager::kLastLayer; iLayer++) {
3564f2da 402 if (!fgAlignObjs[iLayer-kFirstLayer]) {
403 fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[LayerSize(iLayer)];
3564f2da 404 }
67dd5535 405 for (Int_t iModule = 0; iModule < LayerSize(iLayer); iModule++) {
406 UShort_t volid = LayerToVolUID(iLayer,iModule);
ebb8460f 407 fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjParams("",volid,0,0,0,0,0,0,kTRUE);
67dd5535 408 const char *symname = SymName(volid);
409 if (!GetFromGeometry(symname, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
410 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,symname));
411 }
412 }
5aedd709 413
67dd5535 414}
415
416//_____________________________________________________________________________
5aedd709 417AliAlignObj* AliGeomManager::GetAlignObj(UShort_t voluid)
418{
67dd5535 419 // Returns the alignment object for given volume ID
420 //
421 Int_t modId;
422 ELayerID layerId = VolUIDToLayer(voluid,modId);
423 return GetAlignObj(layerId,modId);
424}
425
426//_____________________________________________________________________________
427AliAlignObj* AliGeomManager::GetAlignObj(ELayerID layerId, Int_t modId)
428{
429 // Returns pointer to alignment object given its layer and module ID
430 //
431 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
432 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
433 return NULL;
434 }
435 InitAlignObjFromGeometry();
436
437 return fgAlignObjs[layerId-kFirstLayer][modId];
438}
439
440//_____________________________________________________________________________
5aedd709 441const char* AliGeomManager::SymName(UShort_t voluid)
442{
67dd5535 443 // Returns the symbolic volume name for given volume ID
444 //
445 Int_t modId;
446 ELayerID layerId = VolUIDToLayer(voluid,modId);
447 return SymName(layerId,modId);
448}
449
450//_____________________________________________________________________________
451const char* AliGeomManager::SymName(ELayerID layerId, Int_t modId)
452{
453 // Returns the symbolic volume name given for a given layer
454 // and module ID
455 //
ff5970a3 456 if(!fgGeometry){
457 AliErrorClass("No geometry instance loaded yet!");
458 return NULL;
459 }
67dd5535 460 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
461 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
462 return NULL;
463 }
67dd5535 464
a8629c62 465 TGeoPNEntry* pne = fgPNEntry[layerId-kFirstLayer][modId];
466 if(!pne)
467 {
468 AliWarningClass(Form("Module %d of layer %s is not activated!",modId,LayerName(layerId)));
469 return NULL;
470 }
471 return pne->GetName();
472
67dd5535 473}
474
475//_____________________________________________________________________________
9257a1bd 476Bool_t AliGeomManager::CheckSymNamesLUT(const char* /*detsToBeChecked*/)
67dd5535 477{
0bf7aade 478 // Check the look-up table which associates the unique numerical identity of
479 // each alignable volume to the corresponding symbolic volume name.
480 // The LUT is now hold inside the geometry and handled by TGeo.
481 // The method is meant to be launched when loading a geometry to verify that
482 // no changes in the symbolic names have been introduced, which would prevent
483 // backward compatibility with alignment objects.
484 // To accept both complete and partial geometry, this method skips the check
485 // for TRD and TOF volumes which are missing in the partial geometry.
486 //
67dd5535 487
ff5970a3 488// TString detsString(detsToBeChecked);
489// if(detsString.Contains("ALL")) detsString="ITS TPC TOF TRD HMPID PHOS EMCAL";
490
491 // Temporary measure to face the case of reconstruction over detectors not present in the geometry
492 TString detsString = "";
493 if(fgGeometry->CheckPath("ALIC_1/ITSV_1")) detsString+="ITS ";
494 if(fgGeometry->CheckPath("ALIC_1/TPC_M_1")) detsString+="TPC ";
83364444 495
496 TString tofsm;
497 TString baseTof("ALIC_1/B077_1/BSEGMO");
498 TString middleTof("_1/BTOF");
499 TString trailTof("_1/FTOA_0");
500 Bool_t tofActive=kFALSE;
501 Bool_t tofSMs[18];
502 for(Int_t sm=0; sm<18; sm++)
503 {
504 tofSMs[sm]=kFALSE;
505 tofsm=baseTof;
506 tofsm += sm;
507 tofsm += middleTof;
508 tofsm += sm;
509 tofsm += trailTof;
510 if(fgGeometry->CheckPath(tofsm.Data()))
511 {
512 tofActive=kTRUE;
513 tofSMs[sm]=kTRUE;
514 }
515 }
516 if(tofActive) detsString+="TOF ";
517
518 TString trdsm;
519 TString baseTrd("ALIC_1/B077_1/BSEGMO");
520 TString middleTrd("_1/BTRD");
521 TString trailTrd("_1/UTR1_1");
522 Bool_t trdActive=kFALSE;
523 Bool_t trdSMs[18];
524 for(Int_t sm=0; sm<18; sm++)
525 {
526 trdSMs[sm]=kFALSE;
527 trdsm=baseTrd;
528 trdsm += sm;
529 trdsm += middleTrd;
530 trdsm += sm;
531 trdsm += trailTrd;
532 if(fgGeometry->CheckPath(trdsm.Data()))
533 {
534 trdActive=kTRUE;
535 trdSMs[sm]=kTRUE;
536 }
537 }
538 if(trdActive) detsString+="TRD ";
539
ff5970a3 540 if(fgGeometry->CheckPath("ALIC_1/Hmp0_0")) detsString+="HMPID ";
6ead0654 541
542 TString phosMod, cpvMod;
543 TString basePhos("ALIC_1/PHOS_");
544 Bool_t phosActive=kFALSE;
545 Bool_t cpvActive=kFALSE;
546 Bool_t phosMods[5];
547 for(Int_t pmod=0; pmod<5; pmod++)
548 {
549 phosMods[pmod]=kFALSE;
550 phosMod = basePhos;
551 phosMod += (pmod+1);
552 cpvMod = phosMod;
553 cpvMod += "/PCPV_1";
554 if(fgGeometry->CheckPath(phosMod.Data()))
555 {
556 phosActive=kTRUE;
557 phosMods[pmod]=kTRUE;
558 if(fgGeometry->CheckPath(cpvMod.Data())) cpvActive=kTRUE;
559 }
560 }
561 if(phosActive) detsString+="PHOS ";
562
ff5970a3 563 if(fgGeometry->CheckPath("ALIC_1/XEN1_1")) detsString+="EMCAL";
564
67dd5535 565 TString symname;
0bf7aade 566 const char* sname;
567 TGeoPNEntry* pne = 0x0;
568 Int_t uid; // global unique identity
569 Int_t modnum; // unique id inside layer; in the following, set it to 0 at the start of each layer
67dd5535 570
ff5970a3 571 if(detsString.Contains("ITS")){
67dd5535 572 /********************* ITS layers ***********************/
ff5970a3 573 AliDebugClass(2,"Checking consistency of symbolic names for ITS layers");
574 TString strSPD = "ITS/SPD";
575 TString strSDD = "ITS/SDD";
576 TString strSSD = "ITS/SSD";
577 TString strStave = "/Stave";
578 TString strHalfStave = "/HalfStave";
579 TString strLadder = "/Ladder";
580 TString strSector = "/Sector";
581 TString strSensor = "/Sensor";
582 TString strEntryName1;
583 TString strEntryName2;
584 TString strEntryName3;
585
586 /********************* SPD layer1 ***********************/
587 {
588 modnum = 0;
589
590 for(Int_t cSect = 0; cSect<10; cSect++){
591 strEntryName1 = strSPD;
592 strEntryName1 += 0;
593 strEntryName1 += strSector;
594 strEntryName1 += cSect;
595
596 for(Int_t cStave =0; cStave<2; cStave++){
597 strEntryName2 = strEntryName1;
598 strEntryName2 += strStave;
599 strEntryName2 += cStave;
600
601 for (Int_t cHS=0; cHS<2; cHS++) {
602 strEntryName3 = strEntryName2;
603 strEntryName3 += strHalfStave;
604 strEntryName3 += cHS;
605
606 for(Int_t cLad =0; cLad<2; cLad++){
607 symname = strEntryName3;
608 symname += strLadder;
609 symname += cLad+cHS*2;
610 uid = LayerToVolUID(kSPD1,modnum++);
611 pne = fgGeometry->GetAlignableEntryByUID(uid);
612 if(!pne)
613 {
614 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
615 return kFALSE;
616 }
617 sname = pne->GetName();
618 if(symname.CompareTo(sname))
619 {
620 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
621 "Expected was %s, found was %s!", uid, symname.Data(), sname));
622 return kFALSE;
623 }
0bf7aade 624 }
8f8273a4 625 }
67dd5535 626 }
627 }
628 }
ff5970a3 629
630 /********************* SPD layer2 ***********************/
631 {
632 modnum = 0;
633
634 for(Int_t cSect = 0; cSect<10; cSect++){
635 strEntryName1 = strSPD;
636 strEntryName1 += 1;
637 strEntryName1 += strSector;
638 strEntryName1 += cSect;
639
640 for(Int_t cStave =0; cStave<4; cStave++){
641 strEntryName2 = strEntryName1;
642 strEntryName2 += strStave;
643 strEntryName2 += cStave;
644
645 for (Int_t cHS=0; cHS<2; cHS++) {
646 strEntryName3 = strEntryName2;
647 strEntryName3 += strHalfStave;
648 strEntryName3 += cHS;
649
650 for(Int_t cLad =0; cLad<2; cLad++){
651 symname = strEntryName3;
652 symname += strLadder;
653 symname += cLad+cHS*2;
654 uid = LayerToVolUID(kSPD2,modnum++);
655 pne = fgGeometry->GetAlignableEntryByUID(uid);
656 if(!pne)
657 {
658 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
659 return kFALSE;
660 }
661 sname = pne->GetName();
662 if(symname.CompareTo(sname))
663 {
664 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
665 "Expected was %s, found was %s!", uid, symname.Data(), sname));
666 return kFALSE;
667 }
0bf7aade 668 }
8f8273a4 669 }
67dd5535 670 }
671 }
672 }
ff5970a3 673
674 /********************* SDD layer1 ***********************/
675 {
676 modnum=0;
677
678 for(Int_t c1 = 1; c1<=14; c1++){
679 strEntryName1 = strSDD;
680 strEntryName1 += 2;
681 strEntryName1 +=strLadder;
682 strEntryName1 += (c1-1);
683 for(Int_t c2 =1; c2<=6; c2++){
684 symname = strEntryName1;
685 symname += strSensor;
686 symname += (c2-1);
687 uid = LayerToVolUID(kSDD1,modnum++);
688 pne = fgGeometry->GetAlignableEntryByUID(uid);
689 if(!pne)
690 {
691 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
692 return kFALSE;
693 }
694 sname = pne->GetName();
695 if(symname.CompareTo(sname))
696 {
697 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
698 "Expected was %s, found was %s!", uid, symname.Data(), sname));
699 return kFALSE;
700 }
701 }
702 }
703 }
704
705 /********************* SDD layer2 ***********************/
706 {
707 modnum=0;
708
709 for(Int_t c1 = 1; c1<=22; c1++){
710 strEntryName1 = strSDD;
711 strEntryName1 += 3;
712 strEntryName1 +=strLadder;
713 strEntryName1 += (c1-1);
714 for(Int_t c2 = 1; c2<=8; c2++){
715 symname = strEntryName1;
716 symname += strSensor;
717 symname += (c2-1);
718 uid = LayerToVolUID(kSDD2,modnum++);
719 pne = fgGeometry->GetAlignableEntryByUID(uid);
720 if(!pne)
721 {
722 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
723 return kFALSE;
724 }
725 sname = pne->GetName();
726 if(symname.CompareTo(sname))
727 {
728 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
729 "Expected was %s, found was %s!", uid, symname.Data(), sname));
730 return kFALSE;
731 }
732 }
733 }
734 }
735
736 /********************* SSD layer1 ***********************/
737 {
738 modnum=0;
739
740 for(Int_t c1 = 1; c1<=34; c1++){
741 strEntryName1 = strSSD;
742 strEntryName1 += 4;
743 strEntryName1 +=strLadder;
744 strEntryName1 += (c1-1);
745 for(Int_t c2 = 1; c2<=22; c2++){
746 symname = strEntryName1;
747 symname += strSensor;
748 symname += (c2-1);
749 uid = LayerToVolUID(kSSD1,modnum++);
750 pne = fgGeometry->GetAlignableEntryByUID(uid);
751 if(!pne)
752 {
753 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
754 return kFALSE;
755 }
756 sname = pne->GetName();
757 if(symname.CompareTo(sname))
758 {
759 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
760 "Expected was %s, found was %s!", uid, symname.Data(), sname));
761 return kFALSE;
762 }
763 }
764 }
765 }
766
767 /********************* SSD layer2 ***********************/
768 {
769 modnum=0;
770
771 for(Int_t c1 = 1; c1<=38; c1++){
772 strEntryName1 = strSSD;
773 strEntryName1 += 5;
774 strEntryName1 +=strLadder;
775 strEntryName1 += (c1-1);
776 for(Int_t c2 = 1; c2<=25; c2++){
777 symname = strEntryName1;
778 symname += strSensor;
779 symname += (c2-1);
780 uid = LayerToVolUID(kSSD2,modnum++);
781 pne = fgGeometry->GetAlignableEntryByUID(uid);
782 if(!pne)
783 {
784 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
785 return kFALSE;
786 }
787 sname = pne->GetName();
788 if(symname.CompareTo(sname))
789 {
790 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
791 "Expected was %s, found was %s!", uid, symname.Data(), sname));
792 return kFALSE;
793 }
794 }
795 }
796 }
797
798 AliDebugClass(2,"Consistency check for ITS symbolic names finished successfully.");
67dd5535 799 }
800
ff5970a3 801 if(detsString.Contains("TPC"))
67dd5535 802 {
ff5970a3 803 /*************** TPC inner and outer layers ****************/
804
805 AliDebugClass(2,"Checking consistency of symbolic names for TPC layers");
806 TString sAsector="TPC/EndcapA/Sector";
807 TString sCsector="TPC/EndcapC/Sector";
808 TString sInner="/InnerChamber";
809 TString sOuter="/OuterChamber";
810
811 /*************** TPC inner chambers' layer ****************/
812 {
813 modnum = 0;
67dd5535 814
ff5970a3 815 for(Int_t cnt=1; cnt<=18; cnt++)
816 {
817 symname = sAsector;
818 symname += cnt;
819 symname += sInner;
820 uid = LayerToVolUID(kTPC1,modnum++);
0bf7aade 821 pne = fgGeometry->GetAlignableEntryByUID(uid);
822 if(!pne)
823 {
824 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
825 return kFALSE;
826 }
827 sname = pne->GetName();
828 if(symname.CompareTo(sname))
829 {
830 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
831 "Expected was %s, found was %s!", uid, symname.Data(), sname));
832 return kFALSE;
833 }
67dd5535 834 }
67dd5535 835
ff5970a3 836 for(Int_t cnt=1; cnt<=18; cnt++)
837 {
838 symname = sCsector;
839 symname += cnt;
840 symname += sInner;
841 uid = LayerToVolUID(kTPC1,modnum++);
0bf7aade 842 pne = fgGeometry->GetAlignableEntryByUID(uid);
843 if(!pne)
844 {
845 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
846 return kFALSE;
847 }
848 sname = pne->GetName();
849 if(symname.CompareTo(sname))
850 {
851 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
852 "Expected was %s, found was %s!", uid, symname.Data(), sname));
853 return kFALSE;
854 }
67dd5535 855 }
856 }
67dd5535 857
ff5970a3 858 /*************** TPC outer chambers' layer ****************/
859 {
860 modnum = 0;
67dd5535 861
ff5970a3 862 for(Int_t cnt=1; cnt<=18; cnt++)
863 {
864 symname = sAsector;
865 symname += cnt;
866 symname += sOuter;
867 uid = LayerToVolUID(kTPC2,modnum++);
0bf7aade 868 pne = fgGeometry->GetAlignableEntryByUID(uid);
869 if(!pne)
870 {
871 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
872 return kFALSE;
873 }
874 sname = pne->GetName();
875 if(symname.CompareTo(sname))
876 {
877 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
878 "Expected was %s, found was %s!", uid, symname.Data(), sname));
879 return kFALSE;
880 }
67dd5535 881 }
67dd5535 882
ff5970a3 883 for(Int_t cnt=1; cnt<=18; cnt++)
884 {
885 symname = sCsector;
886 symname += cnt;
887 symname += sOuter;
888 uid = LayerToVolUID(kTPC2,modnum++);
0bf7aade 889 pne = fgGeometry->GetAlignableEntryByUID(uid);
890 if(!pne)
891 {
892 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
893 return kFALSE;
894 }
895 sname = pne->GetName();
896 if(symname.CompareTo(sname))
897 {
898 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
899 "Expected was %s, found was %s!", uid, symname.Data(), sname));
900 return kFALSE;
901 }
67dd5535 902 }
903 }
67dd5535 904
ff5970a3 905 AliDebugClass(2,"Consistency check for TPC symbolic names finished successfully.");
67dd5535 906 }
907
ff5970a3 908 if(detsString.Contains("TOF"))
67dd5535 909 {
ff5970a3 910 /********************* TOF layer ***********************/
67dd5535 911
ff5970a3 912 AliDebugClass(2,"Checking consistency of symbolic names for TOF layers");
67dd5535 913 modnum=0;
ff5970a3 914
67dd5535 915 Int_t nstrA=15;
916 Int_t nstrB=19;
917 Int_t nstrC=19;
918 Int_t nSectors=18;
919 Int_t nStrips=nstrA+2*nstrB+2*nstrC;
0bf7aade 920
67dd5535 921 TString snSM = "TOF/sm";
922 TString snSTRIP = "/strip";
923
924 for (Int_t isect = 0; isect < nSectors; isect++) {
925 for (Int_t istr = 1; istr <= nStrips; istr++) {
926 symname = snSM;
927 symname += Form("%02d",isect);
928 symname += snSTRIP;
929 symname += Form("%02d",istr);
0bf7aade 930 uid = LayerToVolUID(kTOF,modnum++);
83364444 931 if(!tofSMs[isect]) continue; // taking possible missing TOF sectors (partial geometry) into account
932 AliDebugClass(2,Form("Consistency check for symnames of TOF supermodule %d.",isect));
0bf7aade 933 if ((isect==13 || isect==14 || isect==15) && (istr >= 39 && istr <= 53)) continue; //taking holes into account
934 pne = fgGeometry->GetAlignableEntryByUID(uid);
935 if(!pne)
936 {
937 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
938 return kFALSE;
939 }
940 sname = pne->GetName();
941 if(symname.CompareTo(sname))
942 {
943 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
944 "Expected was %s, found was %s!", uid, symname.Data(), sname));
945 return kFALSE;
946 }
67dd5535 947 }
948 }
ff5970a3 949
950 AliDebugClass(2,"Consistency check for TOF symbolic names finished successfully.");
67dd5535 951 }
952
ff5970a3 953 if(detsString.Contains("HMPID"))
67dd5535 954 {
ff5970a3 955 /********************* HMPID layer ***********************/
956
957 AliDebugClass(2,"Checking consistency of symbolic names for HMPID layers");
67dd5535 958 TString str = "/HMPID/Chamber";
959
960 for (modnum=0; modnum < 7; modnum++) {
961 symname = str;
962 symname += modnum;
0bf7aade 963 uid = LayerToVolUID(kHMPID,modnum);
964 pne = fgGeometry->GetAlignableEntryByUID(uid);
965 if(!pne)
966 {
967 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
968 return kFALSE;
969 }
970 sname = pne->GetName();
971 if(symname.CompareTo(sname))
972 {
973 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
974 "Expected was %s, found was %s!", uid, symname.Data(), sname));
975 return kFALSE;
976 }
67dd5535 977 }
ff5970a3 978
979 AliDebugClass(2,"Consistency check for HMPID symbolic names finished successfully.");
67dd5535 980 }
981
ff5970a3 982 if(detsString.Contains("TRD"))
67dd5535 983 {
ff5970a3 984 /********************* TRD layers 1-6 *******************/
985 //!! 6 layers with index increasing in outwards direction
986
987 AliDebugClass(2,"Checking consistency of symbolic names for TRD layers");
67dd5535 988 Int_t arTRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
989
990 TString snStr = "TRD/sm";
991 TString snApp1 = "/st";
992 TString snApp2 = "/pl";
993
994 for(Int_t layer=0; layer<6; layer++){
995 modnum=0;
996 for (Int_t isect = 0; isect < 18; isect++) {
997 for (Int_t icham = 0; icham < 5; icham++) {
998 symname = snStr;
999 symname += Form("%02d",isect);
1000 symname += snApp1;
1001 symname += icham;
1002 symname += snApp2;
1003 symname += layer;
0bf7aade 1004 uid = LayerToVolUID(arTRDlayId[layer],modnum++);
83364444 1005 if(!trdSMs[isect]) continue;
1006 AliDebugClass(2,Form("Consistency check for symnames of TRD supermodule %d.",isect));
0bf7aade 1007 if ((isect==13 || isect==14 || isect==15) && icham==2) continue; //keeping holes into account
1008 pne = fgGeometry->GetAlignableEntryByUID(uid);
1009 if(!pne)
1010 {
1011 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1012 return kFALSE;
1013 }
1014 sname = pne->GetName();
1015 if(symname.CompareTo(sname))
1016 {
1017 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1018 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1019 return kFALSE;
1020 }
67dd5535 1021 }
1022 }
1023 }
ff5970a3 1024
1025 AliDebugClass(2,"Consistency check for TRD symbolic names finished successfully.");
67dd5535 1026 }
df117114 1027
ff5970a3 1028 if(detsString.Contains("PHOS"))
df117114 1029 {
ff5970a3 1030 /********************* PHOS EMC layer ***********************/
df117114 1031
ff5970a3 1032 AliDebugClass(2,"Checking consistency of symbolic names for PHOS layers");
1033
ff5970a3 1034 TString str = "PHOS/Module";
1035 modnum=0;
1036
6ead0654 1037 for (Int_t iModule=0; iModule < 5; iModule++) {
1038 if(!phosMods[iModule]) continue;
ff5970a3 1039 symname = str;
6ead0654 1040 symname += (iModule+1);
1041 uid = LayerToVolUID(kPHOS1,iModule);
ff5970a3 1042 pne = fgGeometry->GetAlignableEntryByUID(uid);
1043 if(!pne)
1044 {
1045 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1046 return kFALSE;
1047 }
1048 sname = pne->GetName();
1049 if(symname.CompareTo(sname))
1050 {
1051 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1052 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1053 return kFALSE;
1054 }
6ead0654 1055 /********************* PHOS CPV layer ***********************/
1056 if(!cpvActive) continue;
ff5970a3 1057 symname += "/CPV";
6ead0654 1058 uid = LayerToVolUID(kPHOS2,iModule);
ff5970a3 1059 pne = fgGeometry->GetAlignableEntryByUID(uid);
1060 if(!pne)
1061 {
1062 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1063 return kFALSE;
1064 }
1065 sname = pne->GetName();
1066 if(symname.CompareTo(sname))
1067 {
1068 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1069 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1070 return kFALSE;
1071 }
0bf7aade 1072 }
ff5970a3 1073 AliDebugClass(2,"Consistency check for PHOS symbolic names finished successfully.");
f47b9233 1074 }
1075
ff5970a3 1076 if(detsString.Contains("EMCAL"))
3dfc15c0 1077 {
ff5970a3 1078 /********************* EMCAL layer ***********************/
1079
1080 AliDebugClass(2,"Checking consistency of symbolic names for EMCAL layers");
3dfc15c0 1081 TString str = "EMCAL/FullSupermodule";
1082 modnum=0;
1083
1084 for (Int_t iModule=1; iModule <= 12; iModule++) {
1085 symname = str;
1086 symname += iModule;
1087 if(iModule >10) {
1088 symname = "EMCAL/HalfSupermodule";
1089 symname += iModule-10;
1090 }
1091 modnum = iModule-1;
0bf7aade 1092 uid = LayerToVolUID(kEMCAL,modnum);
1093 pne = fgGeometry->GetAlignableEntryByUID(uid);
1094 if(!pne)
1095 {
1096 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1097 return kFALSE;
1098 }
1099 sname = pne->GetName();
1100 if(symname.CompareTo(sname))
1101 {
1102 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1103 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1104 return kFALSE;
1105 }
3dfc15c0 1106 }
ff5970a3 1107
1108 AliDebugClass(2,"Consistency check for EMCAL symbolic names finished successfully.");
3dfc15c0 1109 }
0bf7aade 1110
1111 return kTRUE;
f47b9233 1112
67dd5535 1113}
1114
1115//_____________________________________________________________________________
1116void AliGeomManager::InitPNEntriesLUT()
1117{
1118 // Initialize the look-up table which associates the unique
1119 // numerical identity of each alignable volume to the
1120 // corresponding TGeoPNEntry.
1121 // The LUTs are static; they are created at the creation of the
1122 // AliGeomManager instance and recreated if the geometry has changed
1123 //
36b010bf 1124 if(!fgGeometry) {
1125 AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
1126 return;
1127 }
25fad4e5 1128
67dd5535 1129 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
3564f2da 1130 if (!fgPNEntry[iLayer]) fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
36b010bf 1131 for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
0bf7aade 1132 fgPNEntry[iLayer][modnum] = fgGeometry->GetAlignableEntryByUID(LayerToVolUID(iLayer+1,modnum));
36b010bf 1133 }
1134 }
1135}
1136
67dd5535 1137//______________________________________________________________________
53dd673d 1138TGeoHMatrix* AliGeomManager::GetMatrix(TGeoPNEntry * const pne)
67dd5535 1139{
5aedd709 1140 // Get the global transformation matrix for a given PNEntry
67dd5535 1141 // by quering the TGeoManager
1142
36b010bf 1143 if (!fgGeometry || !fgGeometry->IsClosed()) {
25fad4e5 1144 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1145 return NULL;
1146 }
5aedd709 1147
67dd5535 1148 TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
1149 if (pnode) return pnode->GetMatrix();
1150
1151 const char* path = pne->GetTitle();
36b010bf 1152 if (!fgGeometry->cd(path)) {
67dd5535 1153 AliErrorClass(Form("Volume path %s not valid!",path));
1154 return NULL;
1155 }
36b010bf 1156 return fgGeometry->GetCurrentMatrix();
67dd5535 1157}
1158
1159//______________________________________________________________________
1160TGeoHMatrix* AliGeomManager::GetMatrix(Int_t index)
1161{
1162 // Get the global transformation matrix for a given alignable volume
1163 // identified by its unique ID 'index' by quering the TGeoManager
1164
67dd5535 1165 TGeoPNEntry *pne = GetPNEntry(index);
1166 if (!pne) return NULL;
1167
1168 return GetMatrix(pne);
1169}
1170
1171//______________________________________________________________________
1172TGeoHMatrix* AliGeomManager::GetMatrix(const char* symname)
1173{
1174 // Get the global transformation matrix for a given alignable volume
1175 // identified by its symbolic name 'symname' by quering the TGeoManager
1176
36b010bf 1177 if (!fgGeometry || !fgGeometry->IsClosed()) {
1178 AliErrorClass("No active geometry or geometry not yet closed!");
1179 return NULL;
1180 }
1181
1182 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 1183 if (!pne) return NULL;
1184
1185 return GetMatrix(pne);
1186}
1187
1188//______________________________________________________________________
1189Bool_t AliGeomManager::GetTranslation(Int_t index, Double_t t[3])
1190{
1191 // Get the translation vector for a given module 'index'
1192 // by quering the TGeoManager
1193
1194 TGeoHMatrix *m = GetMatrix(index);
1195 if (!m) return kFALSE;
1196
1197 Double_t *trans = m->GetTranslation();
1198 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1199
1200 return kTRUE;
1201}
1202
1203//______________________________________________________________________
1204Bool_t AliGeomManager::GetRotation(Int_t index, Double_t r[9])
1205{
1206 // Get the rotation matrix for a given module 'index'
1207 // by quering the TGeoManager
1208
1209 TGeoHMatrix *m = GetMatrix(index);
1210 if (!m) return kFALSE;
1211
1212 Double_t *rot = m->GetRotationMatrix();
1213 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1214
1215 return kTRUE;
1216}
1217
5d534fe3 1218//_____________________________________________________________________________
1219Bool_t AliGeomManager::GetDeltaForBranch(Int_t index, TGeoHMatrix &inclusiveD)
1220{
1221 // The method sets the matrix passed as argument as the global delta
1222 // (for the volume referred by the unique index) including the displacements
1223 // of all parent volumes in the branch.
1224 //
5d534fe3 1225
1226 TGeoHMatrix go,invgo;
1227 go = *GetOrigGlobalMatrix(index);
1228 invgo = go.Inverse();
5aedd709 1229 inclusiveD = *GetMatrix(index);
5d534fe3 1230 inclusiveD.Multiply(&invgo);
1231
1232 return kTRUE;
1233}
1234
1235//_____________________________________________________________________________
1236Bool_t AliGeomManager::GetDeltaForBranch(AliAlignObj& aao, TGeoHMatrix &inclusiveD)
1237{
1238 // The method sets the matrix passed as argument as the global delta
1239 // (for the volume referred by the alignment object) including the displacements
1240 // of all parent volumes in the brach.
1241 //
1242 Int_t index = aao.GetVolUID();
1243 if(!index){
1244 AliErrorClass("Either the alignment object or its index are not valid");
1245 return kFALSE;
1246 }
1247 return GetDeltaForBranch(index, inclusiveD);
1248}
1249
36b010bf 1250//______________________________________________________________________
1251Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, TGeoHMatrix &m)
67dd5535 1252{
36b010bf 1253 // Get the global transformation matrix (ideal geometry) for a given alignable volume
0bf7aade 1254 // The alignable volume is identified by 'symname' which has to be either a valid symbolic
1255 // name, the query being performed after alignment, or a valid volume path if the query is
1256 // performed before alignment.
1257 //
36b010bf 1258 m.Clear();
67dd5535 1259
36b010bf 1260 if (!fgGeometry || !fgGeometry->IsClosed()) {
1261 AliErrorClass("No active geometry or geometry not yet closed!");
67dd5535 1262 return kFALSE;
1263 }
36b010bf 1264 if (!fgGeometry->GetListOfPhysicalNodes()) {
67dd5535 1265 AliWarningClass("gGeoManager doesn't contain any aligned nodes!");
36b010bf 1266 if (!fgGeometry->cd(symname)) {
67dd5535 1267 AliErrorClass(Form("Volume path %s not valid!",symname));
1268 return kFALSE;
1269 }
1270 else {
36b010bf 1271 m = *fgGeometry->GetCurrentMatrix();
67dd5535 1272 return kTRUE;
1273 }
1274 }
1275
36b010bf 1276 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 1277 const char* path = NULL;
67dd5535 1278 if(pne){
0bf7aade 1279 m = *pne->GetGlobalOrig();
1280 return kTRUE;
67dd5535 1281 }else{
1282 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
1283 path=symname;
1284 }
1285
36b010bf 1286 return GetOrigGlobalMatrixFromPath(path,m);
1287}
1288
1289//_____________________________________________________________________________
1290Bool_t AliGeomManager::GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m)
1291{
5aedd709 1292 // The method returns the global matrix for the volume identified by
1293 // 'path' in the ideal detector geometry.
1294 // The output global matrix is stored in 'm'.
1295 // Returns kFALSE in case TGeo has not been initialized or the volume
1296 // path is not valid.
36b010bf 1297 //
1298 m.Clear();
1299
1300 if (!fgGeometry || !fgGeometry->IsClosed()) {
1301 AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
67dd5535 1302 return kFALSE;
1303 }
1304
36b010bf 1305 if (!fgGeometry->CheckPath(path)) {
1306 AliErrorClass(Form("Volume path %s not valid!",path));
1307 return kFALSE;
1308 }
67dd5535 1309
36b010bf 1310 TIter next(fgGeometry->GetListOfPhysicalNodes());
1311 fgGeometry->cd(path);
67dd5535 1312
36b010bf 1313 while(fgGeometry->GetLevel()){
67dd5535 1314
1315 TGeoPhysicalNode *physNode = NULL;
1316 next.Reset();
36b010bf 1317 TGeoNode *node = fgGeometry->GetCurrentNode();
67dd5535 1318 while ((physNode=(TGeoPhysicalNode*)next()))
1319 if (physNode->GetNode() == node) break;
1320
1321 TGeoMatrix *lm = NULL;
1322 if (physNode) {
5aedd709 1323 lm = physNode->GetOriginalMatrix();
1324 if (!lm) lm = node->GetMatrix();
67dd5535 1325 } else
1326 lm = node->GetMatrix();
1327
1328 m.MultiplyLeft(lm);
1329
36b010bf 1330 fgGeometry->CdUp();
67dd5535 1331 }
1332
1333 return kTRUE;
1334}
1335
36b010bf 1336//_____________________________________________________________________________
53dd673d 1337TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(TGeoPNEntry * const pne)
36b010bf 1338{
1339 // The method returns global matrix for the ideal detector geometry
1340 // using the corresponding TGeoPNEntry as an input.
5aedd709 1341 // The returned pointer should be copied by the user, since its content could
1342 // be overwritten by a following call to the method.
1343 // In case of missing TGeoManager the method returns NULL.
1344 //
36b010bf 1345 if (!fgGeometry || !fgGeometry->IsClosed()) {
1346 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1347 return NULL;
1348 }
1349
0bf7aade 1350 return pne->GetGlobalOrig();
36b010bf 1351}
1352
67dd5535 1353//______________________________________________________________________
36b010bf 1354TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(Int_t index)
67dd5535 1355{
5aedd709 1356 // The method returns global matrix from the ideal detector geometry
1357 // for the volume identified by its index.
1358 // The returned pointer should be copied by the user, since its content could
1359 // be overwritten by a following call to the method.
1360 // In case of missing TGeoManager the method returns NULL.
1361 // If possible, the method uses the LUT of original ideal matrices
1362 // for fast access. The LUT is reset in case a
36b010bf 1363 // new geometry is loaded.
5aedd709 1364 //
0bf7aade 1365 TGeoPNEntry* pne = GetPNEntry(index);
1366 return pne->GetGlobalOrig();
67dd5535 1367}
1368
1369//______________________________________________________________________
1370Bool_t AliGeomManager::GetOrigTranslation(Int_t index, Double_t t[3])
1371{
1372 // Get the original translation vector (ideal geometry)
1373 // for a given module 'index' by quering the TGeoManager
1374
36b010bf 1375 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1376 if (!m) return kFALSE;
67dd5535 1377
36b010bf 1378 Double_t *trans = m->GetTranslation();
67dd5535 1379 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1380
1381 return kTRUE;
1382}
1383
1384//______________________________________________________________________
1385Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
1386{
1387 // Get the original rotation matrix (ideal geometry)
1388 // for a given module 'index' by quering the TGeoManager
1389
36b010bf 1390 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1391 if (!m) return kFALSE;
67dd5535 1392
36b010bf 1393 Double_t *rot = m->GetRotationMatrix();
67dd5535 1394 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1395
1396 return kTRUE;
1397}
1398
1399//______________________________________________________________________
1400const TGeoHMatrix* AliGeomManager::GetTracking2LocalMatrix(Int_t index)
1401{
25fad4e5 1402 // Get the matrix which transforms from the tracking to the local RS
67dd5535 1403 // The method queries directly the TGeoPNEntry
1404
67dd5535 1405 TGeoPNEntry *pne = GetPNEntry(index);
1406 if (!pne) return NULL;
1407
1408 const TGeoHMatrix *m = pne->GetMatrix();
1409 if (!m)
5aedd709 1410 AliErrorClass(Form("TGeoPNEntry (%s) contains no tracking-to-local matrix !",pne->GetName()));
67dd5535 1411
1412 return m;
1413}
1414
1415//______________________________________________________________________
1416Bool_t AliGeomManager::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
1417{
1418 // Get the matrix which transforms from the tracking r.s. to
1419 // the global one.
1420 // Returns kFALSE in case of error.
1421
1422 m.Clear();
1423
1424 TGeoHMatrix *m1 = GetMatrix(index);
1425 if (!m1) return kFALSE;
1426
1427 const TGeoHMatrix *m2 = GetTracking2LocalMatrix(index);
1428 if (!m2) return kFALSE;
1429
1430 m = *m1;
1431 m.Multiply(m2);
1432
1433 return kTRUE;
1434}
1435
1436//_____________________________________________________________________________
1437TGeoPNEntry* AliGeomManager::GetPNEntry(Int_t voluid) {
1438 // Returns the TGeoPNEntry for the given global volume ID "voluid"
1439 //
1440 Int_t modId;
1441 ELayerID layerId = VolUIDToLayer(voluid,modId);
1442 return GetPNEntry(layerId,modId);
1443}
1444
1445//_____________________________________________________________________________
67dd5535 1446TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
1447{
1448 // Returns the TGeoPNEntry for a given layer
1449 // and module ID
1450 //
25fad4e5 1451
67dd5535 1452 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
1453 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
1454 return NULL;
1455 }
1456
1457 return fgPNEntry[layerId-kFirstLayer][modId];
1458}
1459
1460//_____________________________________________________________________________
5590c6c3 1461void AliGeomManager::CheckOverlapsOverPNs(Double_t threshold)
1462{
1463 // Check for overlaps/extrusions on physical nodes only;
1464 // this overlap-checker is meant to be used to check overlaps/extrusions
1465 // originated by the application of alignment objects.
1466 //
1467
1468 TObjArray* ovexlist = new TObjArray(64);
1469
1470 AliInfoClass("********* Checking overlaps/extrusions over physical nodes only *********");
1471 TObjArray* pnList = gGeoManager->GetListOfPhysicalNodes();
0cd61c1d 1472 TGeoVolume* mvol = 0;
5590c6c3 1473 TGeoPhysicalNode* pn;
1474 TObjArray* overlaps = new TObjArray(64);
1475 overlaps->SetOwner();
1476
1477 TStopwatch timer2;
1478 timer2.Start();
1479 for(Int_t pni=0; pni<pnList->GetEntriesFast(); pni++){
1480 pn = (TGeoPhysicalNode*) pnList->UncheckedAt(pni);
1481 // checking the volume of the mother (go upper in the tree in case it is an assembly)
1482 Int_t levup=1;
1483 while(((TGeoVolume*)pn->GetVolume(pn->GetLevel()-levup))->IsAssembly()) levup++;
1484 //Printf("Going to upper level");
1485 mvol = pn->GetVolume(pn->GetLevel()-levup);
1486 if(!mvol->IsSelected()){
1487 AliInfoClass(Form("Checking overlaps for volume %s",mvol->GetName()));
1488 mvol->CheckOverlaps(threshold);
1489 ovexlist = gGeoManager->GetListOfOverlaps();
1490 TIter next(ovexlist);
1491 TGeoOverlap *ov;
1492 while ((ov=(TGeoOverlap*)next())) overlaps->Add(ov->Clone());
1493 mvol->SelectVolume();
1494 }
1495 }
1496 mvol->SelectVolume(kTRUE); // clears the list of selected volumes
1497
1498 AliInfoClass(Form("Number of overlapping/extruding PNs: %d",overlaps->GetEntriesFast()));
1499 timer2.Stop();
1500 timer2.Print();
1501
1502 TIter nextN(overlaps);
1503 TGeoOverlap *ovlp;
1504 while ((ovlp=(TGeoOverlap*)nextN())) ovlp->PrintInfo();
1505
1506 overlaps->Delete();
1507 delete overlaps;
1508}
1509
1510//_____________________________________________________________________________
4fbb8e9d 1511Int_t AliGeomManager::GetNalignable(const char* module)
8cb26cdf 1512{
4fbb8e9d 1513 // Get number of declared alignable volumes for given detector in current geometry
8cb26cdf 1514 //
1515
4fbb8e9d 1516 // return the detector index corresponding to detector
1517 Int_t index = -1 ;
1518 for (index = 0; index < fgkNDetectors ; index++) {
1519 if ( strcmp(module, fgkDetectorName[index]) == 0 )
1520 break ;
1521 }
1522 return fgNalignable[index];
8cb26cdf 1523}
4fbb8e9d 1524
1525//_____________________________________________________________________________
1526void AliGeomManager::InitNalignable()
1527{
1528 // Set number of declared alignable volumes for given detector in current geometry
1529 // by looping on the list of PNEntries
1530 //
1531
1532 Int_t nAlE = gGeoManager->GetNAlignable(); // total number of alignable entries
1533 TGeoPNEntry *pne = 0;
4fbb8e9d 1534 const char* detName;
1535
1536 for (Int_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1537 detName = fgkDetectorName[iDet];
1538 Int_t nAlDet = 0;
1539
1540 for(Int_t iE = 0; iE < nAlE; iE++)
1541 {
1542 pne = gGeoManager->GetAlignableEntry(iE);
3564f2da 1543 TString pneName = pne->GetName();
1544 if(pneName.Contains(detName)) nAlDet++;
1545 if(!strcmp(detName,"GRP")) if(pneName.Contains("ABSO") || pneName.Contains("DIPO") ||
1546 pneName.Contains("FRAME") || pneName.Contains("PIPE") ||
1547 pneName.Contains("SHIL")) nAlDet++;
4fbb8e9d 1548 }
1549 fgNalignable[iDet] = nAlDet;
1550 }
8cb26cdf 1551
4fbb8e9d 1552}
1553
8cb26cdf 1554//_____________________________________________________________________________
67dd5535 1555Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
1556{
1557 // Calls AddAlignObjsFromCDBSingleDet for the detectors appearing in
1558 // the list passed as argument (called by AliSimulation and
1559 // AliReconstruction)
1560 // Read the alignment objects from CDB.
1561 // Each detector is supposed to have the
1562 // alignment objects in DET/Align/Data CDB path.
1563 // All the detector objects are then collected,
1564 // sorted by geometry level (starting from ALIC) and
1565 // then applied to the TGeo geometry.
1566 // Finally an overlaps check is performed.
1567 //
1568
36b010bf 1569 TObjArray alignObjArray;
1570 alignObjArray.Clear();
1571 alignObjArray.SetOwner(0);
67dd5535 1572
1573 TString alObjsNotLoaded="";
1574 TString alObjsLoaded="";
1575
1576 TString AlignDetsString(AlignDetsList);
1577 TObjArray *detsarr = AlignDetsString.Tokenize(' ');
1578 TIter iter(detsarr);
1579 TObjString *str = 0;
1580
1581 while((str = (TObjString*) iter.Next())){
1582 TString det(str->String());
2912a163 1583 AliDebugClass(5,Form("Loading alignment objs for %s",det.Data()));
36b010bf 1584 if(!LoadAlignObjsFromCDBSingleDet(det.Data(),alignObjArray)){
67dd5535 1585 alObjsNotLoaded += det.Data();
1586 alObjsNotLoaded += " ";
1587 } else {
1588 alObjsLoaded += det.Data();
1589 alObjsLoaded += " ";
1590 }
1591 }
b80b98e1 1592 detsarr->Delete();
1593 delete detsarr;
67dd5535 1594
36b010bf 1595 if(!alObjsLoaded.IsNull()) AliInfoClass(Form("Alignment objects loaded for: %s",
1596 alObjsLoaded.Data()));
451cbb1d 1597 if(!alObjsNotLoaded.IsNull())
1598 AliFatalClass(Form("Could not load alignment objects from OCDB for: %s",
36b010bf 1599 alObjsNotLoaded.Data()));
67dd5535 1600
9cb4fe0b 1601 return ApplyAlignObjsToGeom(alignObjArray);
67dd5535 1602}
1603
1604//_____________________________________________________________________________
36b010bf 1605Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray)
67dd5535 1606{
1607 // Adds the alignable objects found in the CDBEntry for the detector
1608 // passed as argument to the array of all alignment objects to be applyed
1609 // to geometry
1610 //
1611 // Fills array of single detector's alignable objects from CDB
1612
36b010bf 1613 AliDebugClass(2, Form("Loading alignment objs for detector: %s",detName));
67dd5535 1614
1615 AliCDBEntry *entry;
1616
1617 AliCDBPath path(detName,"Align","Data");
1618
1619 entry=AliCDBManager::Instance()->Get(path.GetPath());
1620 if(!entry){
36b010bf 1621 AliDebugClass(2,Form("Couldn't load alignment data for detector %s",detName));
67dd5535 1622 return kFALSE;
1623 }
1624 entry->SetOwner(1);
1625 TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
1626 alignArray->SetOwner(0);
4fbb8e9d 1627 Int_t nAlObjs = alignArray->GetEntries();
1628 AliDebugClass(2,Form("Found %d alignment objects for %s",nAlObjs,detName));
1629 Int_t nAlVols = GetNalignable(detName);
1630 if(nAlObjs!=nAlVols) AliWarningClass(Form("%d alignment objects loaded for %s, which has %d alignable volumes",nAlObjs,detName,GetNalignable(detName)));
67dd5535 1631
1632 AliAlignObj *alignObj=0;
1633 TIter iter(alignArray);
1634
1635 // loop over align objects in detector
1636 while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
36b010bf 1637 alignObjArray.Add(alignObj);
67dd5535 1638 }
1639 // delete entry --- Don't delete, it is cached!
1640
36b010bf 1641 AliDebugClass(2, Form("fAlignObjArray entries: %d",alignObjArray.GetEntries() ));
67dd5535 1642 return kTRUE;
1643
1644}
1645
1646//_____________________________________________________________________________
5590c6c3 1647Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray& alignObjArray, Bool_t ovlpcheck)
67dd5535 1648{
1649 // Read collection of alignment objects (AliAlignObj derived) saved
1650 // in the TClonesArray alObjArray and apply them to gGeoManager
1651 //
36b010bf 1652 alignObjArray.Sort();
1653 Int_t nvols = alignObjArray.GetEntriesFast();
67dd5535 1654
1655 Bool_t flag = kTRUE;
1656
1657 for(Int_t j=0; j<nvols; j++)
bb1970d8 1658 {
1659 AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
1660 flag = alobj->ApplyToGeometry(ovlpcheck);
1661 if(!flag)
67dd5535 1662 {
4fbb8e9d 1663 AliDebugClass(5,Form("Error applying alignment object for volume %s !",alobj->GetSymName()));
bb1970d8 1664 }else{
1665 AliDebugClass(5,Form("Alignment object for volume %s applied successfully",alobj->GetSymName()));
67dd5535 1666 }
1667
bb1970d8 1668 }
1669
1670 if (AliDebugLevelClass() > 5) {
1671 fgGeometry->CheckOverlaps(0.001);
36b010bf 1672 TObjArray* ovexlist = fgGeometry->GetListOfOverlaps();
67dd5535 1673 if(ovexlist->GetEntriesFast()){
36b010bf 1674 AliErrorClass("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
bb1970d8 1675 fgGeometry->PrintOverlaps();
67dd5535 1676 }
1677 }
1678
36b010bf 1679 // Update the TGeoPhysicalNodes
1680 fgGeometry->RefreshPhysicalNodes();
1681
67dd5535 1682 return flag;
1683
1684}
1685
1686//_____________________________________________________________________________
1687Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
1688{
1689 // read collection of alignment objects (AliAlignObj derived) saved
1690 // in the TClonesArray ClArrayName in the file fileName and apply
1691 // them to the geometry
1692 //
1693
1694 TFile* inFile = TFile::Open(fileName,"READ");
1695 if (!inFile || !inFile->IsOpen()) {
1696 AliErrorClass(Form("Could not open file %s !",fileName));
1697 return kFALSE;
1698 }
1699
36b010bf 1700 TClonesArray* alignObjArray = ((TClonesArray*) inFile->Get(clArrayName));
67dd5535 1701 inFile->Close();
36b010bf 1702 if (!alignObjArray) {
67dd5535 1703 AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
1704 return kFALSE;
1705 }
1706
36b010bf 1707 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1708
1709}
1710
1711//_____________________________________________________________________________
1712Bool_t AliGeomManager::ApplyAlignObjsToGeom(AliCDBParam* param, AliCDBId& Id)
1713{
1714 // read collection of alignment objects (AliAlignObj derived) saved
1715 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1716 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1717 // to the geometry
1718 //
1719
1720 AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(param);
1721 AliCDBEntry* entry = storage->Get(Id);
36b010bf 1722 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
67dd5535 1723
36b010bf 1724 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1725
1726}
1727
1728//_____________________________________________________________________________
1729Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
1730{
1731 // read collection of alignment objects (AliAlignObj derived) saved
1732 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1733 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1734 // to the geometry
1735 //
1736
1737 AliCDBParam* param = AliCDBManager::Instance()->CreateParameter(uri);
1738 AliCDBId id(path, runnum, runnum, version, sversion);
1739
1740 return ApplyAlignObjsToGeom(param, id);
1741
1742}
1743
1744//_____________________________________________________________________________
1745Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
1746{
1747 // read collection of alignment objects (AliAlignObj derived) saved
1748 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1749 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1750 // to the geometry
1751 //
1752
1753 AliCDBPath path(detName,"Align","Data");
1754 AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
1755
1756 if(!entry) return kFALSE;
36b010bf 1757 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
25fad4e5 1758
36b010bf 1759 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1760}
171c4ef9 1761
3564f2da 1762//_____________________________________________________________________________
1763void AliGeomManager::ResetPNEntriesLUT()
1764{
1765 // cleans static arrays containing the information on currently loaded geometry
1766 //
1767 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
1768 if (!fgPNEntry[iLayer]) continue;
1769 for (Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++) fgPNEntry[iLayer][modnum] = 0;
1770 }
1771 //
1772}
1773